@formant/realtime-sdk 1.3.0 → 1.4.0

package/dist/client/AuthClient.d.ts

@@ -0,0 +1,42 @@
+import { FormantBaseClient } from "../common/FormantBaseClient";
+import { Feature } from "../model/Feature";
+import { IAdminSignupRequest } from "../model/IAdminSignupRequest";
+import { ICheckSsoResult } from "../model/ICheckSsoResult";
+import { ICreateServiceAccountResponse } from "../model/ICreateServiceAccountResponse";
+import { IDeviceCredentials } from "../model/IDeviceCredentials";
+import { IGoogleLoginRequest } from "../model/IGoogleLoginRequest";
+import { ILoginRequest } from "../model/ILoginRequest";
+import { ILoginResult } from "../model/ILoginResult";
+import { ITags } from "../model/ITags";
+import { IUser } from "../model/IUser";
+import { Uuid } from "../model/Uuid";
+export declare class AuthClient extends FormantBaseClient {
+    adminSignup(props: IAdminSignupRequest, token?: string): Promise<IUser>;
+    login(credentials: ILoginRequest): Promise<ILoginResult>;
+    loginWithGoogleToken(credentials: IGoogleLoginRequest): Promise<ILoginResult>;
+    refresh(refreshToken: string, tokenExpirationSeconds?: number): Promise<ILoginResult>;
+    respondToNewPasswordRequiredChallenge(props: {
+        userId: Uuid;
+        session: string;
+        newPassword: string;
+    }): Promise<ILoginResult>;
+    forgotPassword(email: string): Promise<void>;
+    confirmForgotPassword(props: {
+        email: string;
+        confirmationCode: string;
+        newPassword: string;
+    }): Promise<void>;
+    resendInvitation(email: string): Promise<void>;
+    changePassword({ token, refreshToken, currentPassword, newPassword, }: {
+        token: string;
+        refreshToken: string;
+        currentPassword: string;
+        newPassword: string;
+    }): Promise<void>;
+    getDeviceCredentials(token: string): Promise<IDeviceCredentials>;
+    impersonate(token: string, userId: Uuid): Promise<ILoginResult>;
+    createServiceAccount(token: string, name: string, roleId: Uuid, tags: ITags, description?: string): Promise<ICreateServiceAccountResponse>;
+    getFeatures(token: string): Promise<Feature[]>;
+    checkSso(email: string, allowUserAutoCreation?: boolean): Promise<ICheckSsoResult>;
+    loginWithSso(token: string, refreshToken?: string): Promise<ILoginResult>;
+}

package/dist/client/Credentials.d.ts

@@ -0,0 +1,10 @@
+import { AuthClient } from "./AuthClient";
+export declare class Credentials {
+    private authClient;
+    private email;
+    private password;
+    private tokenTtlMs;
+    private tokenCache;
+    constructor(authClient: AuthClient, email: string, password: string);
+    getToken(): Promise<string>;
+}

package/dist/client/LanAgentClient.d.ts

@@ -0,0 +1,7 @@
+import { BaseClient } from "../common/BaseClient";
+import { IPostLanRtcOfferRequest } from "../model/IPostLanRtcOfferRequest";
+import { IPostLanRtcOfferResponse } from "../model/IPostLanRtcOfferResponse";
+export declare class LanAgentClient extends BaseClient {
+    constructor(endpoint: string);
+    postLanRtcOffer(request: IPostLanRtcOfferRequest): Promise<IPostLanRtcOfferResponse>;
+}

package/dist/client/RtcSignalingClient.d.ts

@@ -0,0 +1,20 @@
+import { FormantBaseClient } from "../common/FormantBaseClient";
+import { IRtcAddSignalsRequest } from "../model/IRtcAddSignalsRequest";
+import { IRtcCreatePeerRequest } from "../model/IRtcCreatePeerRequest";
+import { IRtcCreateSessionRequest } from "../model/IRtcCreateSessionRequest";
+import { IRtcPeer } from "../model/IRtcPeer";
+import { IRtcSession } from "../model/IRtcSession";
+import { IRtcSignal } from "../model/IRtcSignal";
+import { Uuid } from "../model/Uuid";
+export declare class RtcSignalingClient extends FormantBaseClient {
+    createPeer(token: string, request: IRtcCreatePeerRequest): Promise<IRtcPeer>;
+    getPeers(token: string): Promise<IRtcPeer[]>;
+    refreshPeer(token: string, id: Uuid): Promise<void>;
+    createSession(token: string, request: IRtcCreateSessionRequest): Promise<IRtcSession>;
+    refreshSession(token: string, id: Uuid): Promise<void>;
+    deleteSession(token: string, id: Uuid): Promise<void>;
+    getSessions(token: string): Promise<IRtcSession[]>;
+    getIceServers(token: string): Promise<RTCIceServer[]>;
+    addSignals(token: string, sessionId: Uuid, request: IRtcAddSignalsRequest): Promise<void>;
+    takeSignals(token: string, sessionId: Uuid): Promise<IRtcSignal[]>;
+}

package/dist/common/BaseClient.d.ts

@@ -0,0 +1,43 @@
+import { IDictionary } from "../model/IDictionary";
+import { IValidation } from "../model/IValidation";
+import { ResponseError } from "./ResponseError";
+export interface IRequestInit {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: IDictionary;
+    body?: any;
+    token?: string;
+    allowUnsafeRetries?: boolean;
+    json?: boolean;
+}
+export interface IResponse<T> {
+    body: T;
+    headers: Headers;
+}
+export declare abstract class BaseClient {
+    protected endpoint: string | undefined;
+    static retries: number;
+    static waitForConnectivity: () => Promise<void>;
+    static onResponseError: (error: ResponseError) => Promise<void>;
+    private validateHeaders;
+    private verbose;
+    private configuredRetries;
+    private timeoutMs?;
+    private maxBackoffDelayMs;
+    private json;
+    constructor(endpoint: string | undefined, options?: {
+        validateHeaders?: (headers: Headers) => IValidation;
+        verbose?: boolean;
+        retries?: number;
+        timeoutMs?: number;
+        maxBackoffDelayMs?: number;
+        json?: boolean;
+    });
+    protected getRetries(): number;
+    protected getHeaders(): {
+        [_: string]: string;
+    };
+    protected fetch<T>(path: string, extendedInit?: IRequestInit): Promise<T>;
+    protected fetchVerbose<T>(path: string, extendedInit?: IRequestInit): Promise<IResponse<T>>;
+    private doFetch;
+    private getConstructor;
+}

package/dist/common/ConnectionError.d.ts

@@ -0,0 +1,6 @@
+export declare class ConnectionError extends Error {
+    cause: Error;
+    url: string;
+    retryable: boolean;
+    constructor(cause: Error, url: string, retryable: boolean);
+}

package/dist/common/FormantBaseClient.d.ts

@@ -0,0 +1,13 @@
+import { BaseClient } from "./BaseClient";
+export declare abstract class FormantBaseClient extends BaseClient {
+    protected endpoint: string;
+    static headers: {
+        [_: string]: string;
+    };
+    constructor(endpoint: string, options?: {
+        timeoutMs?: number;
+    });
+    protected getHeaders(): {
+        [_: string]: string;
+    };
+}

package/dist/common/LogApiTransport.d.ts

@@ -0,0 +1,11 @@
+import Transport from "winston-transport";
+export declare class LogApiTransport extends Transport {
+    private endpoint;
+    private metadata;
+    private logClient;
+    constructor(endpoint: string, metadata: {
+        [_: string]: string;
+    });
+    private getLogClient;
+    log(info: any, callback: () => void): Promise<void>;
+}

package/dist/common/LogClient.d.ts

@@ -0,0 +1,6 @@
+import { ILogLine } from "../model/ILogLine";
+import { FormantBaseClient } from "./FormantBaseClient";
+export declare class LogClient extends FormantBaseClient {
+    static token?: string;
+    log(lines: ILogLine[]): Promise<void>;
+}

package/dist/common/LogReporter.d.ts

@@ -0,0 +1,6 @@
+import { IStatEntry, StatsReporter } from "./StatsReporter";
+export declare class LogReporter extends StatsReporter<"simple"> {
+    private message;
+    constructor(message: string);
+    send(values: IStatEntry[]): Promise<void>;
+}

package/dist/common/LruCache.d.ts

@@ -0,0 +1,20 @@
+import BaseLruCache from "lru-cache";
+export type CacheOptions<V> = BaseLruCache.Options<string, V> & {
+    name: string;
+    fastStringify?: boolean;
+};
+export declare class LruCache<K, V> {
+    private options;
+    private cache;
+    private stringify;
+    constructor(options: CacheOptions<V>);
+    set(key: K, value: V, ttl?: number): void;
+    get(key: K): V | undefined;
+    delete(key: K): void;
+    peek(key: K): V | undefined;
+    size(): number;
+    clear(): void;
+    forEach(callback: (value: V) => void): void;
+    purgeStale(): boolean;
+    private updateStats;
+}

package/dist/common/PromiseLruCache.d.ts

@@ -0,0 +1,11 @@
+import { CacheOptions, LruCache } from "./LruCache";
+export type PromiseCacheOptions<V> = CacheOptions<Promise<V>> & {
+    expireRejectedPromiseValues?: boolean;
+    rejectedPromiseValueTtl?: number;
+};
+export declare class PromiseLruCache<K, V> extends LruCache<K, Promise<V>> {
+    protected expireRejectedPromiseValues: boolean;
+    protected rejectedPromiseValueTtl: number;
+    constructor(options: PromiseCacheOptions<V>);
+    set(key: K, value: Promise<V>, ttl?: number): void;
+}

package/dist/common/ResponseError.d.ts

@@ -0,0 +1,11 @@
+import { IValidation } from "../model/IValidation";
+export declare class ResponseError extends Error {
+    method: string;
+    url: string;
+    requestBody: any;
+    statusCode: number;
+    headers: any;
+    body: any;
+    validationErrors: IValidation;
+    constructor(method: string, url: string, requestBody: any, statusCode: number, headers: any, body: any, validationErrors?: IValidation);
+}

package/dist/common/ResponseHeadersError.d.ts

@@ -0,0 +1,7 @@
+import { IValidation } from "../model/IValidation";
+import { ResponseError } from "./ResponseError";
+export declare class ResponseHeadersError extends Error {
+    validationErrors: IValidation;
+    responseError: ResponseError;
+    constructor(validationErrors: IValidation, responseError: ResponseError);
+}

package/dist/common/StatsManager.d.ts

@@ -0,0 +1,39 @@
+import { IStat } from "../model/IStat";
+import { ITags } from "../model/ITags";
+import { StatsReporter } from "./StatsReporter";
+export declare class StatsManager {
+    static readonly samplePeriodMs: number;
+    private buffer;
+    private reporters;
+    private flushInterval;
+    private tags;
+    constructor(config?: {
+        tags?: ITags;
+    });
+    shutdown(): Promise<void>;
+    /**
+     * Aggregates a value into the IStat record at key.
+     */
+    aggregate(metric: string, value: number | IStat, tags?: ITags): void;
+    /**
+     * Aggregates 1 into the IStat record at key.
+     */
+    increment(metric: string, tags?: ITags): void;
+    /**
+     * Times a function call and the promise it produces.
+     * The timing statistic is only recorded if the function
+     * returns without an exception.
+     */
+    timer<T>(metric: string, f: () => Promise<T>, tags?: ITags): Promise<T>;
+    /**
+     * Register a reporter.
+     */
+    registerStatsReporter(statsReporter: StatsReporter): void;
+    setTag(key: string, value: string): void;
+    private addToBuffer;
+    private write;
+    private flushStats;
+    private encodeKey;
+    private decodeKey;
+    private filterTags;
+}

package/dist/common/StatsReporter.d.ts

@@ -0,0 +1,17 @@
+import { IMetric } from "../model/IMetric";
+import { ITags } from "../model/ITags";
+export interface IEntryTypeMap {
+    simple: IStatEntry;
+    tagged: ITaggedStatEntry;
+}
+export type StatsReporterType = keyof IEntryTypeMap;
+export type IStatEntry = Omit<IMetric, "tags">;
+export type ITaggedStatEntry = IStatEntry & {
+    tags: ITags;
+};
+export declare abstract class StatsReporter<T extends StatsReporterType = StatsReporterType> {
+    readonly type: T;
+    readonly name: string;
+    constructor(type: T, name: string);
+    abstract send(values: IEntryTypeMap[T][], intervalMs: number): Promise<void>;
+}

package/dist/common/assertUnreachable.d.ts

@@ -0,0 +1 @@
+export declare function assertUnreachable(_: never): never;

package/dist/common/browser.d.ts

@@ -0,0 +1,2 @@
+export type BrowserType = "Firefox" | "Chrome" | "Edge" | "Safari" | "IE" | "Other";
+export declare function browser(): BrowserType;

package/dist/common/collectErrors.d.ts

@@ -0,0 +1 @@
+export declare function collectErrors<T>(promises: Promise<T>[]): Promise<Error[]>;

package/dist/common/config/index.d.ts

@@ -0,0 +1,23 @@
+export declare const environment: string;
+export declare const app: string;
+export declare const appPath: string;
+export declare const apiEndpoint: string;
+export declare const namespace: string;
+export declare const version: string;
+export declare const buildTag: string;
+export declare const gitCommit: string;
+export declare const enableSentry: boolean;
+export declare const enableSentryProfiling: boolean;
+export declare const sentryDsn: string;
+export declare const logLevel: string;
+export declare const logJson: boolean;
+export declare const logToConsole: boolean;
+export declare const stableAgentVersion: string;
+export declare const logApiEndpoint: string | undefined;
+export declare const jestWorkerId: string | undefined;
+export declare const sheetExportMaxRowCount: number;
+export declare const logToFile: boolean;
+export declare const enableSelfServe: boolean;
+export type UsageMetricsAggregateLevel = "day" | "hour" | "minute";
+export declare const aggregateLevel: UsageMetricsAggregateLevel;
+export declare const auditLogsEnabled: boolean;

package/dist/common/defined.d.ts

@@ -0,0 +1,6 @@
+export declare function assertsDefined<T>(value: T | undefined, message?: string): asserts value is T;
+export declare function assertsNotNull<T>(value: T | null, message?: string): asserts value is T;
+export declare function assertsDefinedAndNotNull<T>(value: T | undefined | null, message?: string): asserts value is T;
+export declare function defined<T>(value: T | undefined): T;
+export declare function notNull<T>(value: T | null): T;
+export declare function definedAndNotNull<T>(value: T | undefined | null): T;

package/dist/common/delay.d.ts

@@ -0,0 +1 @@
+export declare const delay: (time?: number) => Promise<unknown>;

package/dist/common/errorToObject.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Convert an error object to plain javascript object, including any custom properties.
+ */
+export declare function errorToObject(error: any, options?: {
+    redacted?: boolean;
+}): {
+    message: string;
+    name?: undefined;
+    stack?: undefined;
+    meta?: undefined;
+} | {
+    name: any;
+    message: any;
+    stack: any;
+    meta: any;
+};

package/dist/common/errorToString.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Serialize an error object to a string, including any custom properties.
+ */
+export declare function errorToString(error: any, options?: {
+    redacted?: boolean;
+}): string;

package/dist/common/filterIceServers.d.ts

@@ -0,0 +1,8 @@
+import { IRtcIceServer } from "../model/IRtcIceServer";
+import { IRtcInfo } from "../model/IRtcInfo";
+import { RtcIceServerProtocol } from "../model/RtcIceServerProtocol";
+import { RtcIceTransportPolicy } from "../model/RtcIceTransportPolicy";
+import { Uuid } from "../model/Uuid";
+export declare function filterIceServers(iceServers: IRtcIceServer[], rtcInfo: IRtcInfo | undefined, organizationId?: Uuid): IRtcIceServer[];
+export declare function isPolicy(url: string, policy: RtcIceTransportPolicy): boolean;
+export declare function isProtocol(url: string, protocol: RtcIceServerProtocol): boolean;

package/dist/common/instanceId.d.ts

@@ -0,0 +1 @@
+export declare const instanceId: string;

package/dist/common/isErrorType.d.ts

@@ -0,0 +1 @@
+export declare function isErrorType<T extends Error>(error: unknown, constructor: new (...x: any[]) => T, predicate?: (t: T) => boolean): error is T;

package/dist/common/isObject.d.ts

@@ -0,0 +1 @@
+export declare function isObject(value: any): boolean;

package/dist/common/isValidTagString.d.ts

@@ -0,0 +1 @@
+export declare function isValidTagString(keyOrValue: string, allowStar?: boolean): boolean;

package/dist/common/logger.d.ts

@@ -0,0 +1,4 @@
+import { IAuditLog } from "../model/IAuditLog";
+export declare function setLogMetadata(key: string, value: string): void;
+export declare const logger: import("winston").Logger;
+export declare function audit(auditLog: IAuditLog): void;

package/dist/common/narrowError.d.ts

@@ -0,0 +1 @@
+export declare function narrowError<T extends Error>(error: unknown, constructor: new (...x: any[]) => T, predicate?: (t: T) => boolean): T;

package/dist/common/objectMapValues.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates an object with the same keys as obj and values
+ * produced by mapping each keyed property with mapF.
+ */
+export declare function objectMapValues<T1, T2>(obj: {
+    [key: string]: T1;
+}, mapF: (value: T1) => T2): {
+    [key: string]: T2;
+};

package/dist/common/redact.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a copy of an object with sensitive information redacted.
+ */
+export declare function redact(object: unknown, visited?: WeakSet<any>): any;
+export declare const redactStringifiedFields: (offerSignal: any) => Record<any, any>;

package/dist/common/setPromiseInterval.d.ts

@@ -0,0 +1,16 @@
+export interface IPromiseIntervalOptions {
+    func: () => Promise<void>;
+    delay: number;
+    immediate?: boolean;
+}
+export interface IShutdownPromiseInterval {
+    stop(): Promise<void>;
+}
+/**
+ * Runs callback function f periodically.
+ * The next call is queued only after the
+ * promise returned by f is resolved.
+ *
+ * Returns a function that stops execution if invoked.
+ */
+export declare function setPromiseInterval({ func, delay, immediate, }: IPromiseIntervalOptions): IShutdownPromiseInterval;

package/dist/common/stats.d.ts

@@ -0,0 +1,2 @@
+import { StatsManager } from "./StatsManager";
+export declare const stats: StatsManager;

package/dist/common/toStringSafe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Safely stringify input.
+ * Similar to `JSON.stringify` but
+ * doesn't throw an error if input includes circular properties.
+ *
+ * Warning: output is not guaranteed to be a valid JSON string.
+ */
+export declare function toStringSafe(input: any): string;

package/dist/date-fns/parseIsoDate.d.ts

@@ -0,0 +1 @@
+export declare function parseIsoDate(timestamp: string): Date;