Class CommandManager

new CommandManager(query: Query): CommandManager

apikeyadd(
    params: { cldbid?: number; lifetime?: number; scope: string },
): Promise<RawApiKey>

apikeydel(params: { id: number }): Promise<void>

apikeylist(
    params: {
        _count?: true;
        cldbid: number | "*";
        duration?: number;
        start?: number;
    },
): Promise<RawApiKey | RawApiKey[]>

banadd(
    params: {
        banreason?: string;
        ip?: string;
        lastnickname?: string;
        mytsid?: string;
        name?: string;
        time?: number;
        uid?: string;
    },
): Promise<void>

banclient(
    params: {
        _continueonerror?: true;
        banreason?: string;
        clid: number;
        time?: number;
    },
): Promise<{ banid: string } | { banid: string }[]>

bandel(params: { banid: number }): Promise<void>

bandelall(): Promise<void>

banlist(
    params?: { _count?: true; duration?: number; start?: number },
): Promise<RawBan | RawBan[]>

bindinglist(
    params: { subsystem?: "query" | "voice" | "filetransfer" },
): Promise<RawBinding | RawBinding[]>

channeladdperm(): void

channelclientaddperm(): void

channelclientdelperm(): void

channelclientpermlist(): void

channelcreate(
    params: {
        channel_codec?: number;
        channel_codec_quality?: number;
        channel_description?: string;
        channel_flag_default?: boolean;
        channel_flag_maxclients_unlimited?: boolean;
        channel_flag_maxfamilyclients_inherited?: boolean;
        channel_flag_maxfamilyclients_unlimited?: boolean;
        channel_flag_password?: boolean;
        channel_flag_permanent?: boolean;
        channel_flag_semi_permanent?: boolean;
        channel_flag_temporary?: boolean;
        channel_maxclients?: number;
        channel_maxfamilyclients?: number;
        channel_name: string;
        channel_name_phonetic?: string;
        channel_needed_talk_power?: number;
        channel_order?: number;
        channel_password?: string;
        channel_topic?: string;
    },
): Promise<{ cid: string }>

channeldelete(
    __namedParameters: { cid: number; force?: boolean },
): Promise<void>

channeldelperm(): void

channeledit(
    params: {
        channel_banner_gfx_url?: string;
        channel_banner_mode?: number;
        channel_codec?: number;
        channel_codec_is_unencrypted?: boolean;
        channel_codec_quality?: number;
        channel_delete_delay?: number;
        channel_description?: string;
        channel_flag_default?: boolean;
        channel_flag_maxclients_unlimited?: boolean;
        channel_flag_maxfamilyclients_inherited?: boolean;
        channel_flag_maxfamilyclients_unlimited?: boolean;
        channel_flag_permanent?: boolean;
        channel_flag_semi_permanent?: boolean;
        channel_icon_id?: number;
        channel_maxclients?: number;
        channel_maxfamilyclients?: number;
        channel_name?: string;
        channel_name_phonetic?: string;
        channel_needed_talk_power?: number;
        channel_order?: number;
        channel_password?: string;
        channel_topic?: string;
        cid: number;
        cpid?: number;
    },
): Promise<void>

channelfind(
    params: { pattern: string },
): Promise<RawChannelFindItem | RawChannelFindItem[]>

channelgroupadd(
    params: { name: string; type?: number },
): Promise<{ cgid: string }>

channelgroupaddperm(): void

channelgroupclientlist(): void

channelgroupcopy(
    params: { name?: string; scgid: number; tcgid?: number; type?: number },
): Promise<{ cgid: string }>

channelgroupdel(params: { cgid: number; force?: boolean }): Promise<void>

channelgroupdelperm(): void

channelgrouplist(): Promise<RawChannelGroup | RawChannelGroup[]>

channelgrouppermlist(): void

channelgrouprename(params: { cgid: number; name: string }): Promise<void>

channelinfo(params: { cid: number }): Promise<RawChannel>

channellist(
    params?: {
        _banners?: true;
        _flags?: true;
        _icon?: true;
        _limits?: true;
        _secondsempty?: true;
        _topic?: true;
        _voice?: true;
    },
): Promise<RawChannelListItem[]>

channelmove(
    params: { cid: number; cpid: number; order?: number },
): Promise<void>

channelpermlist(
    params: { _permsid?: true; cid: number },
): Promise<RawChannelPermission | RawChannelPermission[]>

clientaddperm(): void

clientdbdelete(params: { cldbid: number }): Promise<void>

clientdbedit(): void

clientdbfind(
    params: { _uid?: true; pattern: string },
): Promise<RawClientFindDatabaseItem | RawClientFindDatabaseItem[]>

clientdbinfo(params: { cldbid: number }): Promise<RawClientDbInfo>

clientdblist(
    params: { _count?: true; duration?: number; start?: number },
): Promise<RawDbClient | RawDbClient[]>

clientdelperm(): void

clientedit(
    params: {
        clid: number;
        client_description?: string;
        client_icon_id?: number;
        client_is_channel_commander?: boolean;
        client_is_talker?: boolean;
        client_nickname?: string;
    },
): Promise<void>

clientfind(
    params: { pattern: string },
): Promise<RawClientFindItem | RawClientFindItem[]>

clientgetdbidfromuid(params: { cluid: string }): Promise<RawClientDbid>

clientgetids(
    params: { cluid: string },
): Promise<RawClientIdsItem | RawClientIds>

clientgetnamefromdbid(params: { cldbid: number }): Promise<RawClientName>

clientgetnamefromuid(params: { cluid: string }): Promise<RawClientName>

clientgetuidfromclid(
    params: { clid: number },
): Promise<RawClientUid | RawClientUid[]>

clientinfo(params: { clid: number }): Promise<RawClient>

clientkick(
    params: {
        _continueonerror?: true;
        clid: number;
        reasonid: number;
        reasonmsg?: string;
    },
): Promise<void>

clientlist(
    params?: {
        _away?: true;
        _badges?: true;
        _country?: true;
        _groups?: true;
        _icon?: true;
        _info?: true;
        _ip?: true;
        _times?: true;
        _uid?: true;
        _voice?: true;
    },
): Promise<RawClient | RawClient[]>

clientmove(
    params: {
        _continueonerror?: true;
        cid: number;
        clid: number;
        cpw?: string;
    },
): Promise<void>

clientpermlist(
    params: { _permsid?: true; cldbid: number },
): Promise<RawClientPermission | RawClientPermission[]>

clientpoke(params: { clid: number; msg: string }): Promise<void>

clientsetserverquerylogin(
    params: { client_login_name: string },
): Promise<{ client_login_password: string }>

clientupdate(params: { client_nickname?: string }): Promise<void>

complainadd(params: { message: string; tcldbid: number }): Promise<void>

complaindel(params: { fcldbid: number; tcldbid: number }): Promise<void>

complaindelall(params: { tcldbid: number }): Promise<void>

complainlist(
    params?: { tcldbid?: number },
): Promise<RawComplain | RawComplain[]>

customdelete(): void

custominfo(): void

customsearch(): void

customset(): void

ftcreatedir(): void

ftdeletefile(): void

ftgetfileinfo(): void

ftgetfilelist(): void

ftinitdownload(): void

ftinitupload(): void

ftlist(): void

ftrenamefile(): void

ftstop(): void

gm(params: { msg: string }): Promise<void>

help(): void

hostinfo(): Promise<RawHostInfo>

instanceedit(): void

instanceinfo(): Promise<RawInstance>

logadd(params: { loglevel: number; logmsg: string }): Promise<void>

login(
    params: { client_login_name: string; client_login_password: string },
): Promise<void>

logout(): Promise<void>

logview(
    params?: {
        begin_pos?: number;
        instance?: boolean;
        lines?: number;
        reverse?: boolean;
    },
): Promise<RawLogView | RawLogViewItem[]>

messageadd(): void

messagedel(): void

messageget(): void

messagelist(): void

messageupdateflag(): void

permfind(): void

permget(): void

permidgetbyname(
    params: { permsid: string },
): Promise<{ permid: string; permsid: string }>

permissionlist(): Promise<RawPermission[]>

permoverview(): void

permreset(): void

privilegekeyadd(
    params: {
        customset?: string;
        tokendescription?: string;
        tokenid1: number;
        tokenid2: number;
        tokentype: number;
    },
): Promise<{ token: string }>

privilegekeydelete(params: { token: string }): Promise<void>

privilegekeylist(): Promise<RawPrivilegeKey | RawPrivilegeKey[]>

privilegekeyuse(params: { token: string }): Promise<void>

queryloginadd(
    params: { cldbid: number; client_login_name: string },
): Promise<RawQueryLoginAdd>

querylogindel(params: { cldbid: number }): Promise<void>

queryloginlist(
    params: {
        _count?: true;
        duration?: number;
        pattern?: string;
        start?: number;
    },
): Promise<RawQueryLogin | RawQueryLogin[]>

quit(): void

sendtextmessage(
    params: { msg: string; target: number; targetmode: number },
): Promise<void>

servercreate(
    params: {
        virtualserver_autostart?: boolean;
        virtualserver_codec_encryption_mode?: string;
        virtualserver_default_channel_group?: number;
        virtualserver_default_server_group?: number;
        virtualserver_encryption_ciphers?: string;
        virtualserver_hostbanner_gfx_interval?: number;
        virtualserver_hostbanner_gfx_url?: string;
        virtualserver_hostbanner_url?: string;
        virtualserver_hostmessage?: string;
        virtualserver_hostmessage_mode?: number;
        virtualserver_machine_id?: string;
        virtualserver_maxclients?: number;
        virtualserver_name: string;
        virtualserver_password?: string;
        virtualserver_port?: number;
        virtualserver_weblist_enabled?: boolean;
        virtualserver_welcomemessage?: string;
    },
): Promise<RawCreatedVirtualServer>

serverdelete(params: { sid: number }): Promise<void>

serveredit(
    params: {
        virtualserver_antiflood_points_needed_command_block?: number;
        virtualserver_antiflood_points_needed_ip_block?: number;
        virtualserver_antiflood_points_needed_plugin_block?: number;
        virtualserver_antiflood_points_tick_reduce?: number;
        virtualserver_autostart?: boolean;
        virtualserver_codec_encryption_mode?: string;
        virtualserver_complain_autoban_count?: number;
        virtualserver_complain_autoban_time?: number;
        virtualserver_complain_remove_time?: number;
        virtualserver_default_channel_admin_group?: number;
        virtualserver_default_channel_group?: number;
        virtualserver_default_server_group?: number;
        virtualserver_download_quota?: number;
        virtualserver_hostbanner_gfx_interval?: number;
        virtualserver_hostbanner_gfx_url?: string;
        virtualserver_hostbanner_mode?: number;
        virtualserver_hostbanner_url?: string;
        virtualserver_hostbutton_gfx_url?: string;
        virtualserver_hostbutton_tooltip?: string;
        virtualserver_hostbutton_url?: string;
        virtualserver_hostmessage?: string;
        virtualserver_hostmessage_mode?: number;
        virtualserver_icon_id?: number;
        virtualserver_log_channel?: boolean;
        virtualserver_log_client?: boolean;
        virtualserver_log_filetransfer?: boolean;
        virtualserver_log_permissions?: boolean;
        virtualserver_log_query?: boolean;
        virtualserver_log_server?: boolean;
        virtualserver_max_download_total_bandwidth?: number;
        virtualserver_max_upload_total_bandwidth?: number;
        virtualserver_maxclients?: number;
        virtualserver_min_android_version?: number;
        virtualserver_min_client_version?: number;
        virtualserver_min_clients_in_channel_before_forced_silence?: number;
        virtualserver_min_ios_version?: number;
        virtualserver_name?: string;
        virtualserver_name_phonetic?: string;
        virtualserver_needed_identity_security_level?: number;
        virtualserver_password?: string;
        virtualserver_port?: number;
        virtualserver_priority_speaker_dimm_modificator?: number;
        virtualserver_reserved_slots?: number;
        virtualserver_status?: string;
        virtualserver_upload_quota?: number;
        virtualserver_weblist_enabled?: boolean;
        virtualserver_welcomemessage?: string;
    },
): Promise<void>

servergroupadd(
    params: { name: string; type?: number },
): Promise<{ sgid: string }>

servergroupaddclient(
    params: { _continueonerror?: true; cldbid: number; sgid: number },
): Promise<void>

servergroupaddperm(
    params: {
        permid?: number;
        permnegated?: boolean;
        permsid?: string;
        permskip?: boolean;
        permvalue?: number;
        sgid: number;
    },
): Promise<void>

servergroupautoaddperm(): void

servergroupautodelperm(): void

servergroupclientlist(
    params: { _names?: true; sgid: number },
): Promise<
    RawServerGroupClientListItem
    | RawServerGroupClientListItem[]
    | null,
>

servergroupcopy(
    params: {
        name?: string;
        ssgid: number;
        tsgid?: number;
        type?: ServerGroupType;
    },
): Promise<{ sgid: string }>

servergroupdel(params: { force?: boolean; sgid: number }): Promise<void>

servergroupdelclient(
    params: { _continueonerror?: true; cldbid: number; sgid: number },
): Promise<void>

servergroupdelperm(
    params: {
        _continueonerror?: true;
        permid?: number;
        permsid?: string;
        sgid: number;
    },
): Promise<void>

servergrouplist(): Promise<RawServerGroup | RawServerGroup[]>

servergrouppermlist(
    params: { _continueonerror?: true; _permsid?: true; sgid: number },
): Promise<RawAssignedPermission | RawAssignedPermission[]>

servergrouprename(params: { name: string; sgid: number }): Promise<void>

servergroupsbyclientid(
    params: { cldbid: number },
): Promise<RawClientServerGroup | RawClientServerGroup[]>

serveridgetbyport(
    params: { virtualserver_port: number },
): Promise<{ server_id: string }>

serverinfo(): Promise<RawVirtualServer>

serverlist(
    params?: {
        _all?: true;
        _onlyoffline?: true;
        _short?: true;
        _uid?: true;
    },
): Promise<RawVirtualServerListItem[]>

servernotifyregister(params: { event: string; id?: number }): Promise<void>

servernotifyunregister(): Promise<void>

serverprocessstop(params: { reasonmsg?: string }): Promise<void>

serverrequestconnectioninfo(): Promise<RawServerConnectionInfo>

serversnapshotcreate(): Promise<RawServerSnapshot>

serversnapshotdeploy(
    params: {
        _keepfiles?: true;
        _mapping?: true;
        data: string;
        password?: string;
        salt?: string;
        version: number;
    },
): Promise<unknown>

serverstart(params: { sid: number }): Promise<void>

serverstop(params: { reasonmsg?: string; sid: number }): Promise<void>

servertemppasswordadd(
    params: {
        desc: string;
        duration: number;
        pw: string;
        tcid?: string;
        tcpw?: string;
    },
): Promise<void>

servertemppassworddel(params: { pw: string }): Promise<void>

servertemppasswordlist(): Promise<
    RawServerTempPassword
    | RawServerTempPassword[],
>

setclientchannelgroup(
    params: { cgid: number; cid: number; cldbid: number },
): Promise<void>

tokenadd(): void

tokendelete(): void

tokenlist(): void

tokenuse(): void

use(
    params: { client_nickname?: string; port?: number; sid?: number },
): Promise<void>

version(): Promise<RawVersion>