TeaSpeak-Client/modules/renderer/imports/.copy_imports_shared.d.ts

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/audio/audio.ts */
declare namespace audio {
    export namespace player {
        export interface Device {
            device_id: string;
            driver: string;
            name: string;
        }
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/bookmarks.ts */
declare namespace bookmarks {
    export const boorkmak_connect;
    export interface ServerProperties {
        server_address: string;
        server_port: number;
        server_password_hash?: string;
        server_password?: string;
    }
    export enum BookmarkType {
        ENTRY,
        DIRECTORY
    }
    export interface Bookmark {
        type: BookmarkType;
        /* readonly */ parent: DirectoryBookmark;
        server_properties: ServerProperties;
        display_name: string;
        unique_id: string;
        nickname: string;
        default_channel?: number | string;
        default_channel_password_hash?: string;
        default_channel_password?: string;
        connect_profile: string;
        last_icon_id?: number;
    }
    export interface DirectoryBookmark {
        type: BookmarkType;
        /* readonly */ parent: DirectoryBookmark;
        readonly content: (Bookmark | DirectoryBookmark)[];
        unique_id: string;
        display_name: string;
    }
    export function bookmarks(): DirectoryBookmark;
    export function bookmarks_flat(): Bookmark[];
    export function find_bookmark(uuid: string): Bookmark | DirectoryBookmark | undefined;
    export function parent_bookmark(bookmark: Bookmark): DirectoryBookmark;
    export function create_bookmark(display_name: string, directory: DirectoryBookmark, server_properties: ServerProperties, nickname: string): Bookmark;
    export function create_bookmark_directory(parent: DirectoryBookmark, name: string): DirectoryBookmark;
    //TODO test if the new parent is within the old bookmark
    export function change_directory(parent: DirectoryBookmark, bookmark: Bookmark | DirectoryBookmark);
    export function save_bookmark(bookmark?: Bookmark | DirectoryBookmark);
    export function delete_bookmark(bookmark: Bookmark | DirectoryBookmark);
    export function add_current_server();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/BrowserIPC.ts */
declare interface Window {
    BroadcastChannel: BroadcastChannel;
}
declare namespace bipc {
    export interface BroadcastMessage {
        timestamp: number;
        receiver: string;
        sender: string;
        type: string;
        data: any;
    }
    export interface ChannelMessage {
        channel_id: string;
        key: string;
        message: any;
    }
    export interface ProcessQueryResponse {
        request_timestamp: number;
        request_query_id: string;
        device_id: string;
        protocol: number;
    }
    export interface CertificateAcceptCallback {
        request_id: string;
    }
    export interface CertificateAcceptSucceeded {
    }
    export abstract class BasicIPCHandler {
        protected static readonly BROADCAST_UNIQUE_ID;
        protected static readonly PROTOCOL_VERSION;
        protected _channels: Channel[];
        protected unique_id;
        protected constructor();
        setup();
        get_local_address();
        abstract send_message(type: string, data: any, target?: string);
        protected handle_message(message: BroadcastMessage);
        create_channel(target_id?: string, channel_id?: string);
        channels(): Channel[];
        delete_channel(channel: Channel);
        private _query_results: {
            [key: string]: ProcessQueryResponse[];
        };
        query_processes(timeout?: number): Promise<ProcessQueryResponse[]>;
        private _cert_accept_callbacks: {
            [key: string]: (() => any);
        };
        register_certificate_accept_callback(callback: () => any): string;
        private _cert_accept_succeeded: {
            [sender: string]: (() => any);
        };
        post_certificate_accpected(id: string, timeout?: number): Promise<void>;
    }
    export interface Channel {
        readonly channel_id: string;
        target_id?: string;
        message_handler: (remote_id: string, message: ChannelMessage) => any;
        send_message(key: string, message: any);
    }
    export class BroadcastChannelIPC extends BasicIPCHandler {
        private static readonly CHANNEL_NAME;
        private channel: BroadcastChannel;
        constructor();
        setup();
        private on_message(event: MessageEvent);
        private on_error(event: MessageEvent);
        send_message(type: string, data: any, target?: string);
    }
    export interface MethodProxyInvokeData {
        method_name: string;
        arguments: any[];
        promise_id: string;
    }
    export interface MethodProxyResultData {
        promise_id: string;
        result: any;
        success: boolean;
    }
    export interface MethodProxyCallback {
        promise: Promise<any>;
        promise_id: string;
        resolve: (object: any) => any;
        reject: (object: any) => any;
    }
    export type MethodProxyConnectParameters = {
        channel_id: string;
        client_id: string;
    };
    export abstract class MethodProxy {
        readonly ipc_handler: BasicIPCHandler;
        private _ipc_channel: Channel;
        private _ipc_parameters: MethodProxyConnectParameters;
        private readonly _local: boolean;
        private readonly _slave: boolean;
        private _connected: boolean;
        private _proxied_methods: {
            [key: string]: () => Promise<any>;
        };
        private _proxied_callbacks: {
            [key: string]: MethodProxyCallback;
        };
        protected constructor(ipc_handler: BasicIPCHandler, connect_params?: MethodProxyConnectParameters);
        protected setup();
        protected finalize();
        protected register_method<R>(method: (...args: any[]) => Promise<R> | string);
        private _handle_message(remote_id: string, message: ChannelMessage);
        private _handle_finalize();
        private _handle_remote_callback(remote_id: string);
        private _send_result(promise_id: string, success: boolean, message: any);
        private _handle_invoke(data: MethodProxyInvokeData);
        private _handle_result(data: MethodProxyResultData);
        generate_connect_parameters(): MethodProxyConnectParameters;
        is_slave();
        is_master();
        protected abstract on_connected();
        protected abstract on_disconnected();
    }
    export function setup();
    export function get_handler();
    export function supported();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/connection/CommandHandler.ts */
declare namespace connection {
    export class ServerConnectionCommandBoss extends AbstractCommandHandlerBoss {
        constructor(connection: AbstractServerConnection);
    }
    export class ConnectionCommandHandler extends AbstractCommandHandler {
        readonly connection: AbstractServerConnection;
        readonly connection_handler: ConnectionHandler;
        constructor(connection: AbstractServerConnection);
        proxy_command_promise(promise: Promise<CommandResult>, options: connection.CommandOptions);
        handle_command(command: ServerCommand): boolean;
        set_handler(command: string, handler: any);
        unset_handler(command: string, handler?: any);
        handleCommandResult(json);
        handleCommandServerInit(json);
        handleNotifyServerConnectionInfo(json);
        handleNotifyConnectionInfo(json);
        private createChannelFromJson(json, ignoreOrder?: boolean);
        handleCommandChannelList(json);
        handleCommandChannelListFinished(json);
        handleCommandChannelCreate(json);
        handleCommandChannelShow(json);
        handleCommandChannelDelete(json);
        handleCommandChannelHide(json);
        handleCommandClientEnterView(json);
        handleCommandClientLeftView(json);
        handleNotifyClientMoved(json);
        handleNotifyChannelMoved(json);
        handleNotifyChannelEdited(json);
        handleNotifyTextMessage(json);
        notifyClientChatComposing(json);
        handleNotifyClientChatClosed(json);
        handleNotifyClientUpdated(json);
        handleNotifyServerEdited(json);
        handleNotifyServerUpdated(json);
        handleNotifyMusicPlayerInfo(json);
        handleNotifyClientPoke(json);
        //TODO server chat message
        handleNotifyServerGroupClientAdd(json);
        //TODO server chat message
        handleNotifyServerGroupClientRemove(json);
        //TODO server chat message
        handleNotifyClientChannelGroupChanged(json);
        handleNotifyChannelSubscribed(json);
        handleNotifyChannelUnsubscribed(json);
        handleNotifyConversationHistory(json: any[]);
        handleNotifyConversationMessageDelete(json: any[]);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/connection/CommandHelper.ts */
declare namespace connection {
    export class CommandHelper extends AbstractCommandHandler {
        private _who_am_i: any;
        private _awaiters_unique_ids: {
            [unique_id: string]: ((resolved: ClientNameInfo) => any)[];
        };
        constructor(connection);
        initialize();
        destroy();
        handle_command(command: connection.ServerCommand): boolean;
        joinChannel(channel: ChannelEntry, password?: string): Promise<CommandResult>;
        sendMessage(message: string, type: ChatType, target?: ChannelEntry | ClientEntry): Promise<CommandResult>;
        updateClient(key: string, value: string): Promise<CommandResult>;
        info_from_uid(..._unique_ids: string[]): Promise<ClientNameInfo[]>;
        private handle_notifyclientnamefromuid(json: any[]);
        request_query_list(server_id?: number): Promise<QueryList>;
        request_playlist_list(): Promise<Playlist[]>;
        request_playlist_songs(playlist_id: number): Promise<PlaylistSong[]>;
        request_clients_by_server_group(group_id: number): Promise<ServerGroupClient[]>;
        request_playlist_info(playlist_id: number): Promise<PlaylistInfo>;
        /**
         * @deprecated
         *  Its just a workaround for the query management.
         *  There is no garante that the whoami trick will work forever
         */
        current_virtual_server_id(): Promise<number>;
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/connection/ConnectionBase.ts */
declare namespace connection {
    export interface CommandOptions {
        flagset?: string[];
        process_result?: boolean;
        timeout?: number /* default: 1000 */;
    }
    export const CommandOptionDefaults: CommandOptions;
    export type ConnectionStateListener = (old_state: ConnectionState, new_state: ConnectionState) => any;
    export abstract class AbstractServerConnection {
        readonly client: ConnectionHandler;
        readonly command_helper: CommandHelper;
        protected constructor(client: ConnectionHandler);
        /* resolved as soon a connection has been established. This does not means that the authentication had yet been done! */
        abstract connect(address: ServerAddress, handshake: HandshakeHandler, timeout?: number): Promise<void>;
        abstract connected(): boolean;
        abstract disconnect(reason?: string): Promise<void>;
        abstract support_voice(): boolean;
        abstract voice_connection(): voice.AbstractVoiceConnection | undefined;
        abstract command_handler_boss(): AbstractCommandHandlerBoss;
        abstract send_command(command: string, data?: any | any[], options?: CommandOptions): Promise<CommandResult>;
        // @ts-ignore
        abstract get onconnectionstatechanged(): ConnectionStateListener;
        // @ts-ignore
        abstract set onconnectionstatechanged(listener: ConnectionStateListener);
        abstract remote_address(): ServerAddress;
        abstract handshake_handler(): HandshakeHandler;
        abstract ping(): {
            native: number;
            javascript?: number;
        };
    }
    export namespace voice {
        export enum PlayerState {
            PREBUFFERING,
            PLAYING,
            BUFFERING,
            STOPPING,
            STOPPED
        }
        export interface VoiceClient {
            client_id: number;
            callback_playback: () => any;
            callback_stopped: () => any;
            callback_state_changed: (new_state: PlayerState) => any;
            get_state(): PlayerState;
            get_volume(): number;
            set_volume(volume: number): void;
            abort_replay();
        }
        export abstract class AbstractVoiceConnection {
            readonly connection: AbstractServerConnection;
            protected constructor(connection: AbstractServerConnection);
            abstract connected(): boolean;
            abstract encoding_supported(codec: number): boolean;
            abstract decoding_supported(codec: number): boolean;
            abstract register_client(client_id: number): VoiceClient;
            abstract available_clients(): VoiceClient[];
            abstract unregister_client(client: VoiceClient): Promise<void>;
            abstract voice_recorder(): RecorderProfile;
            abstract acquire_voice_recorder(recorder: RecorderProfile | undefined): Promise<void>;
        }
    }
    export class ServerCommand {
        command: string;
        arguments: any[];
    }
    export abstract class AbstractCommandHandler {
        readonly connection: AbstractServerConnection;
        handler_boss: AbstractCommandHandlerBoss | undefined;
        volatile_handler_boss: boolean;
        ignore_consumed: boolean;
        protected constructor(connection: AbstractServerConnection);
        /**
         * @return If the command should be consumed
         */
        abstract handle_command(command: ServerCommand): boolean;
    }
    export interface SingleCommandHandler {
        name?: string;
        command?: string;
        timeout?: number;
        /* if the return is true then the command handler will be removed */
        function: (command: ServerCommand) => boolean;
    }
    export abstract class AbstractCommandHandlerBoss {
        readonly connection: AbstractServerConnection;
        protected command_handlers: AbstractCommandHandler[];
        /* TODO: Timeout */
        protected single_command_handler: SingleCommandHandler[];
        protected constructor(connection: AbstractServerConnection);
        destroy();
        register_handler(handler: AbstractCommandHandler);
        unregister_handler(handler: AbstractCommandHandler);
        register_single_handler(handler: SingleCommandHandler);
        remove_single_handler(handler: SingleCommandHandler);
        handlers(): AbstractCommandHandler[];
        invoke_handle(command: ServerCommand): boolean;
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/connection/HandshakeHandler.ts */
declare namespace connection {
    export interface HandshakeIdentityHandler {
        connection: AbstractServerConnection;
        start_handshake();
        register_callback(callback: (success: boolean, message?: string) => any);
    }
    export class HandshakeHandler {
        private connection: AbstractServerConnection;
        private handshake_handler: HandshakeIdentityHandler;
        private failed;
        readonly profile: profiles.ConnectionProfile;
        readonly parameters: ConnectParameters;
        constructor(profile: profiles.ConnectionProfile, parameters: ConnectParameters);
        setConnection(con: AbstractServerConnection);
        initialize();
        get_identity_handler(): HandshakeIdentityHandler;
        startHandshake();
        on_teamspeak();
        private handshake_failed(message: string);
        private handshake_finished(version?: string);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/connection/ServerConnectionDeclaration.ts */
declare enum ErrorID {
    PERMISSION_ERROR = 2568,
    EMPTY_RESULT = 0x0501,
    PLAYLIST_IS_IN_USE = 0x2103,
    FILE_ALREADY_EXISTS = 2050,
    CLIENT_INVALID_ID = 0x0200,
    CONVERSATION_INVALID_ID = 0x2200,
    CONVERSATION_MORE_DATA = 0x2201,
    CONVERSATION_IS_PRIVATE = 0x2202
}
declare class CommandResult {
    success: boolean;
    id: number;
    message: string;
    extra_message: string;
    json: any;
    constructor(json);
}
declare interface ClientNameInfo {
    //cluid=tYzKUryn\/\/Y8VBMf8PHUT6B1eiE= name=Exp clname=Exp cldbid=9
    client_unique_id: string;
    client_nickname: string;
    client_database_id: number;
}
declare interface ClientNameFromUid {
    promise: LaterPromise<ClientNameInfo[]>;
    keys: string[];
    response: ClientNameInfo[];
}
declare interface ServerGroupClient {
    client_nickname: string;
    client_unique_identifier: string;
    client_database_id: number;
}
declare interface QueryListEntry {
    username: string;
    unique_id: string;
    bounded_server: number;
}
declare interface QueryList {
    flag_own: boolean;
    flag_all: boolean;
    queries: QueryListEntry[];
}
declare interface Playlist {
    playlist_id: number;
    playlist_bot_id: number;
    playlist_title: string;
    playlist_type: number;
    playlist_owner_dbid: number;
    playlist_owner_name: string;
    needed_power_modify: number;
    needed_power_permission_modify: number;
    needed_power_delete: number;
    needed_power_song_add: number;
    needed_power_song_move: number;
    needed_power_song_remove: number;
}
declare interface PlaylistInfo {
    playlist_id: number;
    playlist_title: string;
    playlist_description: string;
    playlist_type: number;
    playlist_owner_dbid: number;
    playlist_owner_name: string;
    playlist_flag_delete_played: boolean;
    playlist_flag_finished: boolean;
    playlist_replay_mode: number;
    playlist_current_song_id: number;
}
declare interface PlaylistSong {
    song_id: number;
    song_previous_song_id: number;
    song_invoker: string;
    song_url: string;
    song_url_loader: string;
    song_loaded: boolean;
    song_metadata: string;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ConnectionHandler.ts */
declare enum DisconnectReason {
    HANDLER_DESTROYED,
    REQUESTED,
    DNS_FAILED,
    CONNECT_FAILURE,
    CONNECTION_CLOSED,
    CONNECTION_FATAL_ERROR,
    CONNECTION_PING_TIMEOUT,
    CLIENT_KICKED,
    CLIENT_BANNED,
    HANDSHAKE_FAILED,
    HANDSHAKE_TEAMSPEAK_REQUIRED,
    HANDSHAKE_BANNED,
    SERVER_CLOSED,
    SERVER_REQUIRES_PASSWORD,
    SERVER_HOSTMESSAGE,
    IDENTITY_TOO_LOW,
    UNKNOWN
}
declare enum ConnectionState {
    UNCONNECTED,
    CONNECTING,
    INITIALISING,
    CONNECTED,
    DISCONNECTING
}
declare enum ViewReasonId {
    VREASON_USER_ACTION = 0,
    VREASON_MOVED = 1,
    VREASON_SYSTEM = 2,
    VREASON_TIMEOUT = 3,
    VREASON_CHANNEL_KICK = 4,
    VREASON_SERVER_KICK = 5,
    VREASON_BAN = 6,
    VREASON_SERVER_STOPPED = 7,
    VREASON_SERVER_LEFT = 8,
    VREASON_CHANNEL_UPDATED = 9,
    VREASON_EDITED = 10,
    VREASON_SERVER_SHUTDOWN = 11
}
declare interface VoiceStatus {
    input_hardware: boolean;
    input_muted: boolean;
    output_muted: boolean;
    channel_codec_encoding_supported: boolean;
    channel_codec_decoding_supported: boolean;
    sound_playback_supported: boolean;
    sound_record_supported;
    away: boolean | string;
    channel_subscribe_all: boolean;
    queries_visible: boolean;
}
declare interface ConnectParameters {
    nickname?: string;
    channel?: {
        target: string | number;
        password?: string;
    };
    token?: string;
    password?: {
        password: string;
        hashed: boolean;
    };
}
declare class ConnectionHandler {
    channelTree: ChannelTree;
    serverConnection: connection.AbstractServerConnection;
    fileManager: FileManager;
    permissions: PermissionManager;
    groups: GroupManager;
    side_bar: chat.Frame;
    settings: ServerSettings;
    sound: sound.SoundManager;
    hostbanner: Hostbanner;
    tag_connection_handler: JQuery;
    private _clientId: number;
    private _local_client: LocalClientEntry;
    private _reconnect_timer: NodeJS.Timer;
    private _reconnect_attempt: boolean;
    private _connect_initialize_id: number;
    client_status: VoiceStatus;
    invoke_resized_on_activate: boolean;
    log: log.ServerLog;
    constructor();
    tab_set_name(name: string);
    setup();
    startConnection(addr: string, profile: profiles.ConnectionProfile, user_action: boolean, parameters: ConnectParameters);
    getClient(): LocalClientEntry;
    getClientId();
    // @ts-ignore
    set clientId(id: number);
    // @ts-ignore
    get clientId();
    getServerConnection(): connection.AbstractServerConnection;
    /**
     * LISTENER
     */
    onConnected();
    private initialize_server_settings();
    // @ts-ignore
    get connected(): boolean;
    private generate_ssl_certificate_accept(): JQuery;
    private _certificate_modal: Modal;
    handleDisconnect(type: DisconnectReason, data?: any);
    cancel_reconnect(log_event: boolean);
    private on_connection_state_changed();
    update_voice_status(targetChannel?: ChannelEntry);
    sync_status_with_server();
    set_away_status(state: boolean | string);
    resize_elements();
    acquire_recorder(voice_recoder: RecorderProfile, update_control_bar: boolean);
    reconnect_properties(profile?: profiles.ConnectionProfile): ConnectParameters;
    update_avatar();
    destroy();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/crypto/asn1.ts */
declare namespace asn1 {
    export class Int10 {
        constructor(value?: any);
        sub(sub: number);
        mulAdd(mul: number, add: number);
        simplify();
    }
    export class Stream {
        private static HEX_DIGITS;
        private static reTimeS;
        private static reTimeL;
        position: number;
        data: string | ArrayBuffer;
        constructor(data: string | Stream | ArrayBuffer, position: number);
        length(): number;
        get(position?: number);
        hexByte(byte: number);
        parseStringISO(start, end);
        parseStringUTF(start, end);
        parseStringBMP(start, end);
        parseTime(start, end, shortYear);
        parseInteger(start, end);
        isASCII(start: number, end: number);
        parseBitString(start, end, maxLength);
        parseOctetString(start, end, maxLength);
        parseOID(start, end, maxLength);
    }
    export enum TagClass {
        UNIVERSAL = 0x00,
        APPLICATION = 0x01,
        CONTEXT = 0x02,
        PRIVATE = 0x03
    }
    export enum TagType {
        EOC = 0x00,
        BOOLEAN = 0x01,
        INTEGER = 0x02,
        BIT_STRING = 0x03,
        OCTET_STRING = 0x04,
        NULL = 0x05,
        OBJECT_IDENTIFIER = 0x06,
        ObjectDescriptor = 0x07,
        EXTERNAL = 0x08,
        REAL = 0x09,
        ENUMERATED = 0x0A,
        EMBEDDED_PDV = 0x0B,
        UTF8String = 0x0C,
        SEQUENCE = 0x10,
        SET = 0x11,
        NumericString = 0x12,
        PrintableString = 0x13,
        TeletextString = 0x14,
        VideotexString = 0x15,
        IA5String = 0x16,
        UTCTime = 0x17,
        GeneralizedTime = 0x18,
        GraphicString = 0x19,
        VisibleString = 0x1A,
        GeneralString = 0x1B,
        UniversalString = 0x1C,
        BMPString = 0x1E
    }
    export class ASN1Tag {
        tagClass: TagClass;
        type: TagType;
        tagConstructed: boolean;
        tagNumber: number;
        constructor(stream: Stream);
        isUniversal();
        isEOC();
    }
    export class ASN1 {
        stream: Stream;
        header: number;
        length: number;
        tag: ASN1Tag;
        children: ASN1[];
        constructor(stream: Stream, header: number, length: number, tag: ASN1Tag, children: ASN1[]);
        content(max_length?: number, type?: TagType);
        typeName(): string;
        toString();
        toPrettyString(indent);
        posStart();
        posContent();
        posEnd();
        static decodeLength(stream: Stream);
        static encodeLength(buffer: Uint8Array, offset: number, length: number);
    }
    export function decode(stream: string | ArrayBuffer);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/crypto/crc32.ts */
declare class Crc32 {
    private static readonly lookup;
    private crc: number;
    constructor();
    update(data: ArrayBufferLike);
    digest(radix: number);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/crypto/hex.ts */
declare namespace hex {
    export function encode(buffer);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/crypto/sha.ts */
declare function define($);
declare function unescape(string: string): string;
declare class _sha1 {
    static arrayBuffer($: ArrayBuffer): ArrayBuffer;
}
declare namespace sha {
    export function encode_text(buffer: string): ArrayBuffer;
    export function sha1(message: string | ArrayBuffer): PromiseLike<ArrayBuffer>;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/dns.ts */
declare namespace dns {
    export interface AddressTarget {
        target_ip: string;
        target_port?: number;
    }
    export interface ResolveOptions {
        timeout?: number;
        allow_cache?: boolean;
        max_depth?: number;
        allow_srv?: boolean;
        allow_cname?: boolean;
        allow_any?: boolean;
        allow_a?: boolean;
        allow_aaaa?: boolean;
    }
    export const default_options: ResolveOptions;
    export function supported();
    export function resolve_address(address: string, options?: ResolveOptions): Promise<AddressTarget>;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/events.ts */
declare namespace event {
    namespace global { }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/FileManager.ts */
declare class FileEntry {
    name: string;
    datetime: number;
    type: number;
    size: number;
}
declare class FileListRequest {
    path: string;
    entries: FileEntry[];
    callback: (entries: FileEntry[]) => void;
}
declare namespace transfer {
    export interface TransferKey {
        client_transfer_id: number;
        server_transfer_id: number;
        key: string;
        file_path: string;
        file_name: string;
        peer: {
            hosts: string[];
            port: number;
        };
        total_size: number;
    }
    export interface UploadOptions {
        name: string;
        path: string;
        channel?: ChannelEntry;
        channel_password?: string;
        size: number;
        overwrite: boolean;
    }
    export interface DownloadTransfer {
        get_key(): DownloadKey;
        request_file(): Promise<Response>;
    }
    export interface UploadTransfer {
        get_key(): UploadKey;
        put_data(data: BlobPart | File): Promise<void>;
    }
    export type DownloadKey = TransferKey;
    export type UploadKey = TransferKey;
    export function spawn_download_transfer(key: DownloadKey): DownloadTransfer;
    export function spawn_upload_transfer(key: UploadKey): UploadTransfer;
}
declare class RequestFileDownload implements transfer.DownloadTransfer {
    readonly transfer_key: transfer.DownloadKey;
    constructor(key: transfer.DownloadKey);
    request_file(): Promise<Response>;
    private try_fetch(url: string): Promise<Response>;
    get_key(): transfer.DownloadKey;
}
declare class RequestFileUpload implements transfer.UploadTransfer {
    readonly transfer_key: transfer.UploadKey;
    constructor(key: transfer.DownloadKey);
    get_key(): transfer.UploadKey;
    put_data(data: BlobPart | File): Promise<void>;
    private try_put(data: FormData, url: string): Promise<void>;
}
declare class FileManager extends connection.AbstractCommandHandler {
    handle: ConnectionHandler;
    icons: IconManager;
    avatars: AvatarManager;
    private listRequests: FileListRequest[];
    private pending_download_requests: transfer.DownloadKey[];
    private pending_upload_requests: transfer.UploadKey[];
    private transfer_counter: number;
    constructor(client: ConnectionHandler);
    destroy();
    handle_command(command: connection.ServerCommand): boolean;
    /******************************** File list ********************************/
    //TODO multiple requests (same path)
    requestFileList(path: string, channel?: ChannelEntry, password?: string): Promise<FileEntry[]>;
    private notifyFileList(json);
    private notifyFileListFinished(json);
    /******************************** File download/upload ********************************/
    download_file(path: string, file: string, channel?: ChannelEntry, password?: string): Promise<transfer.DownloadKey>;
    upload_file(options: transfer.UploadOptions): Promise<transfer.UploadKey>;
    private notifyStartDownload(json);
    private notifyStartUpload(json);
    delete_file(props: {
        name: string;
        path?: string;
        cid?: number;
        cpw?: string;
    }): Promise<void>;
}
declare class Icon {
    id: number;
    url: string;
}
declare enum ImageType {
    UNKNOWN,
    BITMAP,
    PNG,
    GIF,
    SVG,
    JPEG
}
declare function media_image_type(type: ImageType, file?: boolean);
declare function image_type(encoded_data: string | ArrayBuffer, base64_encoded?: boolean);
declare class CacheManager {
    readonly cache_name: string;
    private _cache_category: Cache;
    constructor(name: string);
    setupped(): boolean;
    reset();
    setup();
    cleanup(max_age: number);
    resolve_cached(key: string, max_age?: number): Promise<Response | undefined>;
    put_cache(key: string, value: Response, type?: string, headers?: {
        [key: string]: string;
    });
    delete(key: string);
}
declare class IconManager {
    private static cache: CacheManager;
    handle: FileManager;
    private _id_urls: {
        [id: number]: string;
    };
    private _loading_promises: {
        [id: number]: Promise<Icon>;
    };
    constructor(handle: FileManager);
    destroy();
    clear_cache();
    delete_icon(id: number): Promise<void>;
    iconList(): Promise<FileEntry[]>;
    create_icon_download(id: number): Promise<transfer.DownloadKey>;
    private static _response_url(response: Response);
    resolved_cached?(id: number): Promise<Icon>;
    private static _static_id_url: {
        [icon: number]: string;
    };
    private static _static_cached_promise: {
        [icon: number]: Promise<Icon>;
    };
    static load_cached_icon(id: number, ignore_age?: boolean): Promise<Icon> | Icon;
    private _load_icon(id: number): Promise<Icon>;
    download_icon(id: number): Promise<Icon>;
    resolve_icon(id: number): Promise<Icon>;
    static generate_tag(icon: Promise<Icon> | Icon, options?: {
        animate?: boolean;
    }): JQuery<HTMLDivElement>;
    generateTag(id: number, options?: {
        animate?: boolean;
    }): JQuery<HTMLDivElement>;
}
declare class Avatar {
    client_avatar_id: string;
    avatar_id: string;
    url: string;
    type: ImageType;
}
declare class AvatarManager {
    handle: FileManager;
    private static cache: CacheManager;
    private _cached_avatars: {
        [response_avatar_id: number]: Avatar;
    };
    private _loading_promises: {
        [response_avatar_id: number]: Promise<Icon>;
    };
    constructor(handle: FileManager);
    destroy();
    private _response_url(response: Response, type: ImageType): Promise<string>;
    resolved_cached?(client_avatar_id: string, avatar_version?: string): Promise<Avatar>;
    create_avatar_download(client_avatar_id: string): Promise<transfer.DownloadKey>;
    private _load_avatar(client_avatar_id: string, avatar_version: string);
    /* loads an avatar by the avatar id and optional with the avatar version */
    load_avatar(client_avatar_id: string, avatar_version: string): Promise<Avatar>;
    generate_client_tag(client: ClientEntry): JQuery;
    update_cache(client_avatar_id: string, avatar_id: string);
    generate_tag(client_avatar_id: string, avatar_id?: string, options?: {
        callback_image?: (tag: JQuery<HTMLImageElement>) => any;
        callback_avatar?: (avatar: Avatar) => any;
    }): JQuery;
    unique_id_2_avatar_id(unique_id: string);
    private generate_default_image(): JQuery;
    generate_chat_tag(client: {
        id?: number;
        database_id?: number;
    }, client_unique_id: string, callback_loaded?: (successfully: boolean, error?: any) => any): JQuery;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/i18n/country.ts */
declare namespace i18n {
    export function country_name(alpha_code: string, fallback?: string);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/i18n/localize.ts */
declare function guid();
declare namespace i18n {
    export interface TranslationKey {
        message: string;
        line?: number;
        character?: number;
        filename?: string;
    }
    export interface Translation {
        key: TranslationKey;
        translated: string;
        flags?: string[];
    }
    export interface Contributor {
        name: string;
        email: string;
    }
    export interface TranslationFile {
        path: string;
        full_url: string;
        translations: Translation[];
    }
    export interface RepositoryTranslation {
        key: string;
        path: string;
        country_code: string;
        name: string;
        contributors: Contributor[];
    }
    export interface TranslationRepository {
        unique_id: string;
        url: string;
        name?: string;
        contact?: string;
        translations?: RepositoryTranslation[];
        load_timestamp?: number;
    }
    export function tr(message: string, key?: string);
    export function tra(message: string, ...args: any[]);
    export function load_file(url: string, path: string): Promise<void>;
    export function load_repository(url: string): Promise<TranslationRepository>;
    export namespace config {
        export interface TranslationConfig {
            current_repository_url?: string;
            current_language?: string;
            current_translation_url: string;
            current_translation_path: string;
        }
        export interface RepositoryConfig {
            repositories?: {
                url?: string;
                repository?: TranslationRepository;
            }[];
        }
        export function repository_config();
        export function save_repository_config();
        export function translation_config(): TranslationConfig;
        export function save_translation_config();
    }
    export function register_repository(repository: TranslationRepository);
    export function registered_repositories(): TranslationRepository[];
    export function delete_repository(repository: TranslationRepository);
    export function iterate_repositories(callback_entry: (repository: TranslationRepository) => any): Promise<any>;
    export function select_translation(repository: TranslationRepository, entry: RepositoryTranslation);
    export function initialize(): Promise<any>;
}
declare const tr: typeof i18n.tr;
declare const tra: typeof i18n.tra;

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/log.ts */
declare enum LogCategory {
    CHANNEL,
    CHANNEL_PROPERTIES,
    CLIENT,
    BOOKMARKS,
    SERVER,
    PERMISSIONS,
    GENERAL,
    NETWORKING,
    VOICE,
    AUDIO,
    I18N,
    IPC,
    IDENTITIES,
    STATISTICS
}
declare namespace log {
    export enum LogType {
        TRACE,
        DEBUG,
        INFO,
        WARNING,
        ERROR
    }
    export let enabled_mapping;
    //Values will be overridden by initialize()
    export let level_mapping;
    export enum GroupMode {
        NATIVE,
        PREFIX
    }
    //Category Example: <url>?log.i18n.enabled=0
    //Level Example A: <url>?log.level.trace.enabled=0
    //Level Example B: <url>?log.level=0
    export function initialize(default_level: LogType);
    export function log(type: LogType, category: LogCategory, message: string, ...optionalParams: any[]);
    export function trace(category: LogCategory, message: string, ...optionalParams: any[]);
    export function debug(category: LogCategory, message: string, ...optionalParams: any[]);
    export function info(category: LogCategory, message: string, ...optionalParams: any[]);
    export function warn(category: LogCategory, message: string, ...optionalParams: any[]);
    export function error(category: LogCategory, message: string, ...optionalParams: any[]);
    export function group(level: LogType, category: LogCategory, name: string, ...optionalParams: any[]): Group;
    export function table(level: LogType, category: LogCategory, title: string, arguments: any);
    export class Group {
        readonly mode: GroupMode;
        readonly level: LogType;
        readonly category: LogCategory;
        readonly enabled: boolean;
        owner: Group;
        private readonly name: string;
        private readonly optionalParams: any[][];
        private _collapsed: boolean;
        private initialized;
        private _log_prefix: string;
        constructor(mode: GroupMode, level: LogType, category: LogCategory, name: string, optionalParams: any[][], owner?: Group);
        group(level: LogType, name: string, ...optionalParams: any[]): Group;
        collapsed(flag?: boolean): this;
        log(message: string, ...optionalParams: any[]): this;
        end();
        // @ts-ignore
        get prefix(): string;
        // @ts-ignore
        set prefix(prefix: string);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/main.ts */
declare const js_render;
declare const native_client;
declare function getUserMediaFunctionPromise(): (constraints: MediaStreamConstraints) => Promise<MediaStream>;
declare interface Window {
    open_connected_question: () => Promise<boolean>;
}
declare function setup_close();
declare function moment(...arguments): any;
declare function setup_jsrender(): boolean;
declare function initialize(): Promise<any>;
declare function initialize_app(): Promise<any>;
declare function str2ab8(str);
declare function arrayBufferBase64(base64: string);
declare function base64_encode_ab(source: ArrayBufferLike);
declare function main();
declare const task_teaweb_starter: loader.Task;
declare const task_certificate_callback: loader.Task;

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/permission/GroupManager.ts */
declare enum GroupType {
    QUERY,
    TEMPLATE,
    NORMAL
}
declare enum GroupTarget {
    SERVER,
    CHANNEL
}
declare class GroupProperties {
    iconid: number;
    sortid: number;
    savedb: boolean;
    namemode: number;
}
declare class GroupPermissionRequest {
    group_id: number;
    promise: LaterPromise<PermissionValue[]>;
}
declare class Group {
    properties: GroupProperties;
    readonly handle: GroupManager;
    readonly id: number;
    readonly target: GroupTarget;
    readonly type: GroupType;
    name: string;
    requiredModifyPower: number;
    requiredMemberAddPower: number;
    requiredMemberRemovePower: number;
    constructor(handle: GroupManager, id: number, target: GroupTarget, type: GroupType, name: string);
    updateProperty(key, value);
}
declare class GroupManager extends connection.AbstractCommandHandler {
    readonly handle: ConnectionHandler;
    serverGroups: Group[];
    channelGroups: Group[];
    private requests_group_permissions: GroupPermissionRequest[];
    constructor(client: ConnectionHandler);
    destroy();
    handle_command(command: connection.ServerCommand): boolean;
    requestGroups();
    static sorter(): (a: Group, b: Group) => number;
    serverGroup?(id: number): Group;
    channelGroup?(id: number): Group;
    private handle_grouplist(json);
    request_permissions(group: Group): Promise<PermissionValue[]>;
    private handle_group_permission_list(json: any[]);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/permission/PermissionManager.ts */
declare enum PermissionType {
    B_SERVERINSTANCE_HELP_VIEW = "b_serverinstance_help_view",
    B_SERVERINSTANCE_VERSION_VIEW = "b_serverinstance_version_view",
    B_SERVERINSTANCE_INFO_VIEW = "b_serverinstance_info_view",
    B_SERVERINSTANCE_VIRTUALSERVER_LIST = "b_serverinstance_virtualserver_list",
    B_SERVERINSTANCE_BINDING_LIST = "b_serverinstance_binding_list",
    B_SERVERINSTANCE_PERMISSION_LIST = "b_serverinstance_permission_list",
    B_SERVERINSTANCE_PERMISSION_FIND = "b_serverinstance_permission_find",
    B_VIRTUALSERVER_CREATE = "b_virtualserver_create",
    B_VIRTUALSERVER_DELETE = "b_virtualserver_delete",
    B_VIRTUALSERVER_START_ANY = "b_virtualserver_start_any",
    B_VIRTUALSERVER_STOP_ANY = "b_virtualserver_stop_any",
    B_VIRTUALSERVER_CHANGE_MACHINE_ID = "b_virtualserver_change_machine_id",
    B_VIRTUALSERVER_CHANGE_TEMPLATE = "b_virtualserver_change_template",
    B_SERVERQUERY_LOGIN = "b_serverquery_login",
    B_SERVERINSTANCE_TEXTMESSAGE_SEND = "b_serverinstance_textmessage_send",
    B_SERVERINSTANCE_LOG_VIEW = "b_serverinstance_log_view",
    B_SERVERINSTANCE_LOG_ADD = "b_serverinstance_log_add",
    B_SERVERINSTANCE_STOP = "b_serverinstance_stop",
    B_SERVERINSTANCE_MODIFY_SETTINGS = "b_serverinstance_modify_settings",
    B_SERVERINSTANCE_MODIFY_QUERYGROUP = "b_serverinstance_modify_querygroup",
    B_SERVERINSTANCE_MODIFY_TEMPLATES = "b_serverinstance_modify_templates",
    B_VIRTUALSERVER_SELECT = "b_virtualserver_select",
    B_VIRTUALSERVER_SELECT_GODMODE = "b_virtualserver_select_godmode",
    B_VIRTUALSERVER_INFO_VIEW = "b_virtualserver_info_view",
    B_VIRTUALSERVER_CONNECTIONINFO_VIEW = "b_virtualserver_connectioninfo_view",
    B_VIRTUALSERVER_CHANNEL_LIST = "b_virtualserver_channel_list",
    B_VIRTUALSERVER_CHANNEL_SEARCH = "b_virtualserver_channel_search",
    B_VIRTUALSERVER_CLIENT_LIST = "b_virtualserver_client_list",
    B_VIRTUALSERVER_CLIENT_SEARCH = "b_virtualserver_client_search",
    B_VIRTUALSERVER_CLIENT_DBLIST = "b_virtualserver_client_dblist",
    B_VIRTUALSERVER_CLIENT_DBSEARCH = "b_virtualserver_client_dbsearch",
    B_VIRTUALSERVER_CLIENT_DBINFO = "b_virtualserver_client_dbinfo",
    B_VIRTUALSERVER_PERMISSION_FIND = "b_virtualserver_permission_find",
    B_VIRTUALSERVER_CUSTOM_SEARCH = "b_virtualserver_custom_search",
    B_VIRTUALSERVER_START = "b_virtualserver_start",
    B_VIRTUALSERVER_STOP = "b_virtualserver_stop",
    B_VIRTUALSERVER_TOKEN_LIST = "b_virtualserver_token_list",
    B_VIRTUALSERVER_TOKEN_ADD = "b_virtualserver_token_add",
    B_VIRTUALSERVER_TOKEN_USE = "b_virtualserver_token_use",
    B_VIRTUALSERVER_TOKEN_DELETE = "b_virtualserver_token_delete",
    B_VIRTUALSERVER_LOG_VIEW = "b_virtualserver_log_view",
    B_VIRTUALSERVER_LOG_ADD = "b_virtualserver_log_add",
    B_VIRTUALSERVER_JOIN_IGNORE_PASSWORD = "b_virtualserver_join_ignore_password",
    B_VIRTUALSERVER_NOTIFY_REGISTER = "b_virtualserver_notify_register",
    B_VIRTUALSERVER_NOTIFY_UNREGISTER = "b_virtualserver_notify_unregister",
    B_VIRTUALSERVER_SNAPSHOT_CREATE = "b_virtualserver_snapshot_create",
    B_VIRTUALSERVER_SNAPSHOT_DEPLOY = "b_virtualserver_snapshot_deploy",
    B_VIRTUALSERVER_PERMISSION_RESET = "b_virtualserver_permission_reset",
    B_VIRTUALSERVER_MODIFY_NAME = "b_virtualserver_modify_name",
    B_VIRTUALSERVER_MODIFY_WELCOMEMESSAGE = "b_virtualserver_modify_welcomemessage",
    B_VIRTUALSERVER_MODIFY_MAXCLIENTS = "b_virtualserver_modify_maxclients",
    B_VIRTUALSERVER_MODIFY_RESERVED_SLOTS = "b_virtualserver_modify_reserved_slots",
    B_VIRTUALSERVER_MODIFY_PASSWORD = "b_virtualserver_modify_password",
    B_VIRTUALSERVER_MODIFY_DEFAULT_SERVERGROUP = "b_virtualserver_modify_default_servergroup",
    B_VIRTUALSERVER_MODIFY_DEFAULT_MUSICGROUP = "b_virtualserver_modify_default_musicgroup",
    B_VIRTUALSERVER_MODIFY_DEFAULT_CHANNELGROUP = "b_virtualserver_modify_default_channelgroup",
    B_VIRTUALSERVER_MODIFY_DEFAULT_CHANNELADMINGROUP = "b_virtualserver_modify_default_channeladmingroup",
    B_VIRTUALSERVER_MODIFY_CHANNEL_FORCED_SILENCE = "b_virtualserver_modify_channel_forced_silence",
    B_VIRTUALSERVER_MODIFY_COMPLAIN = "b_virtualserver_modify_complain",
    B_VIRTUALSERVER_MODIFY_ANTIFLOOD = "b_virtualserver_modify_antiflood",
    B_VIRTUALSERVER_MODIFY_FT_SETTINGS = "b_virtualserver_modify_ft_settings",
    B_VIRTUALSERVER_MODIFY_FT_QUOTAS = "b_virtualserver_modify_ft_quotas",
    B_VIRTUALSERVER_MODIFY_HOSTMESSAGE = "b_virtualserver_modify_hostmessage",
    B_VIRTUALSERVER_MODIFY_HOSTBANNER = "b_virtualserver_modify_hostbanner",
    B_VIRTUALSERVER_MODIFY_HOSTBUTTON = "b_virtualserver_modify_hostbutton",
    B_VIRTUALSERVER_MODIFY_PORT = "b_virtualserver_modify_port",
    B_VIRTUALSERVER_MODIFY_HOST = "b_virtualserver_modify_host",
    B_VIRTUALSERVER_MODIFY_DEFAULT_MESSAGES = "b_virtualserver_modify_default_messages",
    B_VIRTUALSERVER_MODIFY_AUTOSTART = "b_virtualserver_modify_autostart",
    B_VIRTUALSERVER_MODIFY_NEEDED_IDENTITY_SECURITY_LEVEL = "b_virtualserver_modify_needed_identity_security_level",
    B_VIRTUALSERVER_MODIFY_PRIORITY_SPEAKER_DIMM_MODIFICATOR = "b_virtualserver_modify_priority_speaker_dimm_modificator",
    B_VIRTUALSERVER_MODIFY_LOG_SETTINGS = "b_virtualserver_modify_log_settings",
    B_VIRTUALSERVER_MODIFY_MIN_CLIENT_VERSION = "b_virtualserver_modify_min_client_version",
    B_VIRTUALSERVER_MODIFY_ICON_ID = "b_virtualserver_modify_icon_id",
    B_VIRTUALSERVER_MODIFY_WEBLIST = "b_virtualserver_modify_weblist",
    B_VIRTUALSERVER_MODIFY_CODEC_ENCRYPTION_MODE = "b_virtualserver_modify_codec_encryption_mode",
    B_VIRTUALSERVER_MODIFY_TEMPORARY_PASSWORDS = "b_virtualserver_modify_temporary_passwords",
    B_VIRTUALSERVER_MODIFY_TEMPORARY_PASSWORDS_OWN = "b_virtualserver_modify_temporary_passwords_own",
    B_VIRTUALSERVER_MODIFY_CHANNEL_TEMP_DELETE_DELAY_DEFAULT = "b_virtualserver_modify_channel_temp_delete_delay_default",
    B_VIRTUALSERVER_MODIFY_MUSIC_BOT_LIMIT = "b_virtualserver_modify_music_bot_limit",
    I_CHANNEL_MIN_DEPTH = "i_channel_min_depth",
    I_CHANNEL_MAX_DEPTH = "i_channel_max_depth",
    B_CHANNEL_GROUP_INHERITANCE_END = "b_channel_group_inheritance_end",
    I_CHANNEL_PERMISSION_MODIFY_POWER = "i_channel_permission_modify_power",
    I_CHANNEL_NEEDED_PERMISSION_MODIFY_POWER = "i_channel_needed_permission_modify_power",
    B_CHANNEL_INFO_VIEW = "b_channel_info_view",
    B_CHANNEL_CREATE_CHILD = "b_channel_create_child",
    B_CHANNEL_CREATE_PERMANENT = "b_channel_create_permanent",
    B_CHANNEL_CREATE_SEMI_PERMANENT = "b_channel_create_semi_permanent",
    B_CHANNEL_CREATE_TEMPORARY = "b_channel_create_temporary",
    B_CHANNEL_CREATE_PRIVATE = "b_channel_create_private",
    B_CHANNEL_CREATE_WITH_TOPIC = "b_channel_create_with_topic",
    B_CHANNEL_CREATE_WITH_DESCRIPTION = "b_channel_create_with_description",
    B_CHANNEL_CREATE_WITH_PASSWORD = "b_channel_create_with_password",
    B_CHANNEL_CREATE_MODIFY_WITH_CODEC_SPEEX8 = "b_channel_create_modify_with_codec_speex8",
    B_CHANNEL_CREATE_MODIFY_WITH_CODEC_SPEEX16 = "b_channel_create_modify_with_codec_speex16",
    B_CHANNEL_CREATE_MODIFY_WITH_CODEC_SPEEX32 = "b_channel_create_modify_with_codec_speex32",
    B_CHANNEL_CREATE_MODIFY_WITH_CODEC_CELTMONO48 = "b_channel_create_modify_with_codec_celtmono48",
    B_CHANNEL_CREATE_MODIFY_WITH_CODEC_OPUSVOICE = "b_channel_create_modify_with_codec_opusvoice",
    B_CHANNEL_CREATE_MODIFY_WITH_CODEC_OPUSMUSIC = "b_channel_create_modify_with_codec_opusmusic",
    I_CHANNEL_CREATE_MODIFY_WITH_CODEC_MAXQUALITY = "i_channel_create_modify_with_codec_maxquality",
    I_CHANNEL_CREATE_MODIFY_WITH_CODEC_LATENCY_FACTOR_MIN = "i_channel_create_modify_with_codec_latency_factor_min",
    B_CHANNEL_CREATE_WITH_MAXCLIENTS = "b_channel_create_with_maxclients",
    B_CHANNEL_CREATE_WITH_MAXFAMILYCLIENTS = "b_channel_create_with_maxfamilyclients",
    B_CHANNEL_CREATE_WITH_SORTORDER = "b_channel_create_with_sortorder",
    B_CHANNEL_CREATE_WITH_DEFAULT = "b_channel_create_with_default",
    B_CHANNEL_CREATE_WITH_NEEDED_TALK_POWER = "b_channel_create_with_needed_talk_power",
    B_CHANNEL_CREATE_MODIFY_WITH_FORCE_PASSWORD = "b_channel_create_modify_with_force_password",
    I_CHANNEL_CREATE_MODIFY_WITH_TEMP_DELETE_DELAY = "i_channel_create_modify_with_temp_delete_delay",
    B_CHANNEL_MODIFY_PARENT = "b_channel_modify_parent",
    B_CHANNEL_MODIFY_MAKE_DEFAULT = "b_channel_modify_make_default",
    B_CHANNEL_MODIFY_MAKE_PERMANENT = "b_channel_modify_make_permanent",
    B_CHANNEL_MODIFY_MAKE_SEMI_PERMANENT = "b_channel_modify_make_semi_permanent",
    B_CHANNEL_MODIFY_MAKE_TEMPORARY = "b_channel_modify_make_temporary",
    B_CHANNEL_MODIFY_NAME = "b_channel_modify_name",
    B_CHANNEL_MODIFY_TOPIC = "b_channel_modify_topic",
    B_CHANNEL_MODIFY_DESCRIPTION = "b_channel_modify_description",
    B_CHANNEL_MODIFY_PASSWORD = "b_channel_modify_password",
    B_CHANNEL_MODIFY_CODEC = "b_channel_modify_codec",
    B_CHANNEL_MODIFY_CODEC_QUALITY = "b_channel_modify_codec_quality",
    B_CHANNEL_MODIFY_CODEC_LATENCY_FACTOR = "b_channel_modify_codec_latency_factor",
    B_CHANNEL_MODIFY_MAXCLIENTS = "b_channel_modify_maxclients",
    B_CHANNEL_MODIFY_MAXFAMILYCLIENTS = "b_channel_modify_maxfamilyclients",
    B_CHANNEL_MODIFY_SORTORDER = "b_channel_modify_sortorder",
    B_CHANNEL_MODIFY_NEEDED_TALK_POWER = "b_channel_modify_needed_talk_power",
    I_CHANNEL_MODIFY_POWER = "i_channel_modify_power",
    I_CHANNEL_NEEDED_MODIFY_POWER = "i_channel_needed_modify_power",
    B_CHANNEL_MODIFY_MAKE_CODEC_ENCRYPTED = "b_channel_modify_make_codec_encrypted",
    B_CHANNEL_MODIFY_TEMP_DELETE_DELAY = "b_channel_modify_temp_delete_delay",
    B_CHANNEL_DELETE_PERMANENT = "b_channel_delete_permanent",
    B_CHANNEL_DELETE_SEMI_PERMANENT = "b_channel_delete_semi_permanent",
    B_CHANNEL_DELETE_TEMPORARY = "b_channel_delete_temporary",
    B_CHANNEL_DELETE_FLAG_FORCE = "b_channel_delete_flag_force",
    I_CHANNEL_DELETE_POWER = "i_channel_delete_power",
    I_CHANNEL_NEEDED_DELETE_POWER = "i_channel_needed_delete_power",
    B_CHANNEL_JOIN_PERMANENT = "b_channel_join_permanent",
    B_CHANNEL_JOIN_SEMI_PERMANENT = "b_channel_join_semi_permanent",
    B_CHANNEL_JOIN_TEMPORARY = "b_channel_join_temporary",
    B_CHANNEL_JOIN_IGNORE_PASSWORD = "b_channel_join_ignore_password",
    B_CHANNEL_JOIN_IGNORE_MAXCLIENTS = "b_channel_join_ignore_maxclients",
    B_CHANNEL_IGNORE_VIEW_POWER = "b_channel_ignore_view_power",
    I_CHANNEL_JOIN_POWER = "i_channel_join_power",
    I_CHANNEL_NEEDED_JOIN_POWER = "i_channel_needed_join_power",
    B_CHANNEL_IGNORE_JOIN_POWER = "b_channel_ignore_join_power",
    I_CHANNEL_VIEW_POWER = "i_channel_view_power",
    I_CHANNEL_NEEDED_VIEW_POWER = "i_channel_needed_view_power",
    I_CHANNEL_SUBSCRIBE_POWER = "i_channel_subscribe_power",
    I_CHANNEL_NEEDED_SUBSCRIBE_POWER = "i_channel_needed_subscribe_power",
    I_CHANNEL_DESCRIPTION_VIEW_POWER = "i_channel_description_view_power",
    I_CHANNEL_NEEDED_DESCRIPTION_VIEW_POWER = "i_channel_needed_description_view_power",
    I_ICON_ID = "i_icon_id",
    I_MAX_ICON_FILESIZE = "i_max_icon_filesize",
    B_ICON_MANAGE = "b_icon_manage",
    B_GROUP_IS_PERMANENT = "b_group_is_permanent",
    I_GROUP_AUTO_UPDATE_TYPE = "i_group_auto_update_type",
    I_GROUP_AUTO_UPDATE_MAX_VALUE = "i_group_auto_update_max_value",
    I_GROUP_SORT_ID = "i_group_sort_id",
    I_GROUP_SHOW_NAME_IN_TREE = "i_group_show_name_in_tree",
    B_VIRTUALSERVER_SERVERGROUP_CREATE = "b_virtualserver_servergroup_create",
    B_VIRTUALSERVER_SERVERGROUP_LIST = "b_virtualserver_servergroup_list",
    B_VIRTUALSERVER_SERVERGROUP_PERMISSION_LIST = "b_virtualserver_servergroup_permission_list",
    B_VIRTUALSERVER_SERVERGROUP_CLIENT_LIST = "b_virtualserver_servergroup_client_list",
    B_VIRTUALSERVER_CHANNELGROUP_CREATE = "b_virtualserver_channelgroup_create",
    B_VIRTUALSERVER_CHANNELGROUP_LIST = "b_virtualserver_channelgroup_list",
    B_VIRTUALSERVER_CHANNELGROUP_PERMISSION_LIST = "b_virtualserver_channelgroup_permission_list",
    B_VIRTUALSERVER_CHANNELGROUP_CLIENT_LIST = "b_virtualserver_channelgroup_client_list",
    B_VIRTUALSERVER_CLIENT_PERMISSION_LIST = "b_virtualserver_client_permission_list",
    B_VIRTUALSERVER_CHANNEL_PERMISSION_LIST = "b_virtualserver_channel_permission_list",
    B_VIRTUALSERVER_CHANNELCLIENT_PERMISSION_LIST = "b_virtualserver_channelclient_permission_list",
    B_VIRTUALSERVER_PLAYLIST_PERMISSION_LIST = "b_virtualserver_playlist_permission_list",
    I_SERVER_GROUP_MODIFY_POWER = "i_server_group_modify_power",
    I_SERVER_GROUP_NEEDED_MODIFY_POWER = "i_server_group_needed_modify_power",
    I_SERVER_GROUP_MEMBER_ADD_POWER = "i_server_group_member_add_power",
    I_SERVER_GROUP_SELF_ADD_POWER = "i_server_group_self_add_power",
    I_SERVER_GROUP_NEEDED_MEMBER_ADD_POWER = "i_server_group_needed_member_add_power",
    I_SERVER_GROUP_MEMBER_REMOVE_POWER = "i_server_group_member_remove_power",
    I_SERVER_GROUP_SELF_REMOVE_POWER = "i_server_group_self_remove_power",
    I_SERVER_GROUP_NEEDED_MEMBER_REMOVE_POWER = "i_server_group_needed_member_remove_power",
    I_CHANNEL_GROUP_MODIFY_POWER = "i_channel_group_modify_power",
    I_CHANNEL_GROUP_NEEDED_MODIFY_POWER = "i_channel_group_needed_modify_power",
    I_CHANNEL_GROUP_MEMBER_ADD_POWER = "i_channel_group_member_add_power",
    I_CHANNEL_GROUP_SELF_ADD_POWER = "i_channel_group_self_add_power",
    I_CHANNEL_GROUP_NEEDED_MEMBER_ADD_POWER = "i_channel_group_needed_member_add_power",
    I_CHANNEL_GROUP_MEMBER_REMOVE_POWER = "i_channel_group_member_remove_power",
    I_CHANNEL_GROUP_SELF_REMOVE_POWER = "i_channel_group_self_remove_power",
    I_CHANNEL_GROUP_NEEDED_MEMBER_REMOVE_POWER = "i_channel_group_needed_member_remove_power",
    I_GROUP_MEMBER_ADD_POWER = "i_group_member_add_power",
    I_GROUP_NEEDED_MEMBER_ADD_POWER = "i_group_needed_member_add_power",
    I_GROUP_MEMBER_REMOVE_POWER = "i_group_member_remove_power",
    I_GROUP_NEEDED_MEMBER_REMOVE_POWER = "i_group_needed_member_remove_power",
    I_GROUP_MODIFY_POWER = "i_group_modify_power",
    I_GROUP_NEEDED_MODIFY_POWER = "i_group_needed_modify_power",
    I_PERMISSION_MODIFY_POWER = "i_permission_modify_power",
    B_PERMISSION_MODIFY_POWER_IGNORE = "b_permission_modify_power_ignore",
    B_VIRTUALSERVER_SERVERGROUP_DELETE = "b_virtualserver_servergroup_delete",
    B_VIRTUALSERVER_CHANNELGROUP_DELETE = "b_virtualserver_channelgroup_delete",
    I_CLIENT_PERMISSION_MODIFY_POWER = "i_client_permission_modify_power",
    I_CLIENT_NEEDED_PERMISSION_MODIFY_POWER = "i_client_needed_permission_modify_power",
    I_CLIENT_MAX_CLONES_UID = "i_client_max_clones_uid",
    I_CLIENT_MAX_CLONES_IP = "i_client_max_clones_ip",
    I_CLIENT_MAX_CLONES_HWID = "i_client_max_clones_hwid",
    I_CLIENT_MAX_IDLETIME = "i_client_max_idletime",
    I_CLIENT_MAX_AVATAR_FILESIZE = "i_client_max_avatar_filesize",
    I_CLIENT_MAX_CHANNEL_SUBSCRIPTIONS = "i_client_max_channel_subscriptions",
    I_CLIENT_MAX_CHANNELS = "i_client_max_channels",
    I_CLIENT_MAX_TEMPORARY_CHANNELS = "i_client_max_temporary_channels",
    I_CLIENT_MAX_SEMI_CHANNELS = "i_client_max_semi_channels",
    I_CLIENT_MAX_PERMANENT_CHANNELS = "i_client_max_permanent_channels",
    B_CLIENT_USE_PRIORITY_SPEAKER = "b_client_use_priority_speaker",
    B_CLIENT_SKIP_CHANNELGROUP_PERMISSIONS = "b_client_skip_channelgroup_permissions",
    B_CLIENT_FORCE_PUSH_TO_TALK = "b_client_force_push_to_talk",
    B_CLIENT_IGNORE_BANS = "b_client_ignore_bans",
    B_CLIENT_IGNORE_VPN = "b_client_ignore_vpn",
    B_CLIENT_IGNORE_ANTIFLOOD = "b_client_ignore_antiflood",
    B_CLIENT_ENFORCE_VALID_HWID = "b_client_enforce_valid_hwid",
    B_CLIENT_ALLOW_INVALID_PACKET = "b_client_allow_invalid_packet",
    B_CLIENT_ALLOW_INVALID_BADGES = "b_client_allow_invalid_badges",
    B_CLIENT_ISSUE_CLIENT_QUERY_COMMAND = "b_client_issue_client_query_command",
    B_CLIENT_USE_RESERVED_SLOT = "b_client_use_reserved_slot",
    B_CLIENT_USE_CHANNEL_COMMANDER = "b_client_use_channel_commander",
    B_CLIENT_REQUEST_TALKER = "b_client_request_talker",
    B_CLIENT_AVATAR_DELETE_OTHER = "b_client_avatar_delete_other",
    B_CLIENT_IS_STICKY = "b_client_is_sticky",
    B_CLIENT_IGNORE_STICKY = "b_client_ignore_sticky",
    B_CLIENT_MUSIC_CREATE_PERMANENT = "b_client_music_create_permanent",
    B_CLIENT_MUSIC_CREATE_SEMI_PERMANENT = "b_client_music_create_semi_permanent",
    B_CLIENT_MUSIC_CREATE_TEMPORARY = "b_client_music_create_temporary",
    B_CLIENT_MUSIC_MODIFY_PERMANENT = "b_client_music_modify_permanent",
    B_CLIENT_MUSIC_MODIFY_SEMI_PERMANENT = "b_client_music_modify_semi_permanent",
    B_CLIENT_MUSIC_MODIFY_TEMPORARY = "b_client_music_modify_temporary",
    I_CLIENT_MUSIC_CREATE_MODIFY_MAX_VOLUME = "i_client_music_create_modify_max_volume",
    I_CLIENT_MUSIC_LIMIT = "i_client_music_limit",
    I_CLIENT_MUSIC_NEEDED_DELETE_POWER = "i_client_music_needed_delete_power",
    I_CLIENT_MUSIC_DELETE_POWER = "i_client_music_delete_power",
    I_CLIENT_MUSIC_PLAY_POWER = "i_client_music_play_power",
    I_CLIENT_MUSIC_NEEDED_PLAY_POWER = "i_client_music_needed_play_power",
    I_CLIENT_MUSIC_MODIFY_POWER = "i_client_music_modify_power",
    I_CLIENT_MUSIC_NEEDED_MODIFY_POWER = "i_client_music_needed_modify_power",
    I_CLIENT_MUSIC_RENAME_POWER = "i_client_music_rename_power",
    I_CLIENT_MUSIC_NEEDED_RENAME_POWER = "i_client_music_needed_rename_power",
    B_PLAYLIST_CREATE = "b_playlist_create",
    I_PLAYLIST_VIEW_POWER = "i_playlist_view_power",
    I_PLAYLIST_NEEDED_VIEW_POWER = "i_playlist_needed_view_power",
    I_PLAYLIST_MODIFY_POWER = "i_playlist_modify_power",
    I_PLAYLIST_NEEDED_MODIFY_POWER = "i_playlist_needed_modify_power",
    I_PLAYLIST_PERMISSION_MODIFY_POWER = "i_playlist_permission_modify_power",
    I_PLAYLIST_NEEDED_PERMISSION_MODIFY_POWER = "i_playlist_needed_permission_modify_power",
    I_PLAYLIST_DELETE_POWER = "i_playlist_delete_power",
    I_PLAYLIST_NEEDED_DELETE_POWER = "i_playlist_needed_delete_power",
    I_PLAYLIST_SONG_ADD_POWER = "i_playlist_song_add_power",
    I_PLAYLIST_SONG_NEEDED_ADD_POWER = "i_playlist_song_needed_add_power",
    I_PLAYLIST_SONG_REMOVE_POWER = "i_playlist_song_remove_power",
    I_PLAYLIST_SONG_NEEDED_REMOVE_POWER = "i_playlist_song_needed_remove_power",
    B_CLIENT_INFO_VIEW = "b_client_info_view",
    B_CLIENT_PERMISSIONOVERVIEW_VIEW = "b_client_permissionoverview_view",
    B_CLIENT_PERMISSIONOVERVIEW_OWN = "b_client_permissionoverview_own",
    B_CLIENT_REMOTEADDRESS_VIEW = "b_client_remoteaddress_view",
    I_CLIENT_SERVERQUERY_VIEW_POWER = "i_client_serverquery_view_power",
    I_CLIENT_NEEDED_SERVERQUERY_VIEW_POWER = "i_client_needed_serverquery_view_power",
    B_CLIENT_CUSTOM_INFO_VIEW = "b_client_custom_info_view",
    B_CLIENT_MUSIC_CHANNEL_LIST = "b_client_music_channel_list",
    B_CLIENT_MUSIC_SERVER_LIST = "b_client_music_server_list",
    I_CLIENT_MUSIC_INFO = "i_client_music_info",
    I_CLIENT_MUSIC_NEEDED_INFO = "i_client_music_needed_info",
    I_CLIENT_KICK_FROM_SERVER_POWER = "i_client_kick_from_server_power",
    I_CLIENT_NEEDED_KICK_FROM_SERVER_POWER = "i_client_needed_kick_from_server_power",
    I_CLIENT_KICK_FROM_CHANNEL_POWER = "i_client_kick_from_channel_power",
    I_CLIENT_NEEDED_KICK_FROM_CHANNEL_POWER = "i_client_needed_kick_from_channel_power",
    I_CLIENT_BAN_POWER = "i_client_ban_power",
    I_CLIENT_NEEDED_BAN_POWER = "i_client_needed_ban_power",
    I_CLIENT_MOVE_POWER = "i_client_move_power",
    I_CLIENT_NEEDED_MOVE_POWER = "i_client_needed_move_power",
    I_CLIENT_COMPLAIN_POWER = "i_client_complain_power",
    I_CLIENT_NEEDED_COMPLAIN_POWER = "i_client_needed_complain_power",
    B_CLIENT_COMPLAIN_LIST = "b_client_complain_list",
    B_CLIENT_COMPLAIN_DELETE_OWN = "b_client_complain_delete_own",
    B_CLIENT_COMPLAIN_DELETE = "b_client_complain_delete",
    B_CLIENT_BAN_LIST = "b_client_ban_list",
    B_CLIENT_BAN_LIST_GLOBAL = "b_client_ban_list_global",
    B_CLIENT_BAN_TRIGGER_LIST = "b_client_ban_trigger_list",
    B_CLIENT_BAN_CREATE = "b_client_ban_create",
    B_CLIENT_BAN_CREATE_GLOBAL = "b_client_ban_create_global",
    B_CLIENT_BAN_NAME = "b_client_ban_name",
    B_CLIENT_BAN_IP = "b_client_ban_ip",
    B_CLIENT_BAN_HWID = "b_client_ban_hwid",
    B_CLIENT_BAN_EDIT = "b_client_ban_edit",
    B_CLIENT_BAN_EDIT_GLOBAL = "b_client_ban_edit_global",
    B_CLIENT_BAN_DELETE_OWN = "b_client_ban_delete_own",
    B_CLIENT_BAN_DELETE = "b_client_ban_delete",
    B_CLIENT_BAN_DELETE_OWN_GLOBAL = "b_client_ban_delete_own_global",
    B_CLIENT_BAN_DELETE_GLOBAL = "b_client_ban_delete_global",
    I_CLIENT_BAN_MAX_BANTIME = "i_client_ban_max_bantime",
    I_CLIENT_PRIVATE_TEXTMESSAGE_POWER = "i_client_private_textmessage_power",
    I_CLIENT_NEEDED_PRIVATE_TEXTMESSAGE_POWER = "i_client_needed_private_textmessage_power",
    B_CLIENT_EVEN_TEXTMESSAGE_SEND = "b_client_even_textmessage_send",
    B_CLIENT_SERVER_TEXTMESSAGE_SEND = "b_client_server_textmessage_send",
    B_CLIENT_CHANNEL_TEXTMESSAGE_SEND = "b_client_channel_textmessage_send",
    B_CLIENT_OFFLINE_TEXTMESSAGE_SEND = "b_client_offline_textmessage_send",
    I_CLIENT_TALK_POWER = "i_client_talk_power",
    I_CLIENT_NEEDED_TALK_POWER = "i_client_needed_talk_power",
    I_CLIENT_POKE_POWER = "i_client_poke_power",
    I_CLIENT_NEEDED_POKE_POWER = "i_client_needed_poke_power",
    B_CLIENT_SET_FLAG_TALKER = "b_client_set_flag_talker",
    I_CLIENT_WHISPER_POWER = "i_client_whisper_power",
    I_CLIENT_NEEDED_WHISPER_POWER = "i_client_needed_whisper_power",
    B_CLIENT_MODIFY_DESCRIPTION = "b_client_modify_description",
    B_CLIENT_MODIFY_OWN_DESCRIPTION = "b_client_modify_own_description",
    B_CLIENT_USE_BBCODE_ANY = "b_client_use_bbcode_any",
    B_CLIENT_USE_BBCODE_URL = "b_client_use_bbcode_url",
    B_CLIENT_USE_BBCODE_IMAGE = "b_client_use_bbcode_image",
    B_CLIENT_MODIFY_DBPROPERTIES = "b_client_modify_dbproperties",
    B_CLIENT_DELETE_DBPROPERTIES = "b_client_delete_dbproperties",
    B_CLIENT_CREATE_MODIFY_SERVERQUERY_LOGIN = "b_client_create_modify_serverquery_login",
    B_CLIENT_QUERY_CREATE = "b_client_query_create",
    B_CLIENT_QUERY_LIST = "b_client_query_list",
    B_CLIENT_QUERY_LIST_OWN = "b_client_query_list_own",
    B_CLIENT_QUERY_RENAME = "b_client_query_rename",
    B_CLIENT_QUERY_RENAME_OWN = "b_client_query_rename_own",
    B_CLIENT_QUERY_CHANGE_PASSWORD = "b_client_query_change_password",
    B_CLIENT_QUERY_CHANGE_OWN_PASSWORD = "b_client_query_change_own_password",
    B_CLIENT_QUERY_CHANGE_PASSWORD_GLOBAL = "b_client_query_change_password_global",
    B_CLIENT_QUERY_DELETE = "b_client_query_delete",
    B_CLIENT_QUERY_DELETE_OWN = "b_client_query_delete_own",
    B_FT_IGNORE_PASSWORD = "b_ft_ignore_password",
    B_FT_TRANSFER_LIST = "b_ft_transfer_list",
    I_FT_FILE_UPLOAD_POWER = "i_ft_file_upload_power",
    I_FT_NEEDED_FILE_UPLOAD_POWER = "i_ft_needed_file_upload_power",
    I_FT_FILE_DOWNLOAD_POWER = "i_ft_file_download_power",
    I_FT_NEEDED_FILE_DOWNLOAD_POWER = "i_ft_needed_file_download_power",
    I_FT_FILE_DELETE_POWER = "i_ft_file_delete_power",
    I_FT_NEEDED_FILE_DELETE_POWER = "i_ft_needed_file_delete_power",
    I_FT_FILE_RENAME_POWER = "i_ft_file_rename_power",
    I_FT_NEEDED_FILE_RENAME_POWER = "i_ft_needed_file_rename_power",
    I_FT_FILE_BROWSE_POWER = "i_ft_file_browse_power",
    I_FT_NEEDED_FILE_BROWSE_POWER = "i_ft_needed_file_browse_power",
    I_FT_DIRECTORY_CREATE_POWER = "i_ft_directory_create_power",
    I_FT_NEEDED_DIRECTORY_CREATE_POWER = "i_ft_needed_directory_create_power",
    I_FT_QUOTA_MB_DOWNLOAD_PER_CLIENT = "i_ft_quota_mb_download_per_client",
    I_FT_QUOTA_MB_UPLOAD_PER_CLIENT = "i_ft_quota_mb_upload_per_client"
}
declare class PermissionInfo {
    name: string;
    id: number;
    description: string;
    is_boolean();
    id_grant(): number;
}
declare class PermissionGroup {
    begin: number;
    end: number;
    deep: number;
    name: string;
}
declare class GroupedPermissions {
    group: PermissionGroup;
    permissions: PermissionInfo[];
    children: GroupedPermissions[];
    parent: GroupedPermissions;
}
declare class PermissionValue {
    readonly type: PermissionInfo;
    value: number;
    flag_skip: boolean;
    flag_negate: boolean;
    granted_value: number;
    constructor(type, value?);
    granted(requiredValue: number, required?: boolean): boolean;
    hasValue(): boolean;
    hasGrant(): boolean;
}
declare class NeededPermissionValue extends PermissionValue {
    constructor(type, value);
}
declare class ChannelPermissionRequest {
    requested: number;
    channel_id: number;
    callback_success: ((_: PermissionValue[]) => any)[];
    callback_error: ((_: any) => any)[];
}
declare class TeaPermissionRequest {
    client_id?: number;
    channel_id?: number;
    playlist_id?: number;
    promise: LaterPromise<PermissionValue[]>;
}
declare class PermissionManager extends connection.AbstractCommandHandler {
    readonly handle: ConnectionHandler;
    permissionList: PermissionInfo[];
    permissionGroups: PermissionGroup[];
    neededPermissions: NeededPermissionValue[];
    needed_permission_change_listener: {
        [permission: string]: (() => any)[];
    };
    requests_channel_permissions: ChannelPermissionRequest[];
    requests_client_permissions: TeaPermissionRequest[];
    requests_client_channel_permissions: TeaPermissionRequest[];
    requests_playlist_permissions: TeaPermissionRequest[];
    initializedListener: ((initialized: boolean) => void)[];
    private _cacheNeededPermissions: any;
    /* Static info mapping until TeaSpeak implements a detailed info */
    //TODO tr
    static readonly group_mapping: {
        name: string;
        deep: number;
    }[];
    private _group_mapping;
    public static parse_permission_bulk(json: any[], manager: PermissionManager): PermissionValue[];
    constructor(client: ConnectionHandler);
    destroy();
    handle_command(command: connection.ServerCommand): boolean;
    initialized(): boolean;
    public requestPermissionList();
    private onPermissionList(json);
    private onNeededPermissions(json);
    register_needed_permission(key: PermissionType, listener: () => any);
    unregister_needed_permission(key: PermissionType, listener: () => any);
    private onChannelPermList(json);
    resolveInfo?(key: number | string | PermissionType): PermissionInfo;
    requestChannelPermissions(channelId: number): Promise<PermissionValue[]>;
    private onClientPermList(json: any[]);
    requestClientPermissions(client_id: number): Promise<PermissionValue[]>;
    requestClientChannelPermissions(client_id: number, channel_id: number): Promise<PermissionValue[]>;
    private onPlaylistPermList(json: any[]);
    requestPlaylistPermissions(playlist_id: number): Promise<PermissionValue[]>;
    neededPermission(key: number | string | PermissionType | PermissionInfo): NeededPermissionValue;
    groupedPermissions(): GroupedPermissions[];
    /**
     * Generates an enum with all know permission types, used for the enum above
     */
    export_permission_types();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/PPTListener.ts */
declare enum KeyCode {
    KEY_CANCEL = 3,
    KEY_HELP = 6,
    KEY_BACK_SPACE = 8,
    KEY_TAB = 9,
    KEY_CLEAR = 12,
    KEY_RETURN = 13,
    KEY_ENTER = 14,
    KEY_SHIFT = 16,
    KEY_CONTROL = 17,
    KEY_ALT = 18,
    KEY_PAUSE = 19,
    KEY_CAPS_LOCK = 20,
    KEY_ESCAPE = 27,
    KEY_SPACE = 32,
    KEY_PAGE_UP = 33,
    KEY_PAGE_DOWN = 34,
    KEY_END = 35,
    KEY_HOME = 36,
    KEY_LEFT = 37,
    KEY_UP = 38,
    KEY_RIGHT = 39,
    KEY_DOWN = 40,
    KEY_PRINTSCREEN = 44,
    KEY_INSERT = 45,
    KEY_DELETE = 46,
    KEY_0 = 48,
    KEY_1 = 49,
    KEY_2 = 50,
    KEY_3 = 51,
    KEY_4 = 52,
    KEY_5 = 53,
    KEY_6 = 54,
    KEY_7 = 55,
    KEY_8 = 56,
    KEY_9 = 57,
    KEY_SEMICOLON = 59,
    KEY_EQUALS = 61,
    KEY_A = 65,
    KEY_B = 66,
    KEY_C = 67,
    KEY_D = 68,
    KEY_E = 69,
    KEY_F = 70,
    KEY_G = 71,
    KEY_H = 72,
    KEY_I = 73,
    KEY_J = 74,
    KEY_K = 75,
    KEY_L = 76,
    KEY_M = 77,
    KEY_N = 78,
    KEY_O = 79,
    KEY_P = 80,
    KEY_Q = 81,
    KEY_R = 82,
    KEY_S = 83,
    KEY_T = 84,
    KEY_U = 85,
    KEY_V = 86,
    KEY_W = 87,
    KEY_X = 88,
    KEY_Y = 89,
    KEY_Z = 90,
    KEY_LEFT_CMD = 91,
    KEY_RIGHT_CMD = 93,
    KEY_CONTEXT_MENU = 93,
    KEY_NUMPAD0 = 96,
    KEY_NUMPAD1 = 97,
    KEY_NUMPAD2 = 98,
    KEY_NUMPAD3 = 99,
    KEY_NUMPAD4 = 100,
    KEY_NUMPAD5 = 101,
    KEY_NUMPAD6 = 102,
    KEY_NUMPAD7 = 103,
    KEY_NUMPAD8 = 104,
    KEY_NUMPAD9 = 105,
    KEY_MULTIPLY = 106,
    KEY_ADD = 107,
    KEY_SEPARATOR = 108,
    KEY_SUBTRACT = 109,
    KEY_DECIMAL = 110,
    KEY_DIVIDE = 111,
    KEY_F1 = 112,
    KEY_F2 = 113,
    KEY_F3 = 114,
    KEY_F4 = 115,
    KEY_F5 = 116,
    KEY_F6 = 117,
    KEY_F7 = 118,
    KEY_F8 = 119,
    KEY_F9 = 120,
    KEY_F10 = 121,
    KEY_F11 = 122,
    KEY_F12 = 123,
    KEY_F13 = 124,
    KEY_F14 = 125,
    KEY_F15 = 126,
    KEY_F16 = 127,
    KEY_F17 = 128,
    KEY_F18 = 129,
    KEY_F19 = 130,
    KEY_F20 = 131,
    KEY_F21 = 132,
    KEY_F22 = 133,
    KEY_F23 = 134,
    KEY_F24 = 135,
    KEY_NUM_LOCK = 144,
    KEY_SCROLL_LOCK = 145,
    KEY_COMMA = 188,
    KEY_PERIOD = 190,
    KEY_SLASH = 191,
    KEY_BACK_QUOTE = 192,
    KEY_OPEN_BRACKET = 219,
    KEY_BACK_SLASH = 220,
    KEY_CLOSE_BRACKET = 221,
    KEY_QUOTE = 222,
    KEY_META = 224
}
declare namespace ppt {
    export enum EventType {
        KEY_PRESS,
        KEY_RELEASE,
        KEY_TYPED
    }
    export enum SpecialKey {
        CTRL,
        WINDOWS,
        SHIFT,
        ALT
    }
    export interface KeyDescriptor {
        key_code: string;
        key_ctrl: boolean;
        key_windows: boolean;
        key_shift: boolean;
        key_alt: boolean;
    }
    export interface KeyEvent extends KeyDescriptor {
        readonly type: EventType;
        readonly key: string;
    }
    export interface KeyHook extends KeyDescriptor {
        cancel: boolean;
        callback_press: () => any;
        callback_release: () => any;
    }
    export function key_description(key: KeyDescriptor);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/profiles/ConnectionProfile.ts */
declare namespace profiles {
    export class ConnectionProfile {
        id: string;
        profile_name: string;
        default_username: string;
        default_password: string;
        selected_identity_type: string;
        identities: {
            [key: string]: identities.Identity;
        };
        constructor(id: string);
        selected_identity(current_type?: identities.IdentitifyType): identities.Identity;
        selected_type?(): identities.IdentitifyType;
        set_identity(type: identities.IdentitifyType, identity: identities.Identity);
        spawn_identity_handshake_handler?(connection: connection.AbstractServerConnection): connection.HandshakeIdentityHandler;
        encode?(): string;
        valid(): boolean;
    }
    export function load(): Promise<any>;
    export function create_new_profile(name: string, id?: string): ConnectionProfile;
    export function save();
    export function mark_need_save();
    export function requires_save(): boolean;
    export function profiles(): ConnectionProfile[];
    export function find_profile(id: string): ConnectionProfile | undefined;
    export function find_profile_by_name(name: string): ConnectionProfile | undefined;
    export function default_profile(): ConnectionProfile;
    export function set_default_profile(profile: ConnectionProfile);
    export function delete_profile(profile: ConnectionProfile);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/profiles/identities/NameIdentity.ts */
declare namespace profiles.identities {
    export class NameHandshakeHandler extends AbstractHandshakeIdentityHandler {
        readonly identity: NameIdentity;
        handler: HandshakeCommandHandler<NameHandshakeHandler>;
        constructor(connection: connection.AbstractServerConnection, identity: profiles.identities.NameIdentity);
        start_handshake();
        protected trigger_fail(message: string);
        protected trigger_success();
    }
    export class NameIdentity implements Identity {
        private _name: string;
        constructor(name?: string);
        set_name(name: string);
        name(): string;
        uid(): string;
        type(): IdentitifyType;
        valid(): boolean;
        decode(data): Promise<void>;
        encode?(): string;
        spawn_identity_handshake_handler(connection: connection.AbstractServerConnection): connection.HandshakeIdentityHandler;
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/profiles/identities/TeaForumIdentity.ts */
declare namespace profiles.identities {
    export class TeaForumHandshakeHandler extends AbstractHandshakeIdentityHandler {
        readonly identity: TeaForumIdentity;
        handler: HandshakeCommandHandler<TeaForumHandshakeHandler>;
        constructor(connection: connection.AbstractServerConnection, identity: profiles.identities.TeaForumIdentity);
        start_handshake();
        private handle_proof(json);
        protected trigger_fail(message: string);
        protected trigger_success();
    }
    export class TeaForumIdentity implements Identity {
        private readonly identity_data: forum.Data;
        valid(): boolean;
        constructor(data: forum.Data);
        data(): forum.Data;
        decode(data): Promise<void>;
        encode(): string;
        spawn_identity_handshake_handler(connection: connection.AbstractServerConnection): connection.HandshakeIdentityHandler;
        name(): string;
        type(): profiles.identities.IdentitifyType;
        uid(): string;
    }
    export function set_static_identity(identity: TeaForumIdentity);
    export function update_forum();
    export function valid_static_forum_identity(): boolean;
    export function static_forum_identity(): TeaForumIdentity | undefined;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/profiles/identities/TeamSpeakIdentity.ts */
declare namespace profiles.identities {
    export namespace CryptoHelper {
        export function base64_url_encode(str);
        export function base64_url_decode(str: string, pad?: boolean);
        export function arraybuffer_to_string(buf);
        export function export_ecc_key(crypto_key: CryptoKey, public_key: boolean): Promise<any>;
        export function decrypt_ts_identity(buffer: Uint8Array): Promise<string>;
        export function encrypt_ts_identity(buffer: Uint8Array): Promise<string>;
        /**
         * @param buffer base64 encoded ASN.1 string
         */
        export function decode_tomcrypt_key(buffer: string);
    }
    export class TeaSpeakHandshakeHandler extends AbstractHandshakeIdentityHandler {
        identity: TeaSpeakIdentity;
        handler: HandshakeCommandHandler<TeaSpeakHandshakeHandler>;
        constructor(connection: connection.AbstractServerConnection, identity: TeaSpeakIdentity);
        start_handshake();
        private handle_proof(json);
        protected trigger_fail(message: string);
        protected trigger_success();
    }
    export class IdentityPOWWorker {
        private _worker: Worker;
        private _current_hash: string;
        private _best_level: number;
        initialize(key: string);
        mine(hash: string, iterations: number, target: number, timeout?: number): Promise<Boolean>;
        current_hash(): string;
        current_level(): number;
        finalize(timeout?: number);
        private handle_message(message: any);
    }
    export class TeaSpeakIdentity implements Identity {
        static generate_new(): Promise<TeaSpeakIdentity>;
        static import_ts(ts_string: string, ini?: boolean): Promise<TeaSpeakIdentity>;
        hash_number: string;
        private_key: string;
        _name: string;
        public_key: string;
        private _initialized: boolean;
        private _crypto_key: CryptoKey;
        private _crypto_key_sign: CryptoKey;
        private _unique_id: string;
        constructor(private_key?: string, hash?: string, name?: string, initialize?: boolean);
        name(): string;
        uid(): string;
        type(): IdentitifyType;
        valid(): boolean;
        decode(data: string): Promise<void>;
        encode?(): string;
        level(): Promise<number>;
        /**
         * @param {string} a
         * @param {string} b
         * @description b must be smaller (in bytes) then a
         */
        private string_add(a: string, b: string);
        improve_level_for(time: number, threads: number): Promise<Boolean>;
        improve_level(target: number, threads: number, active_callback: () => boolean, callback_level?: (current: number) => any, callback_status?: (hash_rate: number) => any): Promise<Boolean>;
        private initialize();
        export_ts(ini?: boolean): Promise<string>;
        sign_message(message: string, hash?: string): Promise<string>;
        spawn_identity_handshake_handler(connection: connection.AbstractServerConnection): connection.HandshakeIdentityHandler;
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/profiles/identities/teaspeak-forum.ts */
declare interface Window {
    grecaptcha: GReCaptcha;
}
declare interface GReCaptcha {
    render(container: string | HTMLElement, parameters: {
        sitekey: string;
        theme?: "dark" | "light";
        size?: "compact" | "normal";
        tabindex?: number;
        callback?: (token: string) => any;
        "expired-callback"?: () => any;
        "error-callback"?: (error: any) => any;
    }): string; /* widget_id */
    reset(widget_id?: string);
}
declare namespace forum {
    export namespace gcaptcha {
        export function initialize(): Promise<any>;
        export function spawn(container: JQuery, key: string, callback_data: (token: string) => any): Promise<any>;
    }
    export class Data {
        readonly auth_key: string;
        readonly raw: string;
        readonly sign: string;
        parsed: {
            user_id: number;
            user_name: string;
            data_age: number;
            user_group_id: number;
            is_staff: boolean;
            user_groups: number[];
        };
        constructor(auth: string, raw: string, sign: string);
        data_json(): string;
        data_sign(): string;
        name(): string;
        user_id();
        user_group();
        is_stuff(): boolean;
        is_premium(): boolean;
        data_age(): Date;
        is_expired(): boolean;
        should_renew(): boolean;
    }
    export function logged_in(): boolean;
    export function data(): Data;
    export interface LoginResult {
        status: "success" | "captcha" | "error";
        error_message?: string;
        captcha?: {
            type: "gre-captcha" | "unknown";
            data: any; /* in case of gre-captcha it would be the side key */
        };
    }
    export function login(username: string, password: string, captcha?: any): Promise<LoginResult>;
    export function renew_data(): Promise<"success" | "login-required">;
    export function logout(): Promise<void>;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/profiles/Identity.ts */
declare namespace profiles.identities {
    export enum IdentitifyType {
        TEAFORO,
        TEAMSPEAK,
        NICKNAME
    }
    export interface Identity {
        name(): string;
        uid(): string;
        type(): IdentitifyType;
        valid(): boolean;
        encode?(): string;
        decode(data: string): Promise<void>;
        spawn_identity_handshake_handler(connection: connection.AbstractServerConnection): connection.HandshakeIdentityHandler;
    }
    export function decode_identity(type: IdentitifyType, data: string): Promise<Identity>;
    export function create_identity(type: IdentitifyType);
    export class HandshakeCommandHandler<T extends AbstractHandshakeIdentityHandler> extends connection.AbstractCommandHandler {
        readonly handle: T;
        constructor(connection: connection.AbstractServerConnection, handle: T);
        handle_command(command: connection.ServerCommand): boolean;
    }
    export abstract class AbstractHandshakeIdentityHandler implements connection.HandshakeIdentityHandler {
        connection: connection.AbstractServerConnection;
        protected callbacks: ((success: boolean, message?: string) => any)[];
        protected constructor(connection: connection.AbstractServerConnection);
        register_callback(callback: (success: boolean, message?: string) => any);
        abstract start_handshake();
        protected trigger_success();
        protected trigger_fail(message: string);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/proto.ts */
declare interface Array<T> {
    remove(elem?: T): boolean;
    last?(): T;
    pop_front(): T | undefined;
}
declare interface JSON {
    map_to<T>(object: T, json: any, variables?: string | string[], validator?: (map_field: string, map_value: string) => boolean, variable_direction?: number): T;
    map_field_to<T>(object: T, value: any, field: string): T;
}
declare type JQueryScrollType = "height" | "width";
declare interface JQuery<TElement = HTMLElement> {
    render(values?: any): string;
    renderTag(values?: any): JQuery<TElement>;
    hasScrollBar(direction?: JQueryScrollType): boolean;
    visible_height(): number;
    visible_width(): number;
    /* bootstrap */
    alert(): JQuery<TElement>;
    modal(properties: any): this;
    bootstrapMaterialDesign(): this;
    /* first element which matches the selector, could be the element itself or a parent */
    firstParent(selector: string): JQuery;
}
declare interface JQueryStatic<TElement extends Node = HTMLElement> {
    spawn<K extends keyof HTMLElementTagNameMap>(tagName: K): JQuery<HTMLElementTagNameMap[K]>;
    views: any;
}
declare interface String {
    format(...fmt): string;
    format(arguments: string[]): string;
}
declare function concatenate(resultConstructor, ...arrays);
declare function formatDate(secs: number): string;
declare function calculate_width(text: string): number;
declare interface Twemoji {
    parse(message: string): string;
}
declare let twemoji: Twemoji;
declare interface HighlightJS {
    listLanguages(): string[];
    getLanguage(name: string): any | undefined;
    highlight(language: string, text: string, ignore_illegals?: boolean): HighlightJSResult;
    highlightAuto(text: string): HighlightJSResult;
}
declare interface HighlightJSResult {
    language: string;
    relevance: number;
    value: string;
    second_best?: any;
}
declare interface DOMPurify {
    sanitize(html: string, config?: {
        ADD_ATTR?: string[];
    }): string;
}
declare let DOMPurify: DOMPurify;
declare let remarkable: typeof window.remarkable;
declare class webkitAudioContext extends AudioContext {
}
declare class webkitOfflineAudioContext extends OfflineAudioContext {
}
declare interface Window {
    readonly webkitAudioContext: typeof webkitAudioContext;
    readonly AudioContext: typeof webkitAudioContext;
    readonly OfflineAudioContext: typeof OfflineAudioContext;
    readonly webkitOfflineAudioContext: typeof webkitOfflineAudioContext;
    readonly RTCPeerConnection: typeof RTCPeerConnection;
    readonly Pointer_stringify: any;
    readonly jsrender: any;
    twemoji: Twemoji;
    hljs: HighlightJS;
    remarkable: any;
    require(id: string): any;
}
declare interface Navigator {
    browserSpecs: {
        name: string;
        version: string;
    };
    mozGetUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
    webkitGetUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/settings.ts */
declare interface SettingsKey<T> {
    key: string;
    fallback_keys?: string | string[];
    fallback_imports?: {
        [key: string]: (value: string) => T;
    };
    description?: string;
    default_value?: T;
    require_restart?: boolean;
}
declare class SettingsBase {
    protected static readonly UPDATE_DIRECT: boolean;
    protected static transformStO?<T>(input?: string, _default?: T, default_type?: string): T;
    protected static transformOtS?<T>(input: T): string;
    protected static resolveKey<T>(key: SettingsKey<T>, _default: T, resolver: (key: string) => string | boolean, default_type?: string): T;
    protected static keyify<T>(key: string | SettingsKey<T>): SettingsKey<T>;
}
declare class StaticSettings extends SettingsBase {
    private static _instance: StaticSettings;
    // @ts-ignore
    static get instance(): StaticSettings;
    protected _handle: StaticSettings;
    protected _staticPropsTag: JQuery;
    protected constructor(_reserved?);
    private initializeStatic();
    static?<T>(key: string | SettingsKey<T>, _default?: T, default_type?: string): T;
    deleteStatic<T>(key: string | SettingsKey<T>);
}
declare class Settings extends StaticSettings {
    static readonly KEY_DISABLE_COSMETIC_SLOWDOWN: SettingsKey<boolean>;
    static readonly KEY_DISABLE_CONTEXT_MENU: SettingsKey<boolean>;
    static readonly KEY_DISABLE_GLOBAL_CONTEXT_MENU: SettingsKey<boolean>;
    static readonly KEY_DISABLE_UNLOAD_DIALOG: SettingsKey<boolean>;
    static readonly KEY_DISABLE_VOICE: SettingsKey<boolean>;
    static readonly KEY_DISABLE_MULTI_SESSION: SettingsKey<boolean>;
    static readonly KEY_LOAD_DUMMY_ERROR: SettingsKey<boolean>;
    /* Control bar */
    static readonly KEY_CONTROL_MUTE_INPUT: SettingsKey<boolean>;
    static readonly KEY_CONTROL_MUTE_OUTPUT: SettingsKey<boolean>;
    static readonly KEY_CONTROL_SHOW_QUERIES: SettingsKey<boolean>;
    static readonly KEY_CONTROL_CHANNEL_SUBSCRIBE_ALL: SettingsKey<boolean>;
    /* Connect parameters */
    static readonly KEY_FLAG_CONNECT_DEFAULT: SettingsKey<boolean>;
    static readonly KEY_CONNECT_ADDRESS: SettingsKey<string>;
    static readonly KEY_CONNECT_PROFILE: SettingsKey<string>;
    static readonly KEY_CONNECT_USERNAME: SettingsKey<string>;
    static readonly KEY_CONNECT_PASSWORD: SettingsKey<string>;
    static readonly KEY_FLAG_CONNECT_PASSWORD: SettingsKey<boolean>;
    static readonly KEY_CONNECT_HISTORY: SettingsKey<string>;
    static readonly KEY_CERTIFICATE_CALLBACK: SettingsKey<string>;
    /* sounds */
    static readonly KEY_SOUND_MASTER: SettingsKey<number>;
    static readonly KEY_SOUND_MASTER_SOUNDS: SettingsKey<number>;
    static readonly KEY_CHAT_FIXED_TIMESTAMPS: SettingsKey<boolean>;
    static readonly KEY_CHAT_COLLOQUIAL_TIMESTAMPS: SettingsKey<boolean>;
    static readonly KEY_CHAT_COLORED_EMOJIES: SettingsKey<boolean>;
    static readonly KEY_CHAT_TAG_URLS: SettingsKey<boolean>;
    static readonly KEY_CHAT_ENABLE_MARKDOWN: SettingsKey<boolean>;
    static readonly KEY_CHAT_ENABLE_BBCODE: SettingsKey<boolean>;
    static readonly KEY_SWITCH_INSTANT_CHAT: SettingsKey<boolean>;
    static readonly KEY_SWITCH_INSTANT_CLIENT: SettingsKey<boolean>;
    static readonly KEY_HOSTBANNER_BACKGROUND: SettingsKey<boolean>;
    static readonly KEY_CHANNEL_EDIT_ADVANCED: SettingsKey<boolean>;
    static readonly KEY_TEAFORO_URL: SettingsKey<string>;
    static readonly KEY_FONT_SIZE: SettingsKey<number>;
    static readonly FN_SERVER_CHANNEL_SUBSCRIBE_MODE: (channel_id: number) => SettingsKey<number>;
    static readonly FN_PROFILE_RECORD: (name: string) => SettingsKey<any>;
    static readonly KEYS;
    static initialize();
    private cacheGlobal;
    private saveWorker: NodeJS.Timer;
    private updated: boolean;
    constructor();
    static_global?<T>(key: string | SettingsKey<T>, _default?: T): T;
    global?<T>(key: string | SettingsKey<T>, _default?: T): T;
    changeGlobal<T>(key: string | SettingsKey<T>, value?: T);
    save();
}
declare class ServerSettings extends SettingsBase {
    private cacheServer;
    private _server_unique_id: string;
    private _server_save_worker: NodeJS.Timer;
    private _server_settings_updated: boolean;
    private _destroyed;
    constructor();
    destroy();
    server?<T>(key: string | SettingsKey<T>, _default?: T): T;
    changeServer<T>(key: string | SettingsKey<T>, value?: T);
    setServer(server_unique_id: string);
    save();
}
declare let settings: Settings;

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/sound/Sounds.ts */
declare enum Sound {
    SOUND_TEST = "sound.test",
    SOUND_EGG = "sound.egg",
    AWAY_ACTIVATED = "away_activated",
    AWAY_DEACTIVATED = "away_deactivated",
    MICROPHONE_MUTED = "microphone.muted",
    MICROPHONE_ACTIVATED = "microphone.activated",
    SOUND_MUTED = "sound.muted",
    SOUND_ACTIVATED = "sound.activated",
    CONNECTION_CONNECTED = "connection.connected",
    CONNECTION_DISCONNECTED = "connection.disconnected",
    CONNECTION_BANNED = "connection.banned",
    CONNECTION_DISCONNECTED_TIMEOUT = "connection.disconnected.timeout",
    CONNECTION_REFUSED = "connection.refused",
    SERVER_EDITED = "server.edited",
    SERVER_EDITED_SELF = "server.edited.self",
    SERVER_KICKED = "server.kicked",
    CHANNEL_CREATED = "channel.created",
    CHANNEL_MOVED = "channel.moved",
    CHANNEL_EDITED = "channel.edited",
    CHANNEL_EDITED_SELF = "channel.edited.self",
    CHANNEL_DELETED = "channel.deleted",
    CHANNEL_JOINED = "channel.joined",
    CHANNEL_KICKED = "channel.kicked",
    USER_MOVED = "user.moved",
    USER_MOVED_SELF = "user.moved.self",
    USER_POKED_SELF = "user.poked.self",
    USER_BANNED = "user.banned",
    USER_ENTERED = "user.joined",
    USER_ENTERED_MOVED = "user.joined.moved",
    USER_ENTERED_KICKED = "user.joined.kicked",
    USER_ENTERED_CONNECT = "user.joined.connect",
    USER_LEFT = "user.left",
    USER_LEFT_MOVED = "user.left.moved",
    USER_LEFT_KICKED_CHANNEL = "user.left.kicked.server",
    USER_LEFT_KICKED_SERVER = "user.left.kicked.channel",
    USER_LEFT_DISCONNECT = "user.left.disconnect",
    USER_LEFT_BANNED = "user.left.banned",
    USER_LEFT_TIMEOUT = "user.left.timeout",
    ERROR_INSUFFICIENT_PERMISSIONS = "error.insufficient_permissions",
    MESSAGE_SEND = "message.send",
    MESSAGE_RECEIVED = "message.received",
    GROUP_SERVER_ASSIGNED = "group.server.assigned",
    GROUP_SERVER_REVOKED = "group.server.revoked",
    GROUP_CHANNEL_CHANGED = "group.channel.changed",
    GROUP_SERVER_ASSIGNED_SELF = "group.server.assigned.self",
    GROUP_SERVER_REVOKED_SELF = "group.server.revoked.self",
    GROUP_CHANNEL_CHANGED_SELF = "group.channel.changed.self"
}
declare namespace sound {
    export interface SoundHandle {
        key: string;
        filename: string;
        not_supported?: boolean;
        not_supported_timeout?: number;
        cached?: AudioBuffer;
        node?: HTMLAudioElement;
        replaying: boolean;
    }
    export function get_sound_volume(sound: Sound, default_volume?: number): number;
    export function set_sound_volume(sound: Sound, volume: number);
    export function get_master_volume(): number;
    export function set_master_volume(volume: number);
    export function overlap_activated(): boolean;
    export function set_overlap_activated(flag: boolean);
    export function ignore_output_muted(): boolean;
    export function set_ignore_output_muted(flag: boolean);
    export function reinitialisize_audio();
    export function save();
    export function initialize(): Promise<void>;
    export interface PlaybackOptions {
        ignore_muted?: boolean;
        ignore_overlap?: boolean;
        default_volume?: number;
        callback?: (flag: boolean) => any;
    }
    export function resolve_sound(sound: Sound): Promise<SoundHandle>;
    export let manager: SoundManager;
    export class SoundManager {
        private _handle: ConnectionHandler;
        private _playing_sounds: {
            [key: string]: number;
        };
        constructor(handle: ConnectionHandler);
        play(_sound: Sound, options?: PlaybackOptions);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/stats.ts */
declare namespace stats {
    export enum CloseCodes {
        UNSET = 3000,
        RECONNECT = 3001,
        INTERNAL_ERROR = 3002,
        BANNED = 3100
    }
    export enum ConnectionState {
        CONNECTING,
        INITIALIZING,
        CONNECTED,
        UNSET
    }
    export class SessionConfig {
        /*
         * All collected statistics will only be cached by the stats server.
         * No data will be saved.
         */
        volatile_collection_only?: boolean;
        /*
         * Anonymize all IP addresses which will be provided while the stats collection.
         * This option is quite useless when volatile_collection_only is active.
         */
        anonymize_ip_addresses?: boolean;
    }
    export class Config extends SessionConfig {
        verbose?: boolean;
        reconnect_interval?: number;
    }
    export interface UserCountData {
        online_users: number;
        unique_online_users: number;
    }
    export type UserCountListener = (data: UserCountData) => any;
    export function initialize(config: Config);
    export function register_user_count_listener(listener: UserCountListener);
    export function all_user_count_listener(): UserCountListener[];
    export function deregister_user_count_listener(listener: UserCountListener);
    namespace connection {
        export let connection_state: ConnectionState;
        export function start_connection();
        export function close_connection();
        export function cancel_reconnect();
        namespace handler { }
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/channel.ts */
declare enum ChannelType {
    PERMANENT,
    SEMI_PERMANENT,
    TEMPORARY
}
declare namespace ChannelType {
    export function normalize(mode: ChannelType);
}
declare enum ChannelSubscribeMode {
    SUBSCRIBED,
    UNSUBSCRIBED,
    INHERITED
}
declare class ChannelProperties {
    channel_order: number;
    channel_name: string;
    channel_name_phonetic: string;
    channel_topic: string;
    channel_password: string;
    channel_codec: number;
    channel_codec_quality: number;
    channel_codec_is_unencrypted: boolean;
    channel_maxclients: number;
    channel_maxfamilyclients: number;
    channel_needed_talk_power: number;
    channel_flag_permanent: boolean;
    channel_flag_semi_permanent: boolean;
    channel_flag_default: boolean;
    channel_flag_password: boolean;
    channel_flag_maxclients_unlimited: boolean;
    channel_flag_maxfamilyclients_inherited: boolean;
    channel_flag_maxfamilyclients_unlimited: boolean;
    channel_icon_id: number;
    channel_delete_delay: number;
    //Only after request
    channel_description: string;
    channel_flag_conversation_private: boolean;
}
declare class ChannelEntry {
    channelTree: ChannelTree;
    channelId: number;
    parent?: ChannelEntry;
    properties: ChannelProperties;
    channel_previous?: ChannelEntry;
    channel_next?: ChannelEntry;
    private _channel_name_alignment: string;
    private _channel_name_formatted: string;
    private _family_index: number;
    //HTML DOM elements
    private _tag_root: JQuery<HTMLElement>;
    private _tag_siblings: JQuery<HTMLElement>;
    private _tag_clients: JQuery<HTMLElement>;
    private _tag_channel: JQuery<HTMLElement>;
    private _destroyed;
    private _cachedPassword: string;
    private _cached_channel_description: string;
    private _cached_channel_description_promise: Promise<string>;
    private _cached_channel_description_promise_resolve: any;
    private _cached_channel_description_promise_reject: any;
    private _flag_subscribed: boolean;
    private _subscribe_mode: ChannelSubscribeMode;
    constructor(channelId, channelName, parent?);
    destroy();
    channelName();
    formattedChannelName();
    getChannelDescription(): Promise<string>;
    parent_channel();
    hasParent();
    getChannelId();
    children(deep?): ChannelEntry[];
    clients(deep?): ClientEntry[];
    clients_ordered(): ClientEntry[];
    update_family_index(enforce?: boolean);
    calculate_family_index(enforce_recalculate?: boolean): number;
    private initializeTag();
    rootTag(): JQuery<HTMLElement>;
    channelTag(): JQuery<HTMLElement>;
    siblingTag(): JQuery<HTMLElement>;
    clientTag(): JQuery<HTMLElement>;
    reorderClients();
    initializeListener();
    showContextMenu(x: number, y: number, on_close?: () => void);
    handle_frame_resized();
    private static NAME_ALIGNMENTS: string[];
    private __updateChannelName();
    recalculate_repetitive_name();
    updateVariables(...variables: {
        key: string;
        value: string;
    }[]);
    updateChannelTypeIcon();
    generate_bbcode();
    generate_tag(braces?: boolean): JQuery;
    channelType(): ChannelType;
    joinChannel();
    cached_password();
    subscribe(): Promise<void>;
    unsubscribe(inherited_subscription_mode?: boolean): Promise<void>;
    // @ts-ignore
    get flag_subscribed(): boolean;
    // @ts-ignore
    set flag_subscribed(flag: boolean);
    // @ts-ignore
    get subscribe_mode(): ChannelSubscribeMode;
    // @ts-ignore
    set subscribe_mode(mode: ChannelSubscribeMode);
    // @ts-ignore
    set flag_text_unread(flag: boolean);
    log_data(): log.server.base.Channel;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/client_move.ts */
declare class ClientMover {
    static readonly listener_root;
    static readonly move_element;
    readonly channel_tree: ChannelTree;
    selected_client: ClientEntry | ClientEntry[];
    hovered_channel: HTMLDivElement;
    callback: (channel?: ChannelEntry) => any;
    enabled: boolean;
    private _bound_finish;
    private _bound_move;
    private _active: boolean;
    private origin_point: {
        x: number;
        y: number;
    };
    constructor(tree: ChannelTree);
    is_active();
    private hover_text();
    private bbcode_text();
    activate(client: ClientEntry | ClientEntry[], callback: (channel?: ChannelEntry) => any, event: any);
    private move_listener(event);
    private finish_listener(event);
    deactivate();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/client.ts */
declare enum ClientType {
    CLIENT_VOICE,
    CLIENT_QUERY,
    CLIENT_INTERNAL,
    CLIENT_WEB,
    CLIENT_MUSIC,
    CLIENT_UNDEFINED
}
declare class ClientProperties {
    client_type: ClientType;
    client_type_exact: ClientType;
    client_database_id: number;
    client_version: string;
    client_platform: string;
    client_nickname: string;
    client_unique_identifier: string;
    client_description: string;
    client_servergroups: string;
    client_channel_group_id: number;
    client_lastconnected: number;
    client_created: number;
    client_totalconnections: number;
    client_flag_avatar: string;
    client_icon_id: number;
    client_away_message: string;
    client_away: boolean;
    client_country: string;
    client_input_hardware: boolean;
    client_output_hardware: boolean;
    client_input_muted: boolean;
    client_output_muted: boolean;
    client_is_channel_commander: boolean;
    client_teaforo_id: number;
    client_teaforo_name: string;
    client_teaforo_flags: number;
    /* not updated in view! */
    client_month_bytes_uploaded: number;
    client_month_bytes_downloaded: number;
    client_total_bytes_uploaded: number;
    client_total_bytes_downloaded: number;
    client_talk_power: number;
}
declare class ClientConnectionInfo {
    connection_bandwidth_received_last_minute_control: number;
    connection_bandwidth_received_last_minute_keepalive: number;
    connection_bandwidth_received_last_minute_speech: number;
    connection_bandwidth_received_last_second_control: number;
    connection_bandwidth_received_last_second_keepalive: number;
    connection_bandwidth_received_last_second_speech: number;
    connection_bandwidth_sent_last_minute_control: number;
    connection_bandwidth_sent_last_minute_keepalive: number;
    connection_bandwidth_sent_last_minute_speech: number;
    connection_bandwidth_sent_last_second_control: number;
    connection_bandwidth_sent_last_second_keepalive: number;
    connection_bandwidth_sent_last_second_speech: number;
    connection_bytes_received_control: number;
    connection_bytes_received_keepalive: number;
    connection_bytes_received_speech: number;
    connection_bytes_sent_control: number;
    connection_bytes_sent_keepalive: number;
    connection_bytes_sent_speech: number;
    connection_packets_received_control: number;
    connection_packets_received_keepalive: number;
    connection_packets_received_speech: number;
    connection_packets_sent_control: number;
    connection_packets_sent_keepalive: number;
    connection_packets_sent_speech: number;
    connection_ping: number;
    connection_ping_deviation: number;
    connection_server2client_packetloss_control: number;
    connection_server2client_packetloss_keepalive: number;
    connection_server2client_packetloss_speech: number;
    connection_server2client_packetloss_total: number;
    connection_client2server_packetloss_speech: number;
    connection_client2server_packetloss_keepalive: number;
    connection_client2server_packetloss_control: number;
    connection_client2server_packetloss_total: number;
    connection_filetransfer_bandwidth_sent: number;
    connection_filetransfer_bandwidth_received: number;
    connection_connected_time: number;
    connection_idle_time: number;
    connection_client_ip: string | undefined;
    connection_client_port: number;
}
declare class ClientEntry {
    protected _clientId: number;
    protected _channel: ChannelEntry;
    protected _tag: JQuery<HTMLElement>;
    protected _properties: ClientProperties;
    protected lastVariableUpdate: number;
    protected _speaking: boolean;
    protected _listener_initialized: boolean;
    protected _audio_handle: connection.voice.VoiceClient;
    protected _audio_volume: number;
    protected _audio_muted: boolean;
    private _info_variables_promise: Promise<void>;
    private _info_variables_promise_timestamp: number;
    private _info_connection_promise: Promise<ClientConnectionInfo>;
    private _info_connection_promise_timestamp: number;
    private _info_connection_promise_resolve: any;
    private _info_connection_promise_reject: any;
    channelTree: ChannelTree;
    constructor(clientId: number, clientName, properties?: ClientProperties);
    destroy();
    tree_unregistered();
    set_audio_handle(handle: connection.voice.VoiceClient);
    get_audio_handle(): connection.voice.VoiceClient;
    // @ts-ignore
    get properties(): ClientProperties;
    currentChannel(): ChannelEntry;
    clientNickName();
    clientUid();
    clientId();
    is_muted();
    set_muted(flag: boolean, update_icon: boolean, force?: boolean);
    protected initializeListener();
    protected contextmenu_info(): contextmenu.MenuEntry[];
    protected assignment_context(): contextmenu.MenuEntry[];
    open_text_chat();
    showContextMenu(x: number, y: number, on_close?: () => void);
    // @ts-ignore
    get tag(): JQuery<HTMLElement>;
    static bbcodeTag(id: number, name: string, uid: string): string;
    static chatTag(id: number, name: string, uid: string, braces?: boolean): JQuery;
    create_bbcode(): string;
    createChatTag(braces?: boolean): JQuery;
    // @ts-ignore
    set speaking(flag);
    updateClientStatusIcons();
    updateClientSpeakIcon();
    updateAwayMessage();
    updateVariables(...variables: {
        key: string;
        value: string;
    }[]);
    update_displayed_client_groups();
    updateClientVariables(force_update?: boolean): Promise<void>;
    updateClientIcon();
    updateGroupIcon(group: Group);
    update_group_icon_order();
    assignedServerGroupIds(): number[];
    assignedChannelGroup(): number;
    groupAssigned(group: Group): boolean;
    onDelete();
    calculateOnlineTime(): number;
    avatarId?(): string;
    update_family_index();
    log_data(): log.server.base.Client;
    /* max 1s ago, so we could update every second */
    request_connection_info(): Promise<ClientConnectionInfo>;
    set_connection_info(info: ClientConnectionInfo);
}
declare class LocalClientEntry extends ClientEntry {
    handle: ConnectionHandler;
    private renaming: boolean;
    constructor(handle: ConnectionHandler);
    showContextMenu(x: number, y: number, on_close?: () => void): void;
    initializeListener(): void;
    openRename(): void;
}
declare class MusicClientProperties extends ClientProperties {
    player_state: number;
    player_volume: number;
    client_playlist_id: number;
    client_disabled: boolean;
}
declare class MusicClientPlayerInfo {
    bot_id: number;
    player_state: number;
    player_buffered_index: number;
    player_replay_index: number;
    player_max_index: number;
    player_seekable: boolean;
    player_title: string;
    player_description: string;
    song_id: number;
    song_url: string;
    song_invoker: number;
    song_loaded: boolean;
    song_title: string;
    song_thumbnail: string;
    song_length: number;
}
declare class MusicClientEntry extends ClientEntry {
    private _info_promise: Promise<MusicClientPlayerInfo>;
    private _info_promise_age: number;
    private _info_promise_resolve: any;
    private _info_promise_reject: any;
    constructor(clientId, clientName);
    destroy();
    // @ts-ignore
    get properties(): MusicClientProperties;
    showContextMenu(x: number, y: number, on_close?: () => void): void;
    initializeListener(): void;
    handlePlayerInfo(json);
    requestPlayerInfo(max_age?: number): Promise<MusicClientPlayerInfo>;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/context_divider.ts */
declare interface JQuery<TElement = HTMLElement> {
    dividerfy(): this;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/context_menu.ts */
declare namespace contextmenu {
    export interface MenuEntry {
        callback?: () => void;
        type: MenuEntryType;
        name: (() => string) | string;
        icon_class?: string;
        icon_path?: string;
        disabled?: boolean;
        visible?: boolean;
        checkbox_checked?: boolean;
        invalidPermission?: boolean;
        sub_menu?: MenuEntry[];
    }
    export enum MenuEntryType {
        CLOSE,
        ENTRY,
        CHECKBOX,
        HR,
        SUB_MENU
    }
    export class Entry {
        static HR();
        static CLOSE(callback: () => void);
    }
    export interface ContextMenuProvider {
        despawn_context_menu();
        spawn_context_menu(x: number, y: number, ...entries: MenuEntry[]);
        initialize();
        finalize();
        html_format_enabled(): boolean;
    }
    export function spawn_context_menu(x: number, y: number, ...entries: MenuEntry[]);
    export function despawn_context_menu();
    export function get_provider(): ContextMenuProvider;
    export function set_provider(_provider: ContextMenuProvider);
}
declare class HTMLContextMenuProvider implements contextmenu.ContextMenuProvider {
    private _global_click_listener: (event) => any;
    private _context_menu: JQuery;
    private _close_callbacks: (() => any)[];
    private _visible;
    despawn_context_menu();
    finalize();
    initialize();
    private on_global_click(event);
    private generate_tag(entry: contextmenu.MenuEntry): JQuery;
    spawn_context_menu(x: number, y: number, ...entries: contextmenu.MenuEntry[]);
    html_format_enabled(): boolean;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/modal.ts */
declare enum ElementType {
    HEADER,
    BODY,
    FOOTER
}
declare type BodyCreator = (() => JQuery | JQuery[] | string) | string | JQuery | JQuery[];
declare const ModalFunctions;
declare class ModalProperties {
    template?: string;
    header: BodyCreator;
    body: BodyCreator;
    footer: BodyCreator;
    closeListener: (() => void) | (() => void)[];
    registerCloseListener(listener: () => void): this;
    width: number | string;
    min_width?: number | string;
    height: number | string;
    closeable: boolean;
    triggerClose();
    template_properties?: any;
    trigger_tab: boolean;
    full_size?: boolean;
}
declare let _global_modal_count;
declare let _global_modal_last: HTMLElement;
declare let _global_modal_last_time: number;
declare class Modal {
    private _htmlTag: JQuery;
    properties: ModalProperties;
    shown: boolean;
    open_listener: (() => any)[];
    close_listener: (() => any)[];
    close_elements: JQuery;
    constructor(props: ModalProperties);
    // @ts-ignore
    get htmlTag(): JQuery;
    private _create();
    open();
    close();
    set_closeable(flag: boolean);
}
declare function createModal(data: ModalProperties | any): Modal;
declare class InputModalProperties extends ModalProperties {
    maxLength?: number;
    field_title?: string;
    field_label?: string;
    field_placeholder?: string;
    error_message?: string;
}
declare function createInputModal(headMessage: BodyCreator, question: BodyCreator, validator: (input: string) => boolean, callback: (flag: boolean | string) => void, props?: InputModalProperties | any): Modal;
declare function createErrorModal(header: BodyCreator, message: BodyCreator, props?: ModalProperties | any);
declare function createInfoModal(header: BodyCreator, message: BodyCreator, props?: ModalProperties | any);
declare interface ModalElements {
    header?: BodyCreator;
    body?: BodyCreator;
    footer?: BodyCreator;
}
declare interface JQuery<TElement = HTMLElement> {
    modalize(entry_callback?: (header: JQuery, body: JQuery, footer: JQuery) => ModalElements | void, properties?: ModalProperties | any): Modal;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/net_graph.ts */
declare namespace net.graph {
    export type Entry = {
        timestamp: number;
        upload: number;
        download: number;
    };
    export type Style = {
        background_color: string;
        separator_color: string;
        separator_count: number;
        separator_width: number;
        upload: {
            fill: string;
            stroke: string;
            strike_width: number;
        };
        download: {
            fill: string;
            stroke: string;
            strike_width: number;
        };
    };
    export type TimeSpan = {
        origin: {
            begin: number;
            end: number;
            time: number;
        };
        target: {
            begin: number;
            end: number;
            time: number;
        };
    };
    /* Great explanation of Bezier curves: http://en.wikipedia.org/wiki/Bezier_curve#Quadratic_curves
     *
     * Assuming A was the last point in the line plotted and B is the new point,
     * we draw a curve with control points P and Q as below.
     *
     * A---P
     *     |
     *     |
     *     |
     *     Q---B
     *
     * Importantly, A and P are at the same y coordinate, as are B and Q. This is
     * so adjacent curves appear to flow as one.
     */
    export class Graph {
        private static _loops: (() => any)[];
        readonly canvas: HTMLCanvasElement;
        public style: Style;
        private _canvas_context: CanvasRenderingContext2D;
        private _entries: Entry[];
        private _entry_max;
        private _max_space;
        private _max_gap;
        private _animate_loop;
        private _time_span: TimeSpan;
        constructor(canvas: HTMLCanvasElement);
        initialize();
        terminate();
        max_gap_size(value?: number): number;
        private recalculate_cache(time_span?: boolean);
        insert_entry(entry: Entry);
        insert_entries(entries: Entry[]);
        resize();
        cleanup();
        private calculate_time_span(): {
            begin: number;
            end: number;
        };
        draw();
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/slider.ts */
declare interface SliderOptions {
    min_value?: number;
    max_value?: number;
    initial_value?: number;
    step?: number;
    unit?: string;
    value_field?: JQuery | JQuery[];
}
declare interface Slider {
    value(value?: number): number;
}
declare function sliderfy(slider: JQuery, options?: SliderOptions): Slider;

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/tab.ts */
declare interface JQuery<TElement = HTMLElement> {
    asTabWidget(copy?: boolean): JQuery<TElement>;
    tabify(copy?: boolean): this;
    changeElementType(type: string): JQuery<TElement>;
}
declare var TabFunctions;

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/tooltip.ts */
declare function tooltip(entry: JQuery);
declare namespace tooltip {
    export type Handle = {
        show();
        is_shown();
        hide();
        update();
    };
    export function initialize(entry: JQuery): Handle;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/frames/chat_frame.ts */
declare namespace chat {
    export enum InfoFrameMode {
        NONE = "none",
        CHANNEL_CHAT = "channel_chat",
        PRIVATE_CHAT = "private_chat",
        CLIENT_INFO = "client_info"
    }
    export class InfoFrame {
        private readonly handle: Frame;
        private _html_tag: JQuery;
        private _mode: InfoFrameMode;
        private _value_ping: JQuery;
        private _ping_updater: number;
        private _button_conversation: HTMLElement;
        constructor(handle: Frame);
        html_tag(): JQuery;
        destroy();
        private _build_html_tag();
        update_ping();
        update_channel_talk();
        update_channel_text();
        update_chat_counter();
        current_mode(): InfoFrameMode;
        set_mode(mode: InfoFrameMode);
    }
    export class ChatBox {
        private _html_tag: JQuery;
        private _html_input: JQuery<HTMLDivElement>;
        private _enabled: boolean;
        private __callback_text_changed;
        private __callback_key_down;
        private __callback_paste;
        private _typing_timeout: number;
        private _typing_last_event: number;
        typing_interval: number;
        callback_typing: () => any;
        callback_text: (text: string) => any;
        constructor();
        html_tag(): JQuery;
        destroy();
        private _initialize_listener();
        private _build_html_tag();
        private _callback_text_changed(event: Event);
        private _text(element: HTMLElement);
        private htmlEscape(message: string): string;
        private _callback_paste(event: ClipboardEvent);
        private test_message(message: string): boolean;
        private _callback_key_down(event: KeyboardEvent);
        set_enabled(flag: boolean);
        is_enabled();
        focus_input();
    }
    export namespace helpers {
        namespace md2bbc {
            export type RemarkToken = {
                type: string;
                tight: boolean;
                lines: number[];
                level: number;
                /* img */
                alt?: string;
                src?: string;
                /* link */
                href?: string;
                /* table */
                align?: string;
                /* code  */
                params?: string;
                content?: string;
                hLevel?: number;
                children?: RemarkToken[];
            };
            export class Renderer {
                private static renderers;
                private _options;
                render(tokens: RemarkToken[], options: any, env: any);
                private render_token(token: RemarkToken, index: number);
                private render_inline(tokens: RemarkToken[], index: number);
                options(): any;
                maybe_escape_bb(text: string);
            }
        }
        export function preprocess_chat_message(message: string): string;
        export namespace history {
            export function load_history(key: string): Promise<any | undefined>;
            export function save_history(key: string, value: any): Promise<any>;
        }
        export namespace date {
            export function same_day(a: number | Date, b: number | Date);
        }
    }
    export namespace format {
        export namespace date {
            export enum ColloquialFormat {
                YESTERDAY,
                TODAY,
                GENERAL
            }
            export function date_format(date: Date, now: Date, ignore_settings?: boolean): ColloquialFormat;
            export function format_date_general(date: Date, hours?: boolean): string;
            export function format_date_colloquial(date: Date, current_timestamp: Date): {
                result: string;
                format: ColloquialFormat;
            };
            export function format_chat_time(date: Date): {
                result: string;
                next_update: number; /* in MS */
            };
        }
        export namespace time {
            export function format_online_time(secs: number): string;
        }
    }
    export type PrivateConversationViewEntry = {
        html_tag: JQuery;
    };
    export type PrivateConversationMessageData = {
        message_id: string;
        message: string;
        sender: "self" | "partner";
        sender_name: string;
        sender_unique_id: string;
        sender_client_id: number;
        timestamp: number;
    };
    export type PrivateConversationViewMessage = PrivateConversationMessageData & PrivateConversationViewEntry & {
        time_update_id: number;
    };
    export type PrivateConversationViewSpacer = PrivateConversationViewEntry;
    export enum PrivateConversationState {
        OPEN,
        CLOSED,
        DISCONNECTED
    }
    export type DisplayedMessage = {
        timestamp: number;
        message: PrivateConversationViewMessage | PrivateConversationViewEntry;
        message_type: "spacer" | "message";
        /* structure as following
            1. time pointer
            2. unread
            3. message
         */
        tag_message: JQuery;
        tag_unread: PrivateConversationViewSpacer | undefined;
        tag_timepointer: PrivateConversationViewSpacer | undefined;
    };
    export class PrivateConveration {
        readonly handle: PrivateConverations;
        private _html_entry_tag: JQuery;
        private _message_history: PrivateConversationMessageData[];
        private _callback_message: (text: string) => any;
        private _state: PrivateConversationState;
        private _last_message_updater_id: number;
        private _last_typing: number;
        private _typing_timeout: number;
        private _typing_timeout_task: number;
        _scroll_position: number | undefined;
        _html_message_container: JQuery;
        client_unique_id: string;
        client_id: number;
        client_name: string;
        private _displayed_messages: DisplayedMessage[];
        private _displayed_messages_length: number;
        private _spacer_unread_message: DisplayedMessage;
        constructor(handle: PrivateConverations, client_unique_id: string, client_name: string, client_id: number);
        private history_key();
        private load_history();
        private save_history();
        entry_tag(): JQuery;
        destroy();
        private _2d_flat<T>(array: T[][]): T[];
        messages_tags(): JQuery[];
        append_message(message: string, sender: {
            type: "self" | "partner";
            name: string;
            unique_id: string;
            client_id: number;
        }, timestamp?: Date, save_history?: boolean);
        private _displayed_message_first_tag(message: DisplayedMessage);
        private _destroy_displayed_message(message: DisplayedMessage, update_pointers: boolean);
        clear_messages(save?: boolean);
        fix_scroll(animate: boolean);
        private _update_message_timestamp();
        private _destroy_message(message: PrivateConversationViewMessage);
        private _build_message(message: PrivateConversationMessageData): PrivateConversationViewMessage;
        private _build_spacer(message: string, type: "date" | "new" | "disconnect" | "reconnect" | "closed" | "error"): PrivateConversationViewSpacer;
        private _register_displayed_message(message: DisplayedMessage);
        private _destroy_view_entry(entry: PrivateConversationViewEntry);
        private _build_entry_tag();
        update_avatar();
        close_conversation();
        set_client_name(name: string);
        set_unread_flag(flag: boolean, update_chat_counter?: boolean);
        is_unread(): boolean;
        private _append_state_change(state: "disconnect" | "reconnect" | "closed");
        state(): PrivateConversationState;
        set_state(state: PrivateConversationState);
        set_text_callback(callback: (text: string) => any, update_enabled_state?: boolean);
        chat_enabled();
        append_error(message: string, date?: number);
        call_message(message: string);
        private typing_expired();
        trigger_typing();
        typing_active();
    }
    export class PrivateConverations {
        readonly handle: Frame;
        private _chat_box: ChatBox;
        private _html_tag: JQuery;
        private _container_conversation: JQuery;
        private _container_conversation_messages: JQuery;
        private _container_conversation_list: JQuery;
        private _container_typing: JQuery;
        private _html_no_chats: JQuery;
        private _conversations: PrivateConveration[];
        private _current_conversation: PrivateConveration;
        private _select_read_timer: number;
        constructor(handle: Frame);
        clear_client_ids();
        html_tag(): JQuery;
        destroy();
        current_conversation(): PrivateConveration | undefined;
        conversations(): PrivateConveration[];
        create_conversation(client_uid: string, client_name: string, client_id: number): PrivateConveration;
        delete_conversation(conv: PrivateConveration, update_chat_couner?: boolean);
        find_conversation(partner: {
            name: string;
            unique_id: string;
            client_id: number;
        }, mode: {
            create: boolean;
            attach: boolean;
        }): PrivateConveration | undefined;
        clear_conversations();
        set_selected_conversation(conv: PrivateConveration | undefined);
        update_chatbox_state();
        update_typing_state();
        private _build_html_tag();
        try_input_focus();
        on_show();
    }
    export namespace channel {
        export type ViewEntry = {
            html_element: JQuery;
            update_timer?: number;
        };
        export type MessageData = {
            timestamp: number;
            message: string;
            sender_name: string;
            sender_unique_id: string;
            sender_database_id: number;
        };
        export type Message = MessageData & ViewEntry;
        export class Conversation {
            readonly handle: ConversationManager;
            readonly channel_id: number;
            private _flag_private: boolean;
            private _html_tag: JQuery;
            private _container_messages: JQuery;
            private _container_new_message: JQuery;
            private _container_no_permissions: JQuery;
            private _container_is_private: JQuery;
            private _view_max_messages;
            private _view_older_messages: ViewEntry;
            private _has_older_messages: boolean;
            private _view_entries: ViewEntry[];
            private _last_messages: MessageData[];
            private _last_messages_timestamp: number;
            private _first_unread_message: Message;
            private _first_unread_message_pointer: ViewEntry;
            private _scroll_position: number | undefined;
            constructor(handle: ConversationManager, channel_id: number);
            html_tag(): JQuery;
            destroy();
            private _build_html_tag();
            is_unread();
            mark_read();
            private _mark_read();
            private _generate_view_message(data: MessageData): Message;
            private _generate_view_spacer(message: string, type: "date" | "new" | "old" | "error"): ViewEntry;
            last_messages_timestamp(): number;
            fetch_last_messages();
            fetch_older_messages();
            register_new_message(message: MessageData, update_view?: boolean);
            fix_scroll(animate: boolean);
            fix_view_size();
            chat_available(): boolean;
            text_send_failed(error: CommandResult | any);
            set_flag_private(flag: boolean);
            update_private_state();
            delete_message(message: MessageData);
            delete_messages(begin: number, end: number, sender: number, limit: number);
            private _delete_message(message: Message);
        }
        export class ConversationManager {
            readonly handle: Frame;
            private _html_tag: JQuery;
            private _chat_box: ChatBox;
            private _container_conversation: JQuery;
            private _conversations: Conversation[];
            private _current_conversation: Conversation | undefined;
            private _needed_listener;
            constructor(handle: Frame);
            initialize_needed_listener();
            html_tag(): JQuery;
            destroy();
            update_chat_box();
            private _build_html_tag();
            set_current_channel(channel_id: number, update_info_frame?: boolean);
            current_channel(): number;
            /* Used by notifychanneldeleted */
            delete_conversation(channel_id: number);
            reset();
            conversation(channel_id: number, create?: boolean): Conversation;
            on_show();
        }
    }
    export class ClientInfo {
        readonly handle: Frame;
        private _html_tag: JQuery;
        private _current_client: ClientEntry | undefined;
        private _online_time_updater: number;
        previous_frame_content: FrameContent;
        constructor(handle: Frame);
        html_tag(): JQuery;
        destroy();
        private _build_html_tag();
        current_client(): ClientEntry;
        set_current_client(client: ClientEntry | undefined, enforce?: boolean);
    }
    export enum FrameContent {
        NONE,
        PRIVATE_CHAT,
        CHANNEL_CHAT,
        CLIENT_INFO
    }
    export class Frame {
        readonly handle: ConnectionHandler;
        private _info_frame: InfoFrame;
        private _html_tag: JQuery;
        private _container_info: JQuery;
        private _container_chat: JQuery;
        private _content_type: FrameContent;
        private _conversations: PrivateConverations;
        private _client_info: ClientInfo;
        private _channel_conversations: channel.ConversationManager;
        constructor(handle: ConnectionHandler);
        html_tag(): JQuery;
        info_frame(): InfoFrame;
        content_type(): FrameContent;
        destroy();
        private _build_html_tag();
        private_conversations(): PrivateConverations;
        channel_conversations(): channel.ConversationManager;
        client_info(): ClientInfo;
        private _clear();
        show_private_conversations();
        show_channel_conversations();
        show_client_info(client: ClientEntry);
        set_content(type: FrameContent);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/frames/chat.ts */
declare enum ChatType {
    GENERAL,
    SERVER,
    CHANNEL,
    CLIENT
}
declare const xbbcode: any;
declare namespace MessageHelper {
    export function htmlEscape(message: string): string[];
    export function formatElement(object: any, escape_html?: boolean): JQuery[];
    export function formatMessage(pattern: string, ...objects: any[]): JQuery[];
    export function bbcode_chat(message: string): JQuery[];
    export namespace network {
        export const KB;
        export const MB;
        export const GB;
        export const TB;
        export function format_bytes(value: number, options?: {
            time?: string;
            unit?: string;
            exact?: boolean;
        }): string;
    }
    export const K;
    export const M;
    export const G;
    export const T;
    export function format_number(value: number, options?: {
        time?: string;
        unit?: string;
    });
    export const TIME_SECOND;
    export const TIME_MINUTE;
    export const TIME_HOUR;
    export const TIME_DAY;
    export const TIME_WEEK;
    export function format_time(time: number, default_value: string);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/frames/connection_handlers.ts */
declare let server_connections: ServerConnectionManager;
declare class ServerConnectionManager {
    private connection_handlers: ConnectionHandler[];
    private active_handler: ConnectionHandler | undefined;
    private _container_log_server: JQuery;
    private _container_channel_tree: JQuery;
    private _container_hostbanner: JQuery;
    private _container_chat: JQuery;
    private _tag: JQuery;
    private _tag_connection_entries: JQuery;
    private _tag_buttons_scoll: JQuery;
    private _tag_button_scoll_right: JQuery;
    private _tag_button_scoll_left: JQuery;
    constructor(tag: JQuery);
    spawn_server_connection_handler(): ConnectionHandler;
    destroy_server_connection_handler(handler: ConnectionHandler);
    set_active_connection_handler(handler: ConnectionHandler);
    active_connection_handler(): ConnectionHandler | undefined;
    server_connection_handlers(): ConnectionHandler[];
    update_ui();
    private _update_scroll();
    private _button_scroll_right_clicked();
    private _button_scroll_left_clicked();
    private _update_scroll_buttons();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/frames/ControlBar.ts */
declare let control_bar: ControlBar;
declare type MicrophoneState = "disabled" | "muted" | "enabled";
declare type HeadphoneState = "muted" | "enabled";
declare type AwayState = "away-global" | "away" | "online";
declare class ControlBar {
    private _button_away_active: AwayState;
    private _button_microphone: MicrophoneState;
    private _button_speakers: HeadphoneState;
    private _button_subscribe_all: boolean;
    private _button_query_visible: boolean;
    private connection_handler: ConnectionHandler | undefined;
    private _button_hostbanner: JQuery;
    htmlTag: JQuery;
    constructor(htmlTag: JQuery);
    initialize_connection_handler_state(handler?: ConnectionHandler);
    set_connection_handler(handler?: ConnectionHandler);
    apply_server_state();
    apply_server_hostbutton();
    apply_server_voice_state();
    current_connection_handler();
    initialise();
    // @ts-ignore
    set button_away_active(flag: AwayState);
    update_button_away();
    // @ts-ignore
    set button_microphone(state: MicrophoneState);
    // @ts-ignore
    set button_speaker(state: HeadphoneState);
    // @ts-ignore
    set button_subscribe_all(state: boolean);
    // @ts-ignore
    set button_query_visible(state: boolean);
    /* UI listener */
    private on_away_toggle();
    private on_away_enable();
    private on_away_disable();
    private on_away_set_message();
    private on_away_enable_global();
    private on_away_disable_global();
    private on_away_set_message_global();
    private on_toggle_microphone();
    private on_toggle_sound();
    private on_toggle_channel_subscribe();
    private on_toggle_query_view();
    private on_open_settings();
    private on_open_connect();
    private on_open_connect_new_tab();
    update_connection_state();
    private on_execute_disconnect();
    private on_token_use();
    private on_token_list();
    private on_open_permissions();
    private on_open_banslist();
    private on_bookmark_server_add();
    update_bookmark_status();
    update_bookmarks();
    private on_bookmark_manage();
    private on_open_query_create();
    private on_open_query_manage();
    private on_open_playlist_manage();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/frames/hostbanner.ts */
declare class Hostbanner {
    readonly html_tag: JQuery<HTMLElement>;
    readonly client: ConnectionHandler;
    private _destryed;
    private updater: NodeJS.Timer;
    constructor(client: ConnectionHandler);
    destroy();
    update();
    public static generate_tag(banner_url: string | undefined, gfx_interval: number, mode: number): Promise<JQuery | undefined>;
    private generate_tag?(): Promise<JQuery | undefined>;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/frames/MenuBar.ts */
declare namespace top_menu {
    export interface HRItem {
    }
    export interface MenuItem {
        append_item(label: string): MenuItem;
        append_hr(): HRItem;
        delete_item(item: MenuItem | HRItem);
        items(): (MenuItem | HRItem)[];
        icon(klass?: string | Promise<Icon> | Icon): string;
        label(value?: string): string;
        visible(value?: boolean): boolean;
        disabled(value?: boolean): boolean;
        click(callback: () => any): this;
    }
    export interface MenuBarDriver {
        initialize();
        append_item(label: string): MenuItem;
        delete_item(item: MenuItem);
        items(): MenuItem[];
        flush_changes();
    }
    export function driver(): MenuBarDriver;
    export function set_driver(driver: MenuBarDriver);
    export interface NativeActions {
        open_dev_tools();
        reload_page();
        check_native_update();
        open_change_log();
        quit();
    }
    export let native_actions: NativeActions;
    namespace html {
        export class HTMLHrItem implements top_menu.HRItem {
            readonly html_tag: JQuery;
            constructor();
        }
        export class HTMLMenuItem implements top_menu.MenuItem {
            readonly html_tag: JQuery;
            readonly _label_tag: JQuery;
            readonly _label_icon_tag: JQuery;
            readonly _label_text_tag: JQuery;
            readonly _submenu_tag: JQuery;
            private _items: (MenuItem | HRItem)[];
            private _label: string;
            private _callback_click: () => any;
            constructor(label: string, mode: "side" | "down");
            append_item(label: string): top_menu.MenuItem;
            append_hr(): HRItem;
            delete_item(item: top_menu.MenuItem | top_menu.HRItem);
            disabled(value?: boolean): boolean;
            items(): (top_menu.MenuItem | top_menu.HRItem)[];
            label(value?: string): string;
            visible(value?: boolean): boolean;
            click(callback: () => any): this;
            icon(klass?: string | Promise<Icon> | Icon): string;
        }
        export class HTMLMenuBarDriver implements MenuBarDriver {
            private static _instance: HTMLMenuBarDriver;
            public static instance(): HTMLMenuBarDriver;
            readonly html_tag: JQuery;
            private _items: MenuItem[];
            constructor();
            append_item(label: string): top_menu.MenuItem;
            delete_item(item: MenuItem);
            items(): top_menu.MenuItem[];
            flush_changes();
            initialize();
        }
    }
    export function rebuild_bookmarks();
    export function update_state();
    namespace native {
        export function initialize();
    }
    export function initialize();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/frames/server_log.ts */
declare namespace log {
    export namespace server {
        export enum Type {
            CONNECTION_BEGIN = "connection_begin",
            CONNECTION_HOSTNAME_RESOLVE = "connection_hostname_resolve",
            CONNECTION_HOSTNAME_RESOLVE_ERROR = "connection_hostname_resolve_error",
            CONNECTION_HOSTNAME_RESOLVED = "connection_hostname_resolved",
            CONNECTION_LOGIN = "connection_login",
            CONNECTION_CONNECTED = "connection_connected",
            CONNECTION_FAILED = "connection_failed",
            CONNECTION_VOICE_SETUP_FAILED = "connection_voice_setup_failed",
            CONNECTION_COMMAND_ERROR = "connection_command_error",
            GLOBAL_MESSAGE = "global_message",
            SERVER_WELCOME_MESSAGE = "server_welcome_message",
            SERVER_HOST_MESSAGE = "server_host_message",
            SERVER_HOST_MESSAGE_DISCONNECT = "server_host_message_disconnect",
            SERVER_CLOSED = "server_closed",
            SERVER_BANNED = "server_banned",
            SERVER_REQUIRES_PASSWORD = "server_requires_password",
            CLIENT_VIEW_ENTER = "client_view_enter",
            CLIENT_VIEW_LEAVE = "client_view_leave",
            CLIENT_VIEW_MOVE = "client_view_move",
            CLIENT_NICKNAME_CHANGED = "client_nickname_changed",
            CLIENT_NICKNAME_CHANGE_FAILED = "client_nickname_change_failed",
            CLIENT_SERVER_GROUP_ADD = "client_server_group_add",
            CLIENT_SERVER_GROUP_REMOVE = "client_server_group_remove",
            CLIENT_CHANNEL_GROUP_CHANGE = "client_channel_group_change",
            CHANNEL_CREATE = "channel_create",
            CHANNEL_DELETE = "channel_delete",
            ERROR_CUSTOM = "error_custom",
            ERROR_PERMISSION = "error_permission",
            RECONNECT_SCHEDULED = "reconnect_scheduled",
            RECONNECT_EXECUTE = "reconnect_execute",
            RECONNECT_CANCELED = "reconnect_canceled"
        }
        export namespace base {
            export type Client = {
                client_unique_id: string;
                client_name: string;
                client_id: number;
            };
            export type Channel = {
                channel_id: number;
                channel_name: string;
            };
            export type Server = {
                server_name: string;
                server_unique_id: string;
            };
            export type ServerAddress = {
                server_hostname: string;
                server_port: number;
            };
        }
        export namespace event {
            export type GlobalMessage = {
                sender: base.Client;
                message: string;
            };
            export type ConnectBegin = {
                address: base.ServerAddress;
                client_nickname: string;
            };
            export type ErrorCustom = {
                message: string;
            };
            export type ReconnectScheduled = {
                timeout: number;
            };
            export type ReconnectCanceled = {};
            export type ReconnectExecute = {};
            export type ErrorPermission = {
                permission: PermissionInfo;
            };
            export type WelcomeMessage = {
                message: string;
            };
            export type HostMessageDisconnect = {
                message: string;
            };
            //tr("You was moved by {3} from channel {1} to {2}") : tr("{0} was moved from channel {1} to {2} by {3}")
            //tr("You switched from channel {1} to {2}") : tr("{0} switched from channel {1} to {2}")
            //tr("You got kicked out of the channel {1} to channel {2} by {3}{4}") : tr("{0} got kicked from channel {1} to {2} by {3}{4}")
            export type ClientMove = {
                channel_from?: base.Channel;
                channel_from_own: boolean;
                channel_to?: base.Channel;
                channel_to_own: boolean;
                client: base.Client;
                client_own: boolean;
                invoker?: base.Client;
                message?: string;
                reason: ViewReasonId;
            };
            export type ClientEnter = {
                channel_from?: base.Channel;
                channel_to?: base.Channel;
                client: base.Client;
                invoker?: base.Client;
                message?: string;
                own_channel: boolean;
                reason: ViewReasonId;
                ban_time?: number;
            };
            export type ClientLeave = {
                channel_from?: base.Channel;
                channel_to?: base.Channel;
                client: base.Client;
                invoker?: base.Client;
                message?: string;
                own_channel: boolean;
                reason: ViewReasonId;
                ban_time?: number;
            };
            export type ChannelCreate = {
                creator: base.Client;
                channel: base.Channel;
                own_action: boolean;
            };
            export type ChannelDelete = {
                deleter: base.Client;
                channel: base.Channel;
                own_action: boolean;
            };
            export type ConnectionConnected = {
                own_client: base.Client;
            };
            export type ConnectionFailed = {};
            export type ConnectionLogin = {};
            export type ConnectionHostnameResolve = {};
            export type ConnectionHostnameResolved = {
                address: base.ServerAddress;
            };
            export type ConnectionHostnameResolveError = {
                message: string;
            };
            export type ConnectionVoiceSetupFailed = {
                reason: string;
                reconnect_delay: number; /* if less or equal to 0 reconnect is prohibited */
            };
            export type ConnectionCommandError = {
                error: any;
            };
            export type ClientNicknameChanged = {
                own_client: boolean;
                client: base.Client;
                old_name: string;
                new_name: string;
            };
            export type ClientNicknameChangeFailed = {
                reason: string;
            };
            export type ServerClosed = {
                message: string;
            };
            export type ServerRequiresPassword = {};
            export type ServerBanned = {
                message: string;
                time: number;
                invoker: base.Client;
            };
        }
        export type LogMessage = {
            type: Type;
            timestamp: number;
            data: any;
        };
        export interface TypeInfo {
            "connection_begin": event.ConnectBegin;
            "global_message": event.GlobalMessage;
            "error_custom": event.ErrorCustom;
            "error_permission": event.ErrorPermission;
            "connection_hostname_resolved": event.ConnectionHostnameResolved;
            "connection_hostname_resolve": event.ConnectionHostnameResolve;
            "connection_hostname_resolve_error": event.ConnectionHostnameResolveError;
            "connection_failed": event.ConnectionFailed;
            "connection_login": event.ConnectionLogin;
            "connection_connected": event.ConnectionConnected;
            "connection_voice_setup_failed": event.ConnectionVoiceSetupFailed;
            "connection_command_error": event.ConnectionCommandError;
            "reconnect_scheduled": event.ReconnectScheduled;
            "reconnect_canceled": event.ReconnectCanceled;
            "reconnect_execute": event.ReconnectExecute;
            "server_welcome_message": event.WelcomeMessage;
            "server_host_message": event.WelcomeMessage;
            "server_host_message_disconnect": event.HostMessageDisconnect;
            "server_closed": event.ServerClosed;
            "server_requires_password": event.ServerRequiresPassword;
            "server_banned": event.ServerBanned;
            "client_view_enter": event.ClientEnter;
            "client_view_move": event.ClientMove;
            "client_view_leave": event.ClientLeave;
            "client_nickname_change_failed": event.ClientNicknameChangeFailed;
            "client_nickname_changed": event.ClientNicknameChanged;
            "channel_create": event.ChannelCreate;
            "channel_delete": event.ChannelDelete;
        }
        export type MessageBuilderOptions = {};
        export type MessageBuilder<T extends keyof server.TypeInfo> = (data: TypeInfo[T], options: MessageBuilderOptions) => JQuery[] | undefined;
        export const MessageBuilders: {
            [key: string]: MessageBuilder<any>;
        };
    }
    export class ServerLog {
        private readonly handle: ConnectionHandler;
        private history_length: number;
        private _log: server.LogMessage[];
        private _html_tag: JQuery;
        private _log_container: JQuery;
        private auto_follow: boolean;
        private _ignore_event: number;
        constructor(handle: ConnectionHandler);
        log<T extends keyof server.TypeInfo>(type: T, data: server.TypeInfo[T]);
        html_tag(): JQuery;
        destroy();
        private append_log(message: server.LogMessage);
    }
}
declare namespace log {
    export namespace server {
        namespace impl { }
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/htmltags.ts */
declare namespace htmltags {
    export interface ClientProperties {
        client_id: number;
        client_unique_id: string;
        client_name: string;
        add_braces?: boolean;
    }
    export interface ChannelProperties {
        channel_id: number;
        channel_name: string;
        channel_display_name?: string;
        add_braces?: boolean;
    }
    export function generate_client(properties: ClientProperties): string;
    export function generate_client_object(properties: ClientProperties): JQuery;
    export function generate_channel(properties: ChannelProperties): string;
    export function generate_channel_object(properties: ChannelProperties): JQuery;
    export namespace callbacks {
        export function callback_context_client(element: JQuery);
        export function callback_context_channel(element: JQuery);
    }
    namespace bbcodes { }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalAbout.ts */
declare namespace Modals {
    export function spawnAbout();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalAvatar.ts */
declare namespace Modals {
    //TODO: Test if we could render this image and not only the browser by knowing the type.
    export function spawnAvatarUpload(callback_data: (data: ArrayBuffer | undefined | null) => any);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalAvatarList.ts */
declare namespace Modals {
    export const human_file_size;
    export function spawnAvatarList(client: ConnectionHandler);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalBanClient.ts */
declare namespace Modals {
    export function spawnBanClient(name: string | string[], callback: (data: {
        length: number;
        reason: string;
        no_name: boolean;
        no_ip: boolean;
        no_hwid: boolean;
    }) => void);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalBanCreate.ts */
declare namespace Modals {
    export function spawnBanCreate(connection: ConnectionHandler, base?: BanEntry, callback?: (entry?: BanEntry) => any);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalBanList.ts */
declare namespace Modals {
    export interface BanEntry {
        server_id: number;
        banid: number;
        name?: string;
        name_type?: number;
        unique_id?: string;
        ip?: string;
        hardware_id?: string;
        reason: string;
        invoker_name: string;
        invoker_unique_id?: string;
        invoker_database_id?: number;
        timestamp_created: Date;
        timestamp_expire: Date;
        enforcements: number;
        flag_own?: boolean;
    }
    export interface BanListManager {
        addbans: (ban: BanEntry[]) => void;
        clear: (ban?: any) => void;
        modal: Modal;
    }
    export function openBanList(client: ConnectionHandler);
    export function spawnBanListModal(callback_update: () => any, callback_add: () => any, callback_edit: (entry: BanEntry) => any, callback_delete: (entry: BanEntry) => any): BanListManager;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalBookmarks.ts */
declare namespace Modals {
    export function spawnBookmarkModal();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalBotMenue.ts */

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalChangeVolume.ts */
declare namespace Modals {
    export function spawnChangeVolume(current: number, callback: (number) => void);
    /* Units are between 0 and 1 */
    export function spawnChangeRemoteVolume(current: number, max_value: number, callback: (value: number) => void);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalClientInfo.ts */
declare namespace Modals {
    export function openClientInfo(client: ClientEntry);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalConnect.ts */
declare namespace connection_log {
    //TODO: Save password data
    export type ConnectionData = {
        name: string;
        icon_id: number;
        country: string;
        clients_online: number;
        clients_total: number;
        flag_password: boolean;
        password_hash: string;
    };
    export type ConnectionEntry = ConnectionData & {
        address: {
            hostname: string;
            port: number;
        };
        total_connection: number;
        first_timestamp: number;
        last_timestamp: number;
    };
    export function log_connect(address: {
        hostname: string;
        port: number;
    });
    export function update_address_info(address: {
        hostname: string;
        port: number;
    }, data: ConnectionData);
    export function update_address_password(address: {
        hostname: string;
        port: number;
    }, password_hash: string);
    export function history(): ConnectionEntry[];
    export function delete_entry(address: {
        hostname: string;
        port: number;
    });
}
declare namespace Modals {
    export function spawnConnectModal(options: {
        default_connect_new_tab?: boolean; /* default false */
    }, defaultHost?: {
        url: string;
        enforce: boolean;
    }, connect_profile?: {
        profile: profiles.ConnectionProfile;
        enforce: boolean;
    });
    export const Regex;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalCreateChannel.ts */
declare namespace Modals {
    export function createChannelModal(connection: ConnectionHandler, channel: ChannelEntry | undefined, parent: ChannelEntry | undefined, permissions: PermissionManager, callback: (properties?: ChannelProperties, permissions?: PermissionValue[]) => any);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalGroupAssignment.ts */
declare namespace Modals {
    export function createServerGroupAssignmentModal(client: ClientEntry, callback: (group: Group, flag: boolean) => Promise<boolean>);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalIconSelect.ts */
declare namespace Modals {
    export function spawnIconSelect(client: ConnectionHandler, callback_icon?: (id: number) => any, selected_icon?: number);
    export function spawnIconUpload(client: ConnectionHandler);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalIdentity.ts */
declare namespace Modals {
    export function spawnTeamSpeakIdentityImprove(identity: profiles.identities.TeaSpeakIdentity, name: string): Modal;
    export function spawnTeamSpeakIdentityImport(callback: (identity: profiles.identities.TeaSpeakIdentity) => any): Modal;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalInvite.ts */
declare namespace Modals {
    export function spawnInviteEditor(connection: ConnectionHandler);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalKeySelect.ts */
declare namespace Modals {
    export function spawnKeySelect(callback: (key?: ppt.KeyEvent) => void);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalPlaylistEdit.ts */
declare namespace Modals {
    export function spawnPlaylistSongInfo(song: PlaylistSong);
    export function spawnSongAdd(playlist: Playlist, callback_add: (url: string, loader: string) => any);
    export function spawnPlaylistEdit(client: ConnectionHandler, playlist: Playlist);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalPlaylistList.ts */
declare namespace Modals {
    export function spawnPlaylistManage(client: ConnectionHandler);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalPoke.ts */
declare namespace Modals {
    export class PokeModal {
        private _handle: Modal;
        private source_map: ServerEntry[];
        constructor();
        modal();
        add_poke(source: ConnectionHandler, invoker: PokeInvoker, message: string);
        private _handle_close();
    }
    export type PokeInvoker = {
        name: string;
        id: number;
        unique_id: string;
    };
    export function spawnPoke(source: ConnectionHandler, invoker: PokeInvoker, message: string);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalQuery.ts */
declare namespace Modals {
    export function spawnQueryCreate(connection: ConnectionHandler, callback_created?: (user, pass) => any);
    export function spawnQueryCreated(credentials: {
        username: string;
        password: string;
    }, just_created: boolean);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalQueryManage.ts */
declare namespace Modals {
    export function spawnQueryManage(client: ConnectionHandler);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalServerEdit.ts */
declare namespace Modals {
    export function createServerModal(server: ServerEntry, callback: (properties?: ServerProperties) => Promise<void>);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalServerInfo.ts */
declare namespace Modals {
    export function openServerInfo(server: ServerEntry);
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalSettings.ts */
declare namespace Modals {
    export function spawnSettingsModal(default_page?: string): Modal;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/ModalYesNo.ts */
declare namespace Modals {
    export function spawnYesNo(header: BodyCreator, body: BodyCreator, callback: (_: boolean) => any, properties?: {
        text_yes?: string;
        text_no?: string;
    });
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/permission/CanvasPermissionEditor.ts */
declare namespace pe {
    namespace ui {
        export namespace scheme {
            export interface CheckBox {
                border: string;
                checkmark: string;
                checkmark_font: string;
                background_checked: string;
                background_checked_hovered: string;
                background: string;
                background_hovered: string;
            }
            export interface TextField {
                color: string;
                font: string;
                background: string;
                background_hovered: string;
            }
            export interface ColorScheme {
                permission: {
                    background: string;
                    background_selected: string;
                    name: string;
                    name_unset: string;
                    name_font: string;
                    value: TextField;
                    value_b: CheckBox;
                    granted: TextField;
                    negate: CheckBox;
                    skip: CheckBox;
                };
                group: {
                    name: string;
                    name_font: string;
                };
            }
        }
        export enum RepaintMode {
            NONE,
            REPAINT,
            REPAINT_OBJECT_FULL,
            REPAINT_FULL
        }
        export interface AxisAlignedBoundingBox {
            x: number;
            y: number;
            width: number;
            height: number;
        }
        export enum ClickEventType {
            SIGNLE,
            DOUBLE,
            CONTEXT_MENU
        }
        export interface InteractionClickEvent {
            type: ClickEventType;
            consumed: boolean;
            offset_x: number;
            offset_y: number;
        }
        export interface InteractionListener {
            region: AxisAlignedBoundingBox;
            region_weight: number;
            /**
             * @return true if a redraw is required
             */
            on_mouse_enter?: () => RepaintMode;
            /**
             * @return true if a redraw is required
             */
            on_mouse_leave?: () => RepaintMode;
            /**
             * @return true if a redraw is required
             */
            on_click?: (event: InteractionClickEvent) => RepaintMode;
            mouse_cursor?: string;
            set_full_draw?: () => any;
            disabled?: boolean;
        }
        export abstract class DrawableObject {
            abstract draw(context: CanvasRenderingContext2D, full: boolean);
            private _object_full_draw;
            private _width: number;
            set_width(value: number);
            request_full_draw();
            pop_full_draw();
            width();
            abstract height();
            private _transforms: DOMMatrix[];
            protected push_transform(context: CanvasRenderingContext2D);
            protected pop_transform(context: CanvasRenderingContext2D);
            protected original_x(context: CanvasRenderingContext2D, x: number);
            protected original_y(context: CanvasRenderingContext2D, y: number);
            protected colors: scheme.ColorScheme;
            set_color_scheme(scheme: scheme.ColorScheme);
            protected manager: PermissionEditor;
            set_manager(manager: PermissionEditor);
            abstract initialize();
            abstract finalize();
        }
        export class PermissionGroup extends DrawableObject {
            public static readonly HEIGHT;
            public static readonly ARROW_SIZE;
            group: GroupedPermissions;
            _sub_elements: PermissionGroup[];
            _element_permissions: PermissionList;
            collapsed;
            private _listener_colaps: InteractionListener;
            constructor(group: GroupedPermissions);
            draw(context: CanvasRenderingContext2D, full: boolean);
            set_width(value: number);
            set_color_scheme(scheme: scheme.ColorScheme);
            set_manager(manager: PermissionEditor);
            height();
            initialize();
            finalize();
            collapse_group();
            expend_group();
        }
        export class PermissionList extends DrawableObject {
            permissions: PermissionEntry[];
            constructor(permissions: PermissionInfo[]);
            set_width(value: number);
            draw(context: CanvasRenderingContext2D, full: boolean);
            height();
            set_color_scheme(scheme: scheme.ColorScheme);
            set_manager(manager: PermissionEditor);
            initialize();
            finalize();
            handle_hide();
        }
        export class PermissionEntry extends DrawableObject {
            public static readonly HEIGHT;
            public static readonly HALF_HEIGHT;
            public static readonly CHECKBOX_HEIGHT;
            public static readonly COLUMN_PADDING;
            public static readonly COLUMN_VALUE;
            public static readonly COLUMN_GRANTED;
            //public static readonly COLUMN_NEGATE = 25;
            //public static readonly COLUMN_SKIP = 25;
            public static readonly COLUMN_NEGATE;
            public static readonly COLUMN_SKIP;
            private _permission: PermissionInfo;
            hidden: boolean;
            granted: number;
            value: number;
            flag_skip: boolean;
            flag_negate: boolean;
            private _prev_selected;
            selected: boolean;
            flag_skip_hovered;
            flag_negate_hovered;
            flag_value_hovered;
            flag_grant_hovered;
            private _listener_checkbox_skip: InteractionListener;
            private _listener_checkbox_negate: InteractionListener;
            private _listener_value: InteractionListener;
            private _listener_grant: InteractionListener;
            private _listener_general: InteractionListener;
            private _icon_image: HTMLImageElement | undefined;
            on_icon_select?: (current_id: number) => Promise<number>;
            on_context_menu?: (x: number, y: number) => any;
            on_grant_change?: () => any;
            on_change?: () => any;
            constructor(permission: PermissionInfo);
            set_icon_id_image(image: HTMLImageElement | undefined);
            permission();
            draw(ctx: CanvasRenderingContext2D, full: boolean);
            handle_hide();
            private _draw_icon_field(ctx: CanvasRenderingContext2D, scheme: scheme.CheckBox, x: number, y: number, width: number, hovered: boolean, image: HTMLImageElement);
            private _draw_number_field(ctx: CanvasRenderingContext2D, scheme: scheme.TextField, x: number, y: number, width: number, value: number, hovered: boolean);
            private _draw_checkbox_field(ctx: CanvasRenderingContext2D, scheme: scheme.CheckBox, x: number, y: number, height: number, checked: boolean, hovered: boolean);
            height();
            set_width(value: number);
            initialize();
            finalize();
            private _spawn_number_edit(x: number, y: number, width: number, height: number, color: scheme.TextField, value: number, callback: (new_value?: number) => any);
            trigger_value_assign();
            trigger_grant_assign();
        }
        export class InteractionManager {
            private _listeners: InteractionListener[];
            private _entered_listeners: InteractionListener[];
            register_listener(listener: InteractionListener);
            remove_listener(listener: InteractionListener);
            process_mouse_move(new_x: number, new_y: number): {
                repaint: RepaintMode;
                cursor: string;
            };
            private process_click_event(x: number, y: number, event: InteractionClickEvent): RepaintMode;
            process_click(x: number, y: number): RepaintMode;
            process_dblclick(x: number, y: number): RepaintMode;
            process_context_menu(js_event: MouseEvent, x: number, y: number): RepaintMode;
        }
        export class PermissionEditor {
            private static readonly PERMISSION_HEIGHT;
            private static readonly PERMISSION_GROUP_HEIGHT;
            readonly grouped_permissions: GroupedPermissions[];
            readonly canvas: HTMLCanvasElement;
            readonly canvas_container: HTMLDivElement;
            private _max_height: number;
            private _permission_count: number;
            private _permission_group_count: number;
            private _canvas_context: CanvasRenderingContext2D;
            private _selected_entry: PermissionEntry;
            private _draw_requested: boolean;
            private _draw_requested_full: boolean;
            private _elements: PermissionGroup[];
            private _intersect_manager: InteractionManager;
            private _permission_entry_map: {
                [key: number]: PermissionEntry;
            };
            mouse: {
                x: number;
                y: number;
            };
            constructor(permissions: GroupedPermissions[]);
            private _handle_repaint(mode: RepaintMode);
            request_draw(full?: boolean);
            draw(full?: boolean);
            private initialize();
            intercept_manager();
            set_selected_entry(entry?: PermissionEntry);
            permission_entries(): PermissionEntry[];
            collapse_all();
            expend_all();
        }
    }
    export class CanvasPermissionEditor extends Modals.AbstractPermissionEditor {
        private container: JQuery;
        private mode_container_permissions: JQuery;
        private mode_container_error_permission: JQuery;
        private mode_container_unset: JQuery;
        /* references within the container tag */
        private permission_value_map: {
            [key: number]: PermissionValue;
        };
        private entry_editor: ui.PermissionEditor;
        icon_resolver: (id: number) => Promise<HTMLImageElement>;
        icon_selector: (current_id: number) => Promise<number>;
        constructor();
        initialize(permissions: GroupedPermissions[]);
        html_tag();
        private build_tag();
        set_permissions(permissions?: PermissionValue[]);
        set_mode(mode: Modals.PermissionEditorMode);
        update_ui();
        set_toggle_button(callback: () => string, initial: string);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/permission/HTMLPermissionEditor.ts */
declare namespace pe {
    export class HTMLPermission {
        readonly handle: HTMLPermissionEditor;
        readonly group: HTMLPermissionGroup;
        readonly permission: PermissionInfo;
        readonly index: number;
        tag: JQuery;
        tag_name: JQuery;
        tag_container_value: JQuery;
        tag_container_granted: JQuery;
        tag_container_skip: JQuery;
        tag_container_negate: JQuery;
        hidden: boolean;
        /* the "actual" values */
        private _mask;
        private _tag_value: JQuery;
        private _tag_value_input: JQuery;
        private _tag_granted: JQuery;
        private _tag_granted_input: JQuery;
        private _tag_skip: JQuery;
        private _tag_skip_input: JQuery;
        private _tag_negate: JQuery;
        private _tag_negate_input: JQuery;
        private _value: number | undefined;
        private _grant: number | undefined;
        private flags: number;
        constructor(handle: HTMLPermissionEditor, group: HTMLPermissionGroup, permission: PermissionInfo, index: number);
        private static build_checkbox(): {
            tag: JQuery;
            input: JQuery;
        };
        private static number_filter_re;
        private static number_filter;
        private build_tag();
        private _trigger_value_assign();
        private _trigger_grant_assign();
        hide();
        show();
        is_filtered(): boolean;
        set_filtered(flag: boolean);
        is_set(): boolean;
        value(value: number | undefined, skip?: boolean, negate?: boolean);
        granted(value: number | undefined);
        reset();
        private _reset_value();
        private _reset_grant();
        private _update_active_class();
    }
    export class HTMLPermissionGroup {
        readonly handle: HTMLPermissionEditor;
        readonly group: PermissionGroup;
        readonly index: number;
        private _tag_arrow: JQuery;
        permissions: HTMLPermission[];
        children: HTMLPermissionGroup[];
        tag: JQuery;
        visible: boolean;
        collapsed: boolean;
        parent_collapsed: boolean;
        constructor(handle: HTMLPermissionEditor, group: PermissionGroup, index: number);
        private _build_tag();
        update_visibility();
        collapse();
        expend();
    }
    export class HTMLPermissionEditor extends Modals.AbstractPermissionEditor {
        container: JQuery;
        private mode_container_permissions: JQuery;
        private mode_container_error_permission: JQuery;
        private mode_container_unset: JQuery;
        private filter_input: JQuery;
        private filter_grant: JQuery;
        private button_toggle: JQuery;
        private even_list: ({
            visible(): boolean;
            set_even(flag: boolean);
        })[];
        private permission_map: Array<HTMLPermission>;
        private permission_groups: HTMLPermissionGroup[];
        constructor();
        initialize(permissions: GroupedPermissions[]);
        private update_filter();
        private build_tag();
        html_tag(): JQuery<HTMLElement>;
        set_permissions(u_permissions?: PermissionValue[]);
        set_mode(mode: Modals.PermissionEditorMode);
        trigger_change(permission: PermissionInfo, value?: Modals.PermissionEditor.PermissionValue): Promise<void>;
        collapse_all();
        expend_all();
        update_view();
        set_toggle_button(callback: () => string, initial: string);
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/modal/permission/ModalPermissionEdit.ts */
declare interface JQuery<TElement = HTMLElement> {
    dropdown: any;
}
declare namespace Modals {
    export namespace PermissionEditor {
        export interface PermissionEntry {
            tag: JQuery;
            tag_value: JQuery;
            tag_grant: JQuery;
            tag_flag_negate: JQuery;
            tag_flag_skip: JQuery;
            id: number;
            filter: string;
            is_bool: boolean;
        }
        export interface PermissionValue {
            remove: boolean;
            granted?: number;
            value?: number;
            flag_skip?: boolean;
            flag_negate?: boolean;
        }
        export type change_listener_t = (permission: PermissionInfo, value?: PermissionEditor.PermissionValue) => Promise<void>;
    }
    export enum PermissionEditorMode {
        VISIBLE,
        NO_PERMISSION,
        UNSET
    }
    export abstract class AbstractPermissionEditor {
        protected _permissions: GroupedPermissions[];
        protected _listener_update: () => any;
        protected _listener_change: PermissionEditor.change_listener_t;
        protected _toggle_callback: () => string;
        icon_resolver: (id: number) => Promise<HTMLImageElement>;
        icon_selector: (current_id: number) => Promise<number>;
        protected constructor();
        abstract set_mode(mode: PermissionEditorMode);
        abstract initialize(permissions: GroupedPermissions[]);
        abstract html_tag(): JQuery;
        abstract set_permissions(permissions?: PermissionValue[]);
        set_listener(listener?: PermissionEditor.change_listener_t);
        set_listener_update(listener?: () => any);
        trigger_update();
        abstract set_toggle_button(callback: () => string, initial: string);
    }
    export type OptionsServerGroup = {};
    export type OptionsChannelGroup = {};
    export type OptionsClientPermissions = {
        unique_id?: string;
    };
    export type OptionsChannelPermissions = {
        channel_id?: number;
    };
    export type OptionsClientChannelPermissions = OptionsClientPermissions & OptionsChannelPermissions;
    export interface OptionMap {
        "sg": OptionsServerGroup;
        "cg": OptionsChannelGroup;
        "clp": OptionsClientPermissions;
        "chp": OptionsChannelPermissions;
        "clchp": OptionsClientChannelPermissions;
    }
    export function _space();
    export function spawnPermissionEdit<T extends keyof OptionMap>(connection: ConnectionHandler, selected_tab?: T, options?: OptionMap[T]): Modal;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/server.ts */
declare class ServerProperties {
    virtualserver_host: string;
    virtualserver_port: number;
    virtualserver_name: string;
    virtualserver_name_phonetic: string;
    virtualserver_icon_id: number;
    virtualserver_version: string;
    virtualserver_platform: string;
    virtualserver_unique_identifier: string;
    virtualserver_clientsonline: number;
    virtualserver_queryclientsonline: number;
    virtualserver_channelsonline: number;
    virtualserver_uptime: number;
    virtualserver_created: number;
    virtualserver_maxclients: number;
    virtualserver_reserved_slots: number;
    virtualserver_password: string;
    virtualserver_flag_password: boolean;
    virtualserver_ask_for_privilegekey: boolean;
    virtualserver_welcomemessage: string;
    virtualserver_hostmessage: string;
    virtualserver_hostmessage_mode: number;
    virtualserver_hostbanner_url: string;
    virtualserver_hostbanner_gfx_url: string;
    virtualserver_hostbanner_gfx_interval: number;
    virtualserver_hostbanner_mode: number;
    virtualserver_hostbutton_tooltip: string;
    virtualserver_hostbutton_url: string;
    virtualserver_hostbutton_gfx_url: string;
    virtualserver_codec_encryption_mode: number;
    virtualserver_default_music_group: number;
    virtualserver_default_server_group: number;
    virtualserver_default_channel_group: number;
    virtualserver_default_channel_admin_group: number;
    //Special requested properties
    virtualserver_default_client_description: string;
    virtualserver_default_channel_description: string;
    virtualserver_default_channel_topic: string;
    virtualserver_antiflood_points_tick_reduce: number;
    virtualserver_antiflood_points_needed_command_block: number;
    virtualserver_antiflood_points_needed_ip_block: number;
    virtualserver_country_code: string;
    virtualserver_complain_autoban_count: number;
    virtualserver_complain_autoban_time: number;
    virtualserver_complain_remove_time: number;
    virtualserver_needed_identity_security_level: number;
    virtualserver_weblist_enabled: boolean;
    virtualserver_min_clients_in_channel_before_forced_silence: number;
    virtualserver_channel_temp_delete_delay_default: number;
    virtualserver_priority_speaker_dimm_modificator: number;
    virtualserver_max_upload_total_bandwidth: number;
    virtualserver_upload_quota: number;
    virtualserver_max_download_total_bandwidth: number;
    virtualserver_download_quota: number;
    virtualserver_month_bytes_downloaded: number;
    virtualserver_month_bytes_uploaded: number;
    virtualserver_total_bytes_downloaded: number;
    virtualserver_total_bytes_uploaded: number;
}
declare interface ServerConnectionInfo {
    connection_filetransfer_bandwidth_sent: number;
    connection_filetransfer_bandwidth_received: number;
    connection_filetransfer_bytes_sent_total: number;
    connection_filetransfer_bytes_received_total: number;
    connection_filetransfer_bytes_sent_month: number;
    connection_filetransfer_bytes_received_month: number;
    connection_packets_sent_total: number;
    connection_bytes_sent_total: number;
    connection_packets_received_total: number;
    connection_bytes_received_total: number;
    connection_bandwidth_sent_last_second_total: number;
    connection_bandwidth_sent_last_minute_total: number;
    connection_bandwidth_received_last_second_total: number;
    connection_bandwidth_received_last_minute_total: number;
    connection_connected_time: number;
    connection_packetloss_total: number;
    connection_ping: number;
}
declare interface ServerAddress {
    host: string;
    port: number;
}
declare class ServerEntry {
    remote_address: ServerAddress;
    channelTree: ChannelTree;
    properties: ServerProperties;
    private info_request_promise: Promise<void>;
    private info_request_promise_resolve: any;
    private info_request_promise_reject: any;
    private _info_connection_promise: Promise<ServerConnectionInfo>;
    private _info_connection_promise_timestamp: number;
    private _info_connection_promise_resolve: any;
    private _info_connection_promise_reject: any;
    lastInfoRequest: number;
    nextInfoRequest: number;
    private _htmlTag: JQuery<HTMLElement>;
    private _destroyed;
    constructor(tree, name, address: ServerAddress);
    // @ts-ignore
    get htmlTag();
    destroy();
    initializeListener();
    spawnContextMenu(x: number, y: number, on_close?: () => void);
    updateVariables(is_self_notify: boolean, ...variables: {
        key: string;
        value: string;
    }[]);
    /* this result !must! be cached for at least a second */
    updateProperties(): Promise<void>;
    /* max 1s ago, so we could update every second */
    request_connection_info(): Promise<ServerConnectionInfo>;
    set_connection_info(info: ServerConnectionInfo);
    shouldUpdateProperties(): boolean;
    calculateUptime(): number;
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/view.ts */
declare class ChannelTree {
    client: ConnectionHandler;
    server: ServerEntry;
    channels: ChannelEntry[];
    clients: ClientEntry[];
    currently_selected: ClientEntry | ServerEntry | ChannelEntry | (ClientEntry | ServerEntry)[];
    currently_selected_context_callback: (event) => any;
    readonly client_mover: ClientMover;
    private _tag_container: JQuery;
    private _tag_entries: JQuery;
    private _tree_detached: boolean;
    private _show_queries: boolean;
    private channel_last?: ChannelEntry;
    private channel_first?: ChannelEntry;
    private _focused;
    private _listener_document_click;
    private _listener_document_key;
    constructor(client);
    tag_tree(): JQuery;
    destroy();
    hide_channel_tree();
    show_channel_tree();
    showContextMenu(x: number, y: number, on_close?: () => void);
    initialiseHead(serverName: string, address: ServerAddress);
    private __deleteAnimation(element: ChannelEntry | ClientEntry);
    rootChannel(): ChannelEntry[];
    deleteChannel(channel: ChannelEntry);
    insertChannel(channel: ChannelEntry);
    findChannel(channelId: number): ChannelEntry | undefined;
    find_channel_by_name(name: string, parent?: ChannelEntry, force_parent?: boolean): ChannelEntry | undefined;
    moveChannel(channel: ChannelEntry, channel_previous: ChannelEntry, parent: ChannelEntry);
    deleteClient(client: ClientEntry, animate_tag?: boolean);
    registerClient(client: ClientEntry);
    unregisterClient(client: ClientEntry);
    insertClient(client: ClientEntry, channel: ChannelEntry): ClientEntry;
    moveClient(client: ClientEntry, channel: ChannelEntry);
    findClient?(clientId: number): ClientEntry;
    find_client_by_dbid?(client_dbid: number): ClientEntry;
    find_client_by_unique_id?(unique_id: string): ClientEntry;
    private static same_selected_type(a, b);
    onSelect(entry?: ChannelEntry | ClientEntry | ServerEntry, enforce_single?: boolean, flag_shift?: boolean);
    private callback_multiselect_channel(event);
    private callback_multiselect_client(event);
    clientsByGroup(group: Group): ClientEntry[];
    clientsByChannel(channel: ChannelEntry): ClientEntry[];
    reset();
    spawnCreateChannel(parent?: ChannelEntry);
    handle_resized();
    private select_next_channel(channel: ChannelEntry, select_client: boolean);
    handle_key_press(event: KeyboardEvent);
    toggle_server_queries(flag: boolean);
    get_first_channel?(): ChannelEntry;
    unsubscribe_all_channels(subscribe_specified?: boolean);
    subscribe_all_channels();
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/utils/helpers.ts */
declare namespace helpers {
    export function hashPassword(password: string): Promise<string>;
}
declare class LaterPromise<T> extends Promise<T> {
    private _handle: Promise<T>;
    private _resolve: ($: T) => any;
    private _reject: ($: any) => any;
    private _time: number;
    constructor();
    resolved(object: T);
    rejected(reason);
    function_rejected();
    time();
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}
declare const copy_to_clipboard;

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/voice/RecorderBase.ts */
declare namespace audio {
    export namespace recorder {
        export interface InputDevice {
            unique_id: string;
            driver: string;
            name: string;
            default_input: boolean;
            supported: boolean;
            sample_rate: number;
            channels: number;
        }
        export enum InputConsumerType {
            CALLBACK,
            NODE,
            NATIVE
        }
        export interface InputConsumer {
            type: InputConsumerType;
        }
        export interface CallbackInputConsumer extends InputConsumer {
            callback_audio?: (buffer: AudioBuffer) => any;
            callback_buffer?: (buffer: Float32Array, samples: number, channels: number) => any;
        }
        export interface NodeInputConsumer extends InputConsumer {
            callback_node: (source_node: AudioNode) => any;
            callback_disconnect: (source_node: AudioNode) => any;
        }
        export namespace filter {
            export enum Type {
                THRESHOLD,
                VOICE_LEVEL,
                STATE
            }
            export interface Filter {
                type: Type;
                is_enabled(): boolean;
            }
            export interface MarginedFilter {
                get_margin_frames(): number;
                set_margin_frames(value: number);
            }
            export interface ThresholdFilter extends Filter, MarginedFilter {
                get_threshold(): number;
                set_threshold(value: number): Promise<void>;
                get_attack_smooth(): number;
                get_release_smooth(): number;
                set_attack_smooth(value: number);
                set_release_smooth(value: number);
                callback_level?: (value: number) => any;
            }
            export interface VoiceLevelFilter extends Filter, MarginedFilter {
                get_level(): number;
            }
            export interface StateFilter extends Filter {
                set_state(state: boolean): Promise<void>;
                is_active(): boolean; /* if true the the filter allows data to pass */
            }
        }
        export enum InputState {
            PAUSED,
            INITIALIZING,
            RECORDING,
            DRY
        }
        export enum InputStartResult {
            EOK = "eok",
            EUNKNOWN = "eunknown",
            EBUSY = "ebusy",
            ENOTALLOWED = "enotallowed",
            ENOTSUPPORTED = "enotsupported"
        }
        export interface AbstractInput {
            callback_begin: () => any;
            callback_end: () => any;
            current_state(): InputState;
            start(): Promise<InputStartResult>;
            stop(): Promise<void>;
            current_device(): InputDevice | undefined;
            set_device(device: InputDevice | undefined): Promise<void>;
            current_consumer(): InputConsumer | undefined;
            set_consumer(consumer: InputConsumer): Promise<void>;
            get_filter(type: filter.Type): filter.Filter | undefined;
            supports_filter(type: audio.recorder.filter.Type): boolean;
            clear_filter();
            disable_filter(type: filter.Type);
            enable_filter(type: filter.Type);
            get_volume(): number;
            set_volume(volume: number);
        }
        export interface LevelMeter {
            device(): InputDevice;
            set_observer(callback: (value: number) => any);
            destory();
        }
    }
}

/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/voice/RecorderProfile.ts */
declare type VadType = "threshold" | "push_to_talk" | "active";
declare interface RecorderProfileConfig {
    version: number;
    /* devices unique id */
    device_id: string | undefined;
    volume: number;
    vad_type: VadType;
    vad_threshold: {
        threshold: number;
    };
    vad_push_to_talk: {
        delay: number;
        key_code: string;
        key_ctrl: boolean;
        key_windows: boolean;
        key_shift: boolean;
        key_alt: boolean;
    };
}
declare let default_recorder: RecorderProfile /* needs initialize */;
declare class RecorderProfile {
    readonly name;
    readonly volatile;
    config: RecorderProfileConfig;
    input: audio.recorder.AbstractInput;
    current_handler: ConnectionHandler;
    callback_support_change: () => any;
    callback_start: () => any;
    callback_stop: () => any;
    callback_unmount: () => any;
    record_supported: boolean;
    private _ppt_hook: ppt.KeyHook;
    private _ppt_timeout: NodeJS.Timer;
    private _ppt_hook_registered: boolean;
    constructor(name: string, volatile?: boolean);
    initialize(): Promise<void>;
    private initialize_input();
    private load();
    private save(enforce?: boolean);
    private reinitialize_filter();
    unmount(): Promise<void>;
    get_vad_type();
    set_vad_type(type: VadType);
    get_vad_threshold();
    set_vad_threshold(value: number);
    get_vad_ppt_key(): ppt.KeyDescriptor;
    set_vad_ppt_key(key: ppt.KeyDescriptor);
    get_vad_ppt_delay();
    set_vad_ppt_delay(value: number);
    current_device(): audio.recorder.InputDevice | undefined;
    set_device(device: audio.recorder.InputDevice | undefined): Promise<void>;
    get_volume(): number;
    set_volume(volume: number);
}