signal-desktop/ts/window.d.ts

// Captures the globals put in place by preload.js, background.js and others

import * as Backbone from 'backbone';
import * as Underscore from 'underscore';
import { Ref } from 'react';
import {
  ConversationModelCollectionType,
  ConversationModelType,
  MessageModelCollectionType,
  MessageModelType,
} from './model-types.d';
import {
  LibSignalType,
  SignalProtocolAddressClass,
  StorageType,
} from './libsignal.d';
import { ContactRecordIdentityState, TextSecureType } from './textsecure.d';
import { WebAPIConnectType } from './textsecure/WebAPI';
import { CallingClass } from './services/calling';
import * as Crypto from './Crypto';
import * as RemoteConfig from './RemoteConfig';
import { LocalizerType } from './types/Util';
import { CallHistoryDetailsType } from './types/Calling';
import { ColorType } from './types/Colors';
import { ConversationController } from './ConversationController';
import { ReduxActions } from './state/types';
import { SendOptionsType } from './textsecure/SendMessage';
import AccountManager from './textsecure/AccountManager';
import Data from './sql/Client';

export { Long } from 'long';

type TaskResultType = any;

declare global {
  interface Window {
    dcodeIO: DCodeIOType;
    getAccountManager: () => AccountManager | undefined;
    getAlwaysRelayCalls: () => Promise<boolean>;
    getCallRingtoneNotification: () => Promise<boolean>;
    getCallSystemNotification: () => Promise<boolean>;
    getConversations: () => ConversationModelCollectionType;
    getCountMutedConversations: () => Promise<boolean>;
    getEnvironment: () => string;
    getExpiration: () => string;
    getGuid: () => string;
    getInboxCollection: () => ConversationModelCollectionType;
    getIncomingCallNotification: () => Promise<boolean>;
    getMediaCameraPermissions: () => Promise<boolean>;
    getMediaPermissions: () => Promise<boolean>;
    getServerPublicParams: () => string;
    getSocketStatus: () => number;
    getTitle: () => string;
    waitForEmptyEventQueue: () => Promise<void>;
    getVersion: () => string;
    showCallingPermissionsPopup: (forCamera: boolean) => Promise<void>;
    i18n: LocalizerType;
    isValidGuid: (maybeGuid: string) => boolean;
    libphonenumber: {
      util: {
        getRegionCodeForNumber: (number: string) => string;
      };
    };
    libsignal: LibSignalType;
    log: {
      info: LoggerType;
      warn: LoggerType;
      error: LoggerType;
    };
    normalizeUuids: (obj: any, paths: Array<string>, context: string) => any;
    platform: string;
    reduxActions: ReduxActions;
    restart: () => void;
    showWindow: () => void;
    setBadgeCount: (count: number) => void;
    storage: {
      put: (key: string, value: any) => void;
      remove: (key: string) => Promise<void>;
      get: <T = any>(key: string) => T | undefined;
      addBlockedNumber: (number: string) => void;
      isBlocked: (number: string) => boolean;
      removeBlockedNumber: (number: string) => void;
    };
    textsecure: TextSecureType;
    updateTrayIcon: (count: number) => void;

    Backbone: typeof Backbone;
    Signal: {
      Crypto: typeof Crypto;
      Data: typeof Data;
      Metadata: {
        SecretSessionCipher: typeof SecretSessionCipherClass;
        createCertificateValidator: (
          trustRoot: ArrayBuffer
        ) => CertificateValidatorType;
      };
      RemoteConfig: typeof RemoteConfig;
      Services: {
        calling: CallingClass;
      };
      Migrations: {
        deleteAttachmentData: (path: string) => Promise<void>;
        writeNewAttachmentData: (data: ArrayBuffer) => Promise<string>;
      };
      Types: {
        Message: {
          CURRENT_SCHEMA_VERSION: number;
        };
      };
    };
    ConversationController: ConversationController;
    MessageController: MessageControllerType;
    WebAPI: WebAPIConnectType;
    Whisper: WhisperType;

    // Flags
    CALLING: boolean;
    GV2: boolean;
  }

  interface Error {
    cause?: Event;
  }
}

export type DCodeIOType = {
  ByteBuffer: typeof ByteBufferClass & {
    BIG_ENDIAN: number;
    LITTLE_ENDIAN: number;
    Long: DCodeIOType['Long'];
  };
  Long: Long & {
    fromBits: (low: number, high: number, unsigned: boolean) => number;
    fromString: (str: string) => Long;
  };
};

type MessageControllerType = {
  register: (id: string, model: MessageModelType) => MessageModelType;
};

export class CertificateValidatorType {
  validate: (cerficate: any, certificateTime: number) => Promise<void>;
}

export class SecretSessionCipherClass {
  constructor(storage: StorageType);
  decrypt: (
    validator: CertificateValidatorType,
    ciphertext: ArrayBuffer,
    serverTimestamp: number,
    me: any
  ) => Promise<{
    isMe: boolean;
    sender: SignalProtocolAddressClass;
    senderUuid: SignalProtocolAddressClass;
    content: ArrayBuffer;
  }>;
  getRemoteRegistrationId: (
    address: SignalProtocolAddressClass
  ) => Promise<number>;
  closeOpenSessionForDevice: (
    address: SignalProtocolAddressClass
  ) => Promise<void>;
  encrypt: (
    address: SignalProtocolAddressClass,
    senderCertificate: any,
    plaintext: ArrayBuffer | Uint8Array
  ) => Promise<ArrayBuffer>;
}

export class ByteBufferClass {
  constructor(value?: any, littleEndian?: number);
  static wrap: (
    value: any,
    encoding?: string,
    littleEndian?: number
  ) => ByteBufferClass;
  buffer: ArrayBuffer;
  toString: (type: string) => string;
  toArrayBuffer: () => ArrayBuffer;
  toBinary: () => string;
  slice: (start: number, end?: number) => ByteBufferClass;
  append: (data: ArrayBuffer) => void;
  limit: number;
  offset: 0;
  readInt: (offset: number) => number;
  readLong: (offset: number) => Long;
  readShort: (offset: number) => number;
  readVarint32: () => number;
  writeLong: (l: Long) => void;
  skip: (length: number) => void;
}

export class GumVideoCapturer {
  constructor(
    maxWidth: number,
    maxHeight: number,
    maxFramerate: number,
    localPreview: Ref<HTMLVideoElement>
  );
}

export class CanvasVideoRenderer {
  constructor(canvas: Ref<HTMLCanvasElement>);
}

export type LoggerType = (...args: Array<any>) => void;

export type WhisperType = {
  events: {
    on: (name: string, callback: (param1: any, param2?: any) => void) => void;
    trigger: (name: string, param1: any, param2?: any) => void;
  };
  Database: {
    open: () => Promise<IDBDatabase>;
    handleDOMException: (
      context: string,
      error: DOMException | null,
      reject: Function
    ) => void;
  };
  ConversationCollection: typeof ConversationModelCollectionType;
  Conversation: typeof ConversationModelType;
  MessageCollection: typeof MessageModelCollectionType;
  Message: typeof MessageModelType;
};