@factset/frontgate-js-sdk 6.9.0

package/dist/lib/types/Mdg2Client.d.ts

@@ -0,0 +1,52 @@
+import type { HighLevelRequestResult, ObserveOptions, RequestResult } from './common/interfaces';
+import type { RequestQuality } from './common/types';
+import type { ConnectionInterface, ServerInfo } from './connection';
+import type { LoggerInterface } from './logger';
+import type { CookieTokenAuthenticationFactors } from './authentication';
+import type { Mdg2ClientOptions } from './common/Mdg2ClientOptions';
+import type { HTTPProxyRequestResult } from './common/interfaces/result/HTTPProxyRequestResult';
+import type { AbstractMdg2Request, HighLevelRequestMethod, HighLevelRequestOptions, JobObservable, Mdg2Response, HTTPMethod, HTTPProxyRequestOptions } from './message';
+export declare class Mdg2Client {
+    options: Mdg2ClientOptions;
+    private connection?;
+    private logger;
+    private readonly subscriptionModule;
+    private readonly requestModule;
+    flagPermissionDenied: boolean;
+    shouldRestartSubscriptions: boolean;
+    defaultTimeoutInMs: number;
+    defaultTimeoutTokenInMs: number;
+    maxTimeoutsBeforeReconnect: number;
+    enableSessionHandling: boolean;
+    private readonly replaySubjectBufferSize;
+    onConnectCallback: () => null;
+    private sessionConnect;
+    constructor(connection?: ConnectionInterface, options?: Mdg2ClientOptions);
+    connect(): Promise<void>;
+    connectSession(shouldThrow?: boolean): Promise<boolean>;
+    disconnect(logout?: boolean): Promise<void>;
+    request(msg: AbstractMdg2Request, timeOutInMs?: number): Promise<Mdg2Response>;
+    restartSubscriptions(): void;
+    requestWithQuality(msg: AbstractMdg2Request, quality?: RequestQuality, timeOutInMs?: number): Promise<Mdg2Response>;
+    requestEndpoint(method: HighLevelRequestMethod, path: string, data?: Record<string, unknown>, options?: HighLevelRequestOptions, timeOutInMs?: number): Promise<HighLevelRequestResult>;
+    requestProxyEndpoint(method: HTTPMethod, path: string, body?: Record<string, unknown>, options?: HTTPProxyRequestOptions, timeOutInMs?: number): Promise<HTTPProxyRequestResult>;
+    requestAuthenticationToken(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<string>;
+    requestAuthenticationTokenExpiry(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number, otp?: boolean): Promise<{
+        token: string;
+        expiry: number;
+    }>;
+    requestOtpAuthenticationTokenForSessionHandling(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<void>;
+    requestAuthenticationTokenForCookieTokenAuthentication(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<CookieTokenAuthenticationFactors>;
+    observeEndpoint(method: HighLevelRequestMethod, path: string, data: Record<string, unknown>, options?: ObserveOptions, requestOptions?: HighLevelRequestOptions): JobObservable<RequestResult>;
+    unobserveEndpoint(idJob: number): Promise<void>;
+    setConnection(connection: ConnectionInterface): void;
+    getConnection(): ConnectionInterface | undefined;
+    setConnectionFromFetchConfiguration(input: RequestInfo, init?: RequestInit, shouldReconnectOnConnectionLoss?: boolean): Promise<void | Response>;
+    static createConnection(config: any, input?: RequestInfo, init?: RequestInit): ConnectionInterface;
+    setLogger(logger: LoggerInterface): void;
+    getLogger(): LoggerInterface;
+    get isConnected(): boolean;
+    get isConnecting(): boolean;
+    getServerInfo(): ServerInfo | undefined;
+    setConnectionFromSavedConfig(): boolean;
+}

package/dist/lib/types/authentication/AbstractAuthentication.d.ts

@@ -0,0 +1,17 @@
+import type { ConnectionInterface, PeerInfo, ServerInfo } from '../connection';
+import type { AuthenticationInterface } from './AuthenticationInterface';
+import type { DisconnectionMessage, ConfigurationResponse, AuthenticationByTokenResponse } from '../message';
+export declare const ID_APP_AUTHENTICATED = -2;
+export declare const ID_USER_AUTHENTICATED = -2;
+export declare const ID_USER_NONE = -1;
+export declare abstract class AbstractAuthentication implements AuthenticationInterface {
+    readonly idApplication: number;
+    readonly idUser: number;
+    protected connection: ConnectionInterface;
+    private serverInfo;
+    protected constructor(idApplication: number, idUser?: number);
+    abstract authenticate(connection: ConnectionInterface): Promise<void>;
+    protected peerInfoFromMessage(msg: AuthenticationByTokenResponse | ConfigurationResponse | DisconnectionMessage): PeerInfo;
+    private parseServerInfo;
+    getServerInfo(): ServerInfo;
+}

package/dist/lib/types/authentication/AppAuthentication.d.ts

@@ -0,0 +1,12 @@
+import type { ConnectionInterface } from '../connection';
+import { AbstractAuthentication } from './AbstractAuthentication';
+export declare class AppAuthentication extends AbstractAuthentication {
+    readonly sharedSecret: Buffer;
+    readonly clientSecret: Buffer;
+    readonly reconnectable = true;
+    constructor(idApplication: number, idUser: number, clientCredentials: string);
+    authenticate(connection: ConnectionInterface): Promise<void>;
+    private sendAuthenticationRequest;
+    private sendConfigurationRequest;
+    private sendTransportLayerRequestHeaderConfigurationRequest;
+}

package/dist/lib/types/authentication/AuthenticationInterface.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionInterface, ServerInfo } from '../connection';
+export interface AuthenticationInterface {
+    idApplication: number;
+    idUser: number;
+    authenticate: (connection: ConnectionInterface) => Promise<void>;
+    getServerInfo: () => ServerInfo;
+    reconnectable?: boolean;
+    onReconnect?: () => Promise<void>;
+}

package/dist/lib/types/authentication/CookieTokenAuthentication.d.ts

@@ -0,0 +1,6 @@
+import { TokenAuthentication } from './TokenAuthentication';
+export declare class CookieTokenAuthentication extends TokenAuthentication {
+    constructor();
+    protected getEncodedToken(): any[];
+    onReconnect(): Promise<void>;
+}

package/dist/lib/types/authentication/CookieTokenAuthenticationFactors.d.ts

@@ -0,0 +1,7 @@
+export declare class CookieTokenAuthenticationFactors {
+    private readonly firstFactor;
+    private readonly secondFactor;
+    constructor(token: string);
+    getFirstFactor(): string;
+    getSecondFactor(): string;
+}

package/dist/lib/types/authentication/TokenAuthentication.d.ts

@@ -0,0 +1,14 @@
+import { type ConnectionInterface } from '../connection';
+import { AbstractAuthentication } from './AbstractAuthentication';
+export declare class TokenAuthentication extends AbstractAuthentication {
+    token: string;
+    protected fetchConfigurationInput: RequestInfo | undefined;
+    protected fetchConfigurationConfig: RequestInit | undefined;
+    constructor(token: string, validate?: boolean);
+    private setToken;
+    setFetchConfiguration(input: RequestInfo | undefined, config: RequestInit | undefined): void;
+    authenticate(connection: ConnectionInterface): Promise<void>;
+    private sendAuthenticationByTokenRequest;
+    get reconnectable(): boolean;
+    onReconnect(): Promise<void>;
+}

package/dist/lib/types/authentication/UserCredentialAuthentication.d.ts

@@ -0,0 +1,13 @@
+import type { ConnectionInterface } from '../connection';
+import { AbstractAuthentication } from './AbstractAuthentication';
+export declare class UserCredentialAuthentication extends AbstractAuthentication {
+    readonly username: string;
+    readonly sharedSecret: Buffer;
+    readonly clientSecret: Buffer;
+    readonly reconnectable = true;
+    constructor(idApplication: number, username: string, credentials: string);
+    authenticate(connection: ConnectionInterface): Promise<void>;
+    private sendAuthenticationRequest;
+    private sendConfigurationRequest;
+    private sendTransportLayerRequestHeaderConfigurationRequest;
+}

package/dist/lib/types/authentication/UserPasswordAuthentication.d.ts

@@ -0,0 +1,14 @@
+import type { ConnectionInterface } from '../connection';
+import { AbstractAuthentication } from './AbstractAuthentication';
+export declare class UserPasswordAuthentication extends AbstractAuthentication {
+    readonly password: string;
+    readonly username: string;
+    readonly sharedSecret: Buffer;
+    readonly clientSecret: Buffer;
+    readonly reconnectable = true;
+    constructor(idApplication: number, username: string, password: string);
+    authenticate(connection: ConnectionInterface): Promise<void>;
+    private sendAuthenticationRequest;
+    private sendConfigurationRequest;
+    private sendTransportLayerRequestHeaderConfigurationRequest;
+}

package/dist/lib/types/authentication/index.d.ts

@@ -0,0 +1,5 @@
+export * from './AbstractAuthentication';
+export * from './AuthenticationInterface';
+export * from './CookieTokenAuthentication';
+export * from './CookieTokenAuthenticationFactors';
+export * from './TokenAuthentication';

package/dist/lib/types/authentication/util/ChallengeResolver.d.ts

@@ -0,0 +1,15 @@
+import bigInt from 'big-integer';
+export interface SaltedHash {
+    salt: number[];
+    hash1: bigInt.BigInteger;
+    hash2: bigInt.BigInteger;
+    hash3: bigInt.BigInteger;
+}
+export declare class ChallengeResolver {
+    private static readonly INT64MSB;
+    private static readonly INT64OVERFLOW;
+    private static readonly CLIENT_STATIC_PART;
+    static solveChallenge(challenge: Buffer, sharedSecret: Buffer, staticPart?: Buffer): SaltedHash;
+    private static createSaltedHash;
+    private static hexToInt64LE;
+}

package/dist/lib/types/authentication/util/SecretGenerator.d.ts

@@ -0,0 +1,14 @@
+export declare class SecretGenerator {
+    private static readonly INITIALIZATION_VECTOR;
+    private static readonly CLIENT_STATIC_PART;
+    private static readonly SALT_ROUNDS;
+    private static readonly BCRYPT_KEY_A;
+    private static readonly BCRYPT_KEY_B;
+    private static readonly ALGORITHM;
+    static createEncryptedSecret(salt: Buffer, sharedSecret: Buffer, clientSecret: Buffer): number[];
+    static generateClientSecret(username: string, password: string, callback?: (err: Error, encrypted: string) => void): string | undefined;
+    static generateSharedSecret(username: string, password: string, callback?: (err: Error, encrypted: string) => void): string | undefined;
+    static getEncryptionKey(salt: Buffer, secret: Buffer): Buffer;
+    private static generateSalt;
+    private static create128bitSeed;
+}

package/dist/lib/types/authentication/util/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ChallengeResolver';
+export * from './SecretGenerator';

package/dist/lib/types/common/Mdg2ClientOptions.d.ts

@@ -0,0 +1,12 @@
+export interface Mdg2ClientOptions {
+    flagPermissionDenied?: boolean;
+    shouldRestartSubscriptions?: boolean;
+    defaultTimeoutInMs?: number;
+    defaultTimeoutTokenInMs?: number;
+    maxTimeoutsBeforeReconnect?: number;
+    onConnectCallback?: () => null;
+    otpToken?: string;
+    otpTokenExpiry?: number;
+    enableSessionHandling?: boolean;
+    replaySubjectBufferSize?: number;
+}

package/dist/lib/types/common/constants.d.ts

@@ -0,0 +1,11 @@
+import type { RequestQuality } from './types';
+export declare const LOGGER_NAME = "Mdg2Client";
+export declare const DEFAULT_QUALITY: RequestQuality;
+export declare const DEFAULT_TIMEOUT_IN_MS = 6000;
+export declare const DEFAULT_TIMEOUT_TOKEN_IN_MS = 3000;
+export declare const DEFAULT_TIMEOUT_CONNECTION_IN_MS = 9000;
+export declare const DEFAULT_MAX_TIMEOUTS_BEFORE_RECONNECT = 3;
+export declare const DEFAULT_ENABLE_SESSION_HANDLING = false;
+export declare const DEFAULT_RESUBSCRIBE_WAIT_TIME_IN_MS = 9000;
+export declare const DEFAULT_FLAG_PERMISSION_DENIED = false;
+export declare const DEFAULT_REPLAY_SUBJECT_BUFFER_SIZE = 512;

package/dist/lib/types/common/errors.d.ts

@@ -0,0 +1,30 @@
+import type { ErrorResponse } from '../message';
+export interface CustomError {
+    message: string;
+    name: string;
+    code: number;
+}
+export declare class ServiceUnavailableError extends Error implements CustomError {
+    code: number;
+    constructor(message?: string, error?: Error);
+}
+export declare class InternalServerError extends Error implements CustomError {
+    code: number;
+    constructor(message?: string, error?: Error);
+}
+export declare class TimeoutError extends Error implements CustomError {
+    code: number;
+    constructor(message?: string, error?: Error);
+}
+export declare class UnauthorizedError extends Error implements CustomError {
+    code: number;
+    constructor(message?: string, error?: Error);
+}
+export declare class BadRequestError extends Error implements CustomError {
+    code: number;
+    constructor(message?: string, error?: Error);
+}
+export declare class ResponseError extends Error {
+    response: ErrorResponse;
+    constructor(message: string, response: ErrorResponse);
+}

package/dist/lib/types/common/functions.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorResponse, PermissionDeniedResponse } from '../message';
+export declare function isObject(obj: unknown): obj is object;
+export declare function deepmerge(...args: unknown[]): object;
+export declare function provideAsArray<T>(subject: T | T[]): T[];
+export declare function unsignedArrayToBase64(data: number[] | Uint8Array): string;
+export declare function toUrlBase64(strInBase64: string): string;
+export declare function isBase64Url(tokenStr: string): boolean;
+export declare function base64UrlToBase64(base64Url: string): string;
+export declare const errorHandler: (response: ErrorResponse | PermissionDeniedResponse) => Error;
+export declare const delay: (delayInMs: number) => Promise<unknown>;
+export declare const isNodeEnvironment: () => boolean;

package/dist/lib/types/common/interfaces/PtlMessage.d.ts

@@ -0,0 +1,5 @@
+export interface PtlMessage {
+    Message: string;
+    Version: number;
+    [prop: string]: any;
+}

package/dist/lib/types/common/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+export * from './observe/ObserveOptions';
+export * from './result/RequestResult';
+export * from './result/HighLevelRequestResult';
+export * from './result/HTTPProxyRequestResult';
+export type { PtlMessage } from './PtlMessage';

package/dist/lib/types/common/interfaces/observe/ObserveOptions.d.ts

@@ -0,0 +1,5 @@
+import type { RequestQuality } from '../../types';
+export interface ObserveOptions {
+    quality?: RequestQuality;
+    minInterval?: number;
+}

package/dist/lib/types/common/interfaces/result/HTTPProxyRequestResult.d.ts

@@ -0,0 +1,6 @@
+import type { RequestResult } from './RequestResult';
+import type { HTTPProxyResponse } from '../../../message';
+export interface HTTPProxyRequestResult extends RequestResult {
+    data: any | any[];
+    response: HTTPProxyResponse;
+}

package/dist/lib/types/common/interfaces/result/HighLevelRequestResult.d.ts

@@ -0,0 +1,6 @@
+import type { HighLevelResponse } from '../../../message';
+import type { RequestResult } from './RequestResult';
+export interface HighLevelRequestResult<Data = any> extends RequestResult {
+    data: Data;
+    response: HighLevelResponse<Data>;
+}

package/dist/lib/types/common/interfaces/result/RequestResult.d.ts

@@ -0,0 +1,5 @@
+import type { Mdg2Response } from '../../../message';
+export interface RequestResult {
+    data: any | any[];
+    response: Mdg2Response;
+}

package/dist/lib/types/common/types/Quality.d.ts

@@ -0,0 +1 @@
+export type Quality = 'RLT' | 'DLY' | 'EOD';

package/dist/lib/types/common/types/RequestQuality.d.ts

@@ -0,0 +1,2 @@
+import type { Quality } from './Quality';
+export type RequestQuality = Quality | 'BST';

package/dist/lib/types/common/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './RequestQuality';
+export * from './Quality';

package/dist/lib/types/compat/index.d.ts

@@ -0,0 +1,10 @@
+export * from '../authentication/util';
+export * from '../authentication/AppAuthentication';
+export * from '../authentication/UserCredentialAuthentication';
+export * from '../authentication/UserPasswordAuthentication';
+export * from '../message/request/AuthenticationRequest';
+export * from '../message/request/ConfigurationRequest';
+export * from '../mixins/auth/AppAuthMixin';
+export * from '../mixins/auth/UserCredentialAuthMixin';
+export * from '../mixins/auth/UserPasswordAuthMixin';
+export * from '../mixins/auth/SessionAuthMixin';

package/dist/lib/types/connection/AbstractFrontgateConnection.d.ts

@@ -0,0 +1,116 @@
+import type { LoggerInterface } from '../logger';
+import { LogLevel } from '../logger';
+import type { AuthenticationInterface } from '../authentication';
+import type { PtlMessage } from '../common/interfaces';
+import type { ConnectionInterface, MaybeVoidFunctionType, PeerInfo } from './ConnectionInterface';
+import type { JobPromise } from './JobPromise';
+import { Compressor } from './util/Compressor';
+import type { SupportedEncoding } from './util/Encoding';
+import type { MessageProcessor } from './MessageProcessor';
+import type { ClientOptions } from 'ws';
+import type { DisconnectionMessage, LoadNotificationMessage } from '../message';
+import type { Mdg2ClientOptions } from '../common/Mdg2ClientOptions';
+export declare enum ConnectionState {
+    DISCONNECTED = 0,
+    CONNECTING = 1,
+    AUTHENTICATED = 2,
+    RECONNECTING = 3
+}
+export declare enum DeploymentStage {
+    production = 40,
+    preproduction = 35,
+    show = 30,
+    testing = 20
+}
+export declare enum DefaultHosts {
+    production = "frontgate-eu.factsetdigitalsolutions.com",
+    show = "frontgate-eu.show.factsetdigitalsolutions.com"
+}
+export interface FrontgateConnectionOptions {
+    payloadContent?: string;
+    payload_content: string;
+    deploymentStage?: DeploymentStage;
+    deployment_stage: DeploymentStage;
+    logger?: LoggerInterface;
+    loglevel?: LogLevel;
+    maximumIdleInterval?: number;
+    maximum_idle_interval: number;
+    frontgateAuthenticationToken?: string;
+    frontgateSplitAuthenticationTokenSecondFactor?: string | null;
+    splitAuthenticationTokenSecondFactor?: string;
+    split_authentication_token_second_factor?: string;
+    frontgateHost?: string;
+    host: string;
+    port: number;
+    tls: boolean;
+    frontgatePathPrefix?: string;
+    pathPrefix?: string;
+    path_prefix: string;
+    frontgateWebsocketProtocol?: SupportedEncoding;
+    encoding: SupportedEncoding;
+    webSocketClientOptions?: ClientOptions;
+    shouldReconnectOnConnectionLoss: boolean;
+    connectionTimeoutInMs: number;
+    enablePingPongKeepalive?: boolean;
+    sessionHandling: boolean;
+}
+export declare abstract class AbstractFrontgateConnection implements ConnectionInterface {
+    readonly options: FrontgateConnectionOptions;
+    readonly clientOptions: Mdg2ClientOptions;
+    readonly auth: AuthenticationInterface;
+    protected logger: LoggerInterface;
+    protected state: ConnectionState;
+    protected compressor: Compressor;
+    protected timestampOfLastMessageSent: number;
+    protected reconnectDelays: number[];
+    protected reconnectCounter: number;
+    protected connectionCounter: number;
+    protected messageReceiveTimeout: ReturnType<typeof setTimeout> | undefined | null;
+    protected pendingConnection: Promise<void> | null;
+    protected hasActiveSession: boolean;
+    static readonly DEFAULT_OPTIONS: FrontgateConnectionOptions;
+    private jobId;
+    private peerInfo;
+    private keepAliveIntervalHandle;
+    private readonly messageProcessors;
+    shouldRestartSubscriptions: boolean;
+    setMessageProcessor(messageName: string, messageProcessor: MessageProcessor): void;
+    removeMessageProcessor(messageName: string): void;
+    protected constructor(auth: AuthenticationInterface, options: Partial<FrontgateConnectionOptions>);
+    abstract open(delayInMs?: number): Promise<void>;
+    abstract send(msg: PtlMessage): JobPromise<PtlMessage>;
+    abstract submit(msg: PtlMessage): Promise<PtlMessage>;
+    close(): Promise<void>;
+    setPeerInfo(peerInfo: PeerInfo): void;
+    isAuthenticated(): boolean;
+    isConnecting(): boolean;
+    onConnect: MaybeVoidFunctionType;
+    onMessage: ((msg: PtlMessage) => void) | null;
+    onClose: ((reason: string | CloseEvent) => void) | null;
+    onError: ((error: Error) => void) | null;
+    onAuthentication: MaybeVoidFunctionType;
+    onCleanupRequests: MaybeVoidFunctionType;
+    onCleanupSubscriptions: MaybeVoidFunctionType;
+    onClearPendingSubscription: ((jobId: number) => void) | null;
+    onReceiveTimeout: MaybeVoidFunctionType;
+    restartSubscriptions: MaybeVoidFunctionType;
+    protected clearPendingConnection(): void;
+    protected isPendingConnection(): boolean;
+    protected handleLoadNotificationMessage(msg: LoadNotificationMessage): boolean;
+    protected handleKeepAliveMessage(): boolean;
+    protected handlePingResponseMessage(msg: any): boolean;
+    protected handleDisconnectionMessage(msg: DisconnectionMessage): Promise<void>;
+    protected handleAuthentication(): void;
+    protected handleReceiveTimeout(): void;
+    protected resetReceiveTimeout(): void;
+    protected handleStandardMessage(msg: PtlMessage): boolean;
+    protected handleMessage(msg: PtlMessage): PtlMessage | undefined;
+    protected handleClose(info: CloseEvent | string): Promise<void>;
+    private reconnect;
+    protected handleWsError(handleWsError: Error): void;
+    protected preSubmit(msg: PtlMessage): number | undefined | null;
+    private sendKeepAliveMessage;
+    private sendDisconnectionMessage;
+    private returnAndAssignJobIdToMessage;
+    setLogger(logger: LoggerInterface): void;
+}

package/dist/lib/types/connection/ConnectionInterface.d.ts

@@ -0,0 +1,53 @@
+import type { AuthenticationInterface } from '../authentication';
+import type { PtlMessage } from '../common/interfaces';
+import type { FrontgateConnectionOptions } from './AbstractFrontgateConnection';
+import type { JobPromise } from './JobPromise';
+import type { Mdg2ClientOptions } from '../common/Mdg2ClientOptions';
+import type { LoggerInterface } from '../logger';
+export type MaybeVoidFunctionType = (() => void) | null;
+export interface PeerInfo {
+    uuid: {
+        id_1: string;
+        id_2: string;
+    };
+    description: string;
+    software: string;
+    os: string;
+    maximumIdleInterval: number;
+    maximumReceivableMessageSize: number;
+    loadStatus?: {
+        capacity: number;
+        idle: number;
+    };
+}
+export interface ServerInfo {
+    description: string;
+    software: string;
+    os: string;
+    time: Date;
+    offsetInMs: number;
+}
+export interface ConnectionInterface {
+    options: FrontgateConnectionOptions;
+    clientOptions: Mdg2ClientOptions;
+    auth: AuthenticationInterface;
+    shouldRestartSubscriptions: boolean;
+    isConnecting: () => boolean;
+    isAuthenticated: () => boolean;
+    open: (delayInMs?: number) => Promise<void>;
+    close: (reconnect?: boolean, logout?: boolean) => Promise<void>;
+    send: (msg: PtlMessage) => JobPromise<PtlMessage>;
+    submit: (msg: PtlMessage) => Promise<PtlMessage>;
+    onConnect: MaybeVoidFunctionType;
+    onMessage: ((msg: PtlMessage) => void) | null;
+    onAuthentication: MaybeVoidFunctionType;
+    onError: ((err: Error) => void) | null;
+    onClose: ((reason: string | CloseEvent) => void) | null;
+    onCleanupRequests: MaybeVoidFunctionType;
+    restartSubscriptions: MaybeVoidFunctionType;
+    onCleanupSubscriptions: MaybeVoidFunctionType;
+    setPeerInfo: (info: PeerInfo) => void;
+    onClearPendingSubscription: ((jobId: number) => void) | null;
+    onReceiveTimeout: MaybeVoidFunctionType;
+    setLogger: (logger: LoggerInterface) => void;
+}

package/dist/lib/types/connection/FrontgateWSConnection.d.ts

@@ -0,0 +1,23 @@
+import type { AuthenticationInterface } from '../authentication';
+import type { PtlMessage } from '../common/interfaces';
+import type { FrontgateConnectionOptions } from './AbstractFrontgateConnection';
+import { AbstractFrontgateConnection } from './AbstractFrontgateConnection';
+import type { ConnectionInterface } from './ConnectionInterface';
+import type { JobPromise } from './JobPromise';
+export declare class FrontgateWSConnection extends AbstractFrontgateConnection implements ConnectionInterface {
+    private ws;
+    private resolveOnMessage;
+    constructor(auth: AuthenticationInterface, options?: Partial<FrontgateConnectionOptions>);
+    private openConnection;
+    private performAuthentication;
+    open(delayInMs?: any): Promise<void>;
+    close(reconnect?: boolean, logout?: boolean): Promise<void>;
+    send(msg: PtlMessage): JobPromise<PtlMessage>;
+    submit(msg: PtlMessage): Promise<PtlMessage>;
+    private sendMessage;
+    private openWebSocket;
+    private onWebSocketMessage;
+    private decodeMessage;
+    private static sanitizeOptions;
+    protected handleWsError(handleWsError: Error): void;
+}

package/dist/lib/types/connection/JobPromise.d.ts

@@ -0,0 +1,3 @@
+export declare class JobPromise<T> extends Promise<T> {
+    idJob?: number;
+}

package/dist/lib/types/connection/LatencyHandler.d.ts

@@ -0,0 +1 @@
+export type LatencyHandler = (timeOfRequest: number | undefined, latencyTotal: number | undefined, latencyAtPeer: number | undefined, message: string | undefined) => void;

package/dist/lib/types/connection/LatencyTracker.d.ts

@@ -0,0 +1,13 @@
+import type { AbstractFrontgateConnection, LatencyHandler } from './index';
+export declare class LatencyTracker {
+    private static readonly MAX_RESPONSE_LATENCY_MS;
+    private readonly cb;
+    private readonly conn;
+    private timeout;
+    private readonly request;
+    private isRequestPending;
+    constructor(cb: LatencyHandler, conn: AbstractFrontgateConnection);
+    start(interval: number): void;
+    stop(): void;
+    private handlePingResponse;
+}

package/dist/lib/types/connection/MessageProcessor.d.ts

@@ -0,0 +1,2 @@
+import type { PtlMessage } from '../common/interfaces/PtlMessage';
+export type MessageProcessor = (msg: PtlMessage) => boolean;

package/dist/lib/types/connection/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ConnectionInterface';
+export * from './AbstractFrontgateConnection';
+export * from './FrontgateWSConnection';
+export * from './util/Encoding';
+export * from './util/functions';
+export * from './LatencyHandler';
+export * from './LatencyTracker';

package/dist/lib/types/connection/util/Compressor.d.ts

@@ -0,0 +1,8 @@
+export declare class Compressor {
+    private compressor;
+    private decompressor;
+    constructor();
+    reset(): void;
+    compress(uncompressedData: string): Uint8Array;
+    decompress(compressedData: Uint8Array): string;
+}

package/dist/lib/types/connection/util/Encoding.d.ts

@@ -0,0 +1,9 @@
+export type SupportedEncoding = 'jsjson-v2' | 'jsjsonc-v2';
+export declare class Encoding {
+    private static readonly SUPPORTED_ENCODINGS;
+    private static readonly PLAIN_JSON_ENCODINGS;
+    private static readonly COMPRESSED_ENCODINGS;
+    static isSupportedEncoding(encoding: SupportedEncoding): boolean;
+    static isPlainJson(encoding: SupportedEncoding): boolean;
+    static isCompressedJson(encoding: SupportedEncoding): boolean;
+}

package/dist/lib/types/connection/util/functions.d.ts

@@ -0,0 +1,19 @@
+import type { ConnectionInterface } from '../ConnectionInterface';
+export declare enum FetchConnectionConfigurationResponseHeaders {
+    FRONTGATE_HOST = "frontgate-host",
+    FRONTGATE_PATH_PREFIX = "frontgate-path-prefix",
+    FRONTGATE_SPLIT_AUTHENTICATION_TOKEN_SECOND_FACTOR = "frontgate-split-authentication-token-second-factor",
+    FRONTGATE_AUTHENTICATION_TYPE = "frontgate-authentication-type",
+    FRONTGATE_AUTHENTICATION_TOKEN = "frontgate-authentication-token",
+    FRONTGATE_WEBSOCKET_PROTOCOL = "frontgate-websocket-protocol"
+}
+export declare function getBytesFromBuffer(buf?: Buffer): number[];
+export declare function parseConnectionConfiguration(headers: Record<string, string>): Record<string, string>;
+export declare function objectFromFetchHeaders(providedHeaders: Headers): Record<string, string>;
+export declare function fetchConnectionConfiguration(input: RequestInfo, init?: RequestInit): Promise<{
+    config: Record<string, string>;
+    response: Response;
+}>;
+export declare function createConnection(options?: Record<string, string>, input?: RequestInfo, init?: RequestInit): ConnectionInterface;
+export declare function setConnectionConfiguration({ frontgateHost, frontgateWebsocketProtocol }: Record<string, string>): void;
+export declare function getConnectionConfiguration(): Record<string, string> | null;