/* 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; 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; } 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; 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; }; private _proxied_callbacks: { [key: string]: MethodProxyCallback; }; protected constructor(ipc_handler: BasicIPCHandler, connect_params?: MethodProxyConnectParameters); protected setup(); protected finalize(); protected register_method(method: (...args: any[]) => Promise | 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, 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; sendMessage(message: string, type: ChatType, target?: ChannelEntry | ClientEntry): Promise; updateClient(key: string, value: string): Promise; info_from_uid(..._unique_ids: string[]): Promise; private handle_notifyclientnamefromuid(json: any[]); request_query_list(server_id?: number): Promise; request_playlist_list(): Promise; request_playlist_songs(playlist_id: number): Promise; request_clients_by_server_group(group_id: number): Promise; request_playlist_info(playlist_id: number): Promise; /** * @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; } } /* 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; abstract connected(): boolean; abstract disconnect(reason?: string): Promise; 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; // @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; abstract voice_recorder(): RecorderProfile; abstract acquire_voice_recorder(recorder: RecorderProfile | undefined): Promise; } } 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; 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; } /* 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; } /* 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; } export type DownloadKey = TransferKey; export type UploadKey = TransferKey; export function spawn_download_transfer(key: DownloadKey): DownloadTransfer; export function spawn_upload_transfer(key: UploadKey): RequestFileUpload; } declare class RequestFileDownload implements transfer.DownloadTransfer { readonly transfer_key: transfer.DownloadKey; constructor(key: transfer.DownloadKey); request_file(): Promise; private try_fetch(url: string): Promise; get_key(): transfer.DownloadKey; } declare class RequestFileUpload { readonly transfer_key: transfer.UploadKey; constructor(key: transfer.DownloadKey); put_data(data: BlobPart | File); try_put(data: FormData, url: string): Promise; } 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; private notifyFileList(json); private notifyFileListFinished(json); /******************************** File download/upload ********************************/ download_file(path: string, file: string, channel?: ChannelEntry, password?: string): Promise; upload_file(options: transfer.UploadOptions): Promise; private notifyStartDownload(json); private notifyStartUpload(json); delete_file(props: { name: string; path?: string; cid?: number; cpw?: string; }): Promise; } 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; 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; }; constructor(handle: FileManager); destroy(); clear_cache(); delete_icon(id: number): Promise; iconList(): Promise; create_icon_download(id: number): Promise; private static _response_url(response: Response); resolved_cached?(id: number): Promise; private static _static_id_url: { [icon: number]: string; }; private static _static_cached_promise: { [icon: number]: Promise; }; static load_cached_icon(id: number, ignore_age?: boolean): Promise | Icon; private _load_icon(id: number): Promise; download_icon(id: number): Promise; resolve_icon(id: number): Promise; static generate_tag(icon: Promise | Icon, options?: { animate?: boolean; }): JQuery; generateTag(id: number, options?: { animate?: boolean; }): JQuery; } 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; }; constructor(handle: FileManager); destroy(); private _response_url(response: Response, type: ImageType): Promise; resolved_cached?(client_avatar_id: string, avatar_version?: string): Promise; create_avatar_download(client_avatar_id: string): Promise; 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; 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) => 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; export function load_repository(url: string): Promise; 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; export function select_translation(repository: TranslationRepository, entry: RepositoryTranslation); export function initialize(): Promise; } 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: ?log.i18n.enabled=0 //Level Example A: ?log.level.trace.enabled=0 //Level Example B: ?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; declare interface Window { open_connected_question: () => Promise; } declare function setup_close(); declare function moment(...arguments): any; declare function setup_jsrender(): boolean; declare function initialize(): Promise; declare function initialize_app(): Promise; 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; } 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; 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; } 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; private onClientPermList(json: any[]); requestClientPermissions(client_id: number): Promise; requestClientChannelPermissions(client_id: number, channel_id: number): Promise; private onPlaylistPermList(json: any[]); requestPlaylistPermissions(playlist_id: number): Promise; 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; 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; 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; 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; 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; 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; export function decrypt_ts_identity(buffer: Uint8Array): Promise; export function encrypt_ts_identity(buffer: Uint8Array): Promise; /** * @param buffer base64 encoded ASN.1 string */ export function decode_tomcrypt_key(buffer: string); } export class TeaSpeakHandshakeHandler extends AbstractHandshakeIdentityHandler { identity: TeaSpeakIdentity; handler: HandshakeCommandHandler; 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; current_hash(): string; current_level(): number; finalize(timeout?: number); private handle_message(message: any); } export class TeaSpeakIdentity implements Identity { static generate_new(): Promise; static import_ts(ts_string: string, ini?: boolean): Promise; 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; encode?(): string; level(): Promise; /** * @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; improve_level(target: number, threads: number, active_callback: () => boolean, callback_level?: (current: number) => any, callback_status?: (hash_rate: number) => any): Promise; private initialize(); export_ts(ini?: boolean): Promise; sign_message(message: string, hash?: string): Promise; 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; export function spawn(container: JQuery, key: string, callback_data: (token: string) => any): Promise; } 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; export function renew_data(): Promise<"success" | "login-required">; export function logout(): Promise; } /* 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; spawn_identity_handshake_handler(connection: connection.AbstractServerConnection): connection.HandshakeIdentityHandler; } export function decode_identity(type: IdentitifyType, data: string): Promise; export function create_identity(type: IdentitifyType); export class HandshakeCommandHandler 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 { remove(elem?: T): boolean; last?(): T; pop_front(): T | undefined; } declare interface JSON { map_to(object: T, json: any, variables?: string | string[], validator?: (map_field: string, map_value: string) => boolean, variable_direction?: number): T; map_field_to(object: T, value: any, field: string): T; } declare type JQueryScrollType = "height" | "width"; declare interface JQuery { render(values?: any): string; renderTag(values?: any): JQuery; hasScrollBar(direction?: JQueryScrollType): boolean; visible_height(): number; visible_width(): number; /* bootstrap */ alert(): JQuery; 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 { spawn(tagName: K): JQuery; 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 { 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?(input?: string, _default?: T, default_type?: string): T; protected static transformOtS?(input: T): string; protected static resolveKey(key: SettingsKey, _default: T, resolver: (key: string) => string | boolean, default_type?: string): T; protected static keyify(key: string | SettingsKey): SettingsKey; } 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?(key: string | SettingsKey, _default?: T, default_type?: string): T; deleteStatic(key: string | SettingsKey); } declare class Settings extends StaticSettings { static readonly KEY_DISABLE_COSMETIC_SLOWDOWN: SettingsKey; static readonly KEY_DISABLE_CONTEXT_MENU: SettingsKey; static readonly KEY_DISABLE_GLOBAL_CONTEXT_MENU: SettingsKey; static readonly KEY_DISABLE_UNLOAD_DIALOG: SettingsKey; static readonly KEY_DISABLE_VOICE: SettingsKey; static readonly KEY_DISABLE_MULTI_SESSION: SettingsKey; static readonly KEY_LOAD_DUMMY_ERROR: SettingsKey; /* Control bar */ static readonly KEY_CONTROL_MUTE_INPUT: SettingsKey; static readonly KEY_CONTROL_MUTE_OUTPUT: SettingsKey; static readonly KEY_CONTROL_SHOW_QUERIES: SettingsKey; static readonly KEY_CONTROL_CHANNEL_SUBSCRIBE_ALL: SettingsKey; /* Connect parameters */ static readonly KEY_FLAG_CONNECT_DEFAULT: SettingsKey; static readonly KEY_CONNECT_ADDRESS: SettingsKey; static readonly KEY_CONNECT_PROFILE: SettingsKey; static readonly KEY_CONNECT_USERNAME: SettingsKey; static readonly KEY_CONNECT_PASSWORD: SettingsKey; static readonly KEY_FLAG_CONNECT_PASSWORD: SettingsKey; static readonly KEY_CONNECT_HISTORY: SettingsKey; static readonly KEY_CERTIFICATE_CALLBACK: SettingsKey; /* sounds */ static readonly KEY_SOUND_MASTER: SettingsKey; static readonly KEY_SOUND_MASTER_SOUNDS: SettingsKey; static readonly KEY_CHAT_FIXED_TIMESTAMPS: SettingsKey; static readonly KEY_CHAT_COLLOQUIAL_TIMESTAMPS: SettingsKey; static readonly KEY_CHAT_COLORED_EMOJIES: SettingsKey; static readonly KEY_CHAT_TAG_URLS: SettingsKey; static readonly KEY_CHAT_ENABLE_MARKDOWN: SettingsKey; static readonly KEY_CHAT_ENABLE_BBCODE: SettingsKey; static readonly KEY_SWITCH_INSTANT_CHAT: SettingsKey; static readonly KEY_SWITCH_INSTANT_CLIENT: SettingsKey; static readonly KEY_HOSTBANNER_BACKGROUND: SettingsKey; static readonly KEY_CHANNEL_EDIT_ADVANCED: SettingsKey; static readonly KEY_TEAFORO_URL: SettingsKey; static readonly KEY_FONT_SIZE: SettingsKey; static readonly FN_SERVER_CHANNEL_SUBSCRIBE_MODE: (channel_id: number) => SettingsKey; static readonly FN_PROFILE_RECORD: (name: string) => SettingsKey; static readonly KEYS; static initialize(); private cacheGlobal; private saveWorker: NodeJS.Timer; private updated: boolean; constructor(); static_global?(key: string | SettingsKey, _default?: T): T; global?(key: string | SettingsKey, _default?: T): T; changeGlobal(key: string | SettingsKey, 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?(key: string | SettingsKey, _default?: T): T; changeServer(key: string | SettingsKey, 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; export interface PlaybackOptions { ignore_muted?: boolean; ignore_overlap?: boolean; default_volume?: number; callback?: (flag: boolean) => any; } export function resolve_sound(sound: Sound): Promise; 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; private _tag_siblings: JQuery; private _tag_clients: JQuery; private _tag_channel: JQuery; private _destroyed; private _cachedPassword: string; private _cached_channel_description: string; private _cached_channel_description_promise: Promise; 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; 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; channelTag(): JQuery; siblingTag(): JQuery; clientTag(): JQuery; 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; unsubscribe(inherited_subscription_mode?: boolean): Promise; // @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; 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; private _info_variables_promise_timestamp: number; private _info_connection_promise: Promise; 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; 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; 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; 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; 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; } /* File: /home/wolverindev/TeaSpeak/Web-Client/shared/js/ui/elements/context_divider.ts */ declare interface JQuery { 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 { 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/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 { asTabWidget(copy?: boolean): JQuery; tabify(copy?: boolean): this; changeElementType(type: string): JQuery; } 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; 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; export function save_history(key: string, value: any): Promise; } 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(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; 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; 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; private generate_tag?(): Promise; } /* 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): 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): 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 = (data: TypeInfo[T], options: MessageBuilderOptions) => JQuery[] | undefined; export const MessageBuilders: { [key: string]: MessageBuilder; }; } 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(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); } /* 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); } /* 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; 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; icon_selector: (current_id: number) => Promise; 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; private permission_groups: HTMLPermissionGroup[]; constructor(); initialize(permissions: GroupedPermissions[]); private update_filter(); private build_tag(); html_tag(): JQuery; set_permissions(u_permissions?: PermissionValue[]); set_mode(mode: Modals.PermissionEditorMode); trigger_change(permission: PermissionInfo, value?: Modals.PermissionEditor.PermissionValue): Promise; 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 { 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; } 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; icon_selector: (current_id: number) => Promise; 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(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; private info_request_promise_resolve: any; private info_request_promise_reject: any; private _info_connection_promise: Promise; 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; 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; /* max 1s ago, so we could update every second */ request_connection_info(): Promise; 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; } declare class LaterPromise extends Promise { private _handle: Promise; 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(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; /** * 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(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; } 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; 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; 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; stop(): Promise; current_device(): InputDevice | undefined; set_device(device: InputDevice | undefined): Promise; current_consumer(): InputConsumer | undefined; set_consumer(consumer: InputConsumer): Promise; 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; private initialize_input(); private load(); private save(enforce?: boolean); private reinitialize_filter(); unmount(): Promise; 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; get_volume(): number; set_volume(volume: number); }