@signalapp/mock-server/src/api/server.d.ts

Mock Signal Server for writing tests

/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
import { type Readable } from 'stream';
import Long from 'long';
import { ServerOptions } from 'https';
import { BackupMediaBatch } from '../data/schemas';
import { ProvisionIdString, ServiceIdKind, ServiceIdString } from '../types';
import { Group as GroupData } from '../data/group';
import { signalservice as Proto } from '../../protos/compiled';
import { BackupMediaBatchResponse, Server as BaseServer, ChallengeResponse, EnvelopeType, IsSendRateLimitedOptions, ModifyGroupOptions, ModifyGroupResult, ProvisionDeviceOptions, ProvisioningResponse, TransferArchiveResponse } from '../server/base';
import { Device, DeviceKeys } from '../data/device';
import { PrimaryDevice } from './primary-device';
type TrustRoot = Readonly<{
    privateKey: string;
    publicKey: string;
}>;
type ZKParams = Readonly<{
    secretParams: string;
    publicParams: string;
    genericSecretParams: string;
    genericPublicParams: string;
    backupSecretParams: string;
    backupPublicParams: string;
}>;
export type Config = Readonly<{
    trustRoot?: TrustRoot;
    zkParams?: ZKParams;
    https?: ServerOptions;
    timeout?: number;
    maxStorageReadKeys?: number;
    cdn3Path?: string;
    updates2Path?: string;
}>;
export type CreatePrimaryDeviceOptions = Readonly<{
    profileName: string;
    contacts?: ReadonlyArray<PrimaryDevice>;
    contactsWithoutProfileKey?: ReadonlyArray<PrimaryDevice>;
    password?: string;
}>;
export type PendingProvision = {
    complete(response: PendingProvisionResponse): Promise<Device>;
};
export type PendingProvisionResponse = Readonly<{
    provisionURL: string;
    primaryDevice: PrimaryDevice;
}>;
export type RateLimitOptions = Readonly<{
    source: ServiceIdString;
    target: ServiceIdString;
}>;
export declare class Server extends BaseServer {
    private readonly config;
    private readonly trustRoot;
    private readonly primaryDevices;
    private readonly knownNumbers;
    private emptyAttachment;
    private provisionQueue;
    private provisionResultQueueByCode;
    private provisionResultQueueByKey;
    private manifestQueueByAci;
    private groupQueueById;
    private transferArchiveByDevice;
    private transferCallbacksByDevice;
    private rateLimitCountByPair;
    private responseForChallenges;
    private unregisteredServiceIds;
    private wsUpgradeResponseHeaders;
    constructor(config?: Config);
    listen(port: number, host?: string): Promise<void>;
    close(): Promise<void>;
    waitForProvision(): Promise<PendingProvision>;
    private waitForStorageManifest;
    waitForGroupUpdate(group: GroupData): Promise<void>;
    createPrimaryDevice({ profileName, contacts, contactsWithoutProfileKey, password, }: CreatePrimaryDeviceOptions): Promise<PrimaryDevice>;
    createSecondaryDevice(primary: PrimaryDevice): Promise<Device>;
    unregister(primary: PrimaryDevice, serviceIdKind?: ServiceIdKind): void;
    register(primary: PrimaryDevice, serviceIdKind?: ServiceIdKind): void;
    respondToChallengesWith(code?: number, data?: unknown): void;
    stopRespondingToChallenges(): void;
    getResponseForChallenges(): ChallengeResponse | undefined;
    rateLimit({ source, target }: RateLimitOptions): void;
    stopRateLimiting({ source, target, }: RateLimitOptions): number | undefined;
    removeAllCDNAttachments(): Promise<void>;
    storeAttachmentOnCdn(cdnNumber: number, cdnKey: string, data: Uint8Array | Readable): Promise<void>;
    setWebsocketUpgradeResponseHeaders(headers: Record<string, string>): void;
    storeBackupOnCdn(backupId: Uint8Array, data: Uint8Array | Readable): Promise<void>;
    getProvisioningResponse(id: ProvisionIdString): Promise<ProvisioningResponse>;
    handleMessage(source: Device | undefined, serviceIdKind: ServiceIdKind, envelopeType: EnvelopeType, target: Device, encrypted: Buffer): Promise<void>;
    isUnregistered(serviceId: ServiceIdString): boolean;
    isSendRateLimited({ source, target, }: IsSendRateLimitedOptions): boolean;
    updateDeviceKeys(device: Device, serviceIdKind: ServiceIdKind, keys: DeviceKeys): Promise<void>;
    provisionDevice(options: ProvisionDeviceOptions): Promise<Device>;
    getStorageItems(device: Device, keys: ReadonlyArray<Buffer>): Promise<Array<Proto.IStorageItem> | undefined>;
    modifyGroup(options: ModifyGroupOptions): Promise<ModifyGroupResult>;
    protected onStorageManifestUpdate(device: Device, version: Long): Promise<void>;
    protected backupTransitAttachments(backupId: string, batch: BackupMediaBatch): Promise<Array<BackupMediaBatchResponse>>;
    provideTransferArchive(device: Device, archive: TransferArchiveResponse): Promise<void>;
    getTransferArchive(device: Device): Promise<TransferArchiveResponse>;
    private createQueue;
    private generateNumber;
}
export {};