@factset/frontgate-js-sdk 6.9.0

package/dist/lib/types/mixins/auth/FetchAuthenticationMixin.d.ts

@@ -0,0 +1,54 @@
+import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, FrontgateMessage, CalledHooksByAuth, CalledHooksByConnection } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import type { PtlMessage } from '../../common/interfaces/PtlMessage';
+import { LogLevel } from '../../logger';
+export type usedHooksByFetchAuth = CalledHooksByConnection;
+export declare const fetchAuth: (config: FrontgateClientFetchWSConnectionConfig, input: RequestInfo, init?: RequestInit) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByFetchAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        "__#8@#token": string;
+        "__#8@#secondFactor": string;
+        readonly "__#8@#requestInfo": RequestInfo;
+        readonly "__#8@#requestInit": RequestInit | undefined;
+        "__#8@#fetchConnectionConfiguration"(): Promise<{
+            url: string;
+            authtenticationType: string | null;
+            authenticationToken: string | null;
+            splitAuthenticationTokenSecondFactor: string | null;
+        }>;
+        "__#2@#ws": import("ws") | undefined;
+        "__#2@#wsConf": import("../.").InternalFrontgateClientWSConnectionConfig | undefined;
+        "__#2@#wsStateInternal": "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#2@#keepAliveTimer": NodeJS.Timeout | undefined;
+        "__#2@#jobId": number;
+        "__#2@#idApplication": number;
+        "__#2@#idUser": number;
+        readonly "__#2@#wsState": "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#2@#message_buffer_size": number;
+        readonly "__#2@#msgBuffer": FrontgateMessage[];
+        conf: FrontgateClientWSConnectionConfig;
+        connect(): Promise<void>;
+        disconnect(): Promise<void>;
+        "__#2@#getDisconnectMessage"(): import("../..").DisconnectionMessage;
+        "__#2@#getKeepAliveMessage"(): {
+            Message: string;
+            Version: number;
+        };
+        "__#2@#sendMessage"(msg: PtlMessage): Promise<void>;
+        "__#2@#respondToMessage"(msgObj: PtlMessage): void;
+        "__#2@#addJobIdToMessage"(msg: PtlMessage): number;
+        "__#2@#prepareMessage"(msg: PtlMessage): void;
+        "__#2@#createErrorMessage"(error: string, msg: PtlMessage): import("../..").ErrorResponse;
+        "__#2@#applyDefaultsToConfig"(conf: FrontgateClientWSConnectionConfig): import("../.").InternalFrontgateClientWSConnectionConfig;
+        isConnected(): boolean;
+        isDisconnected(): boolean;
+        isReadyToConnect(): boolean;
+        logger: import("../../logger").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<import("../ReconnectMixin").CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<import("../ReconnectMixin").CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase>> & import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;
+export interface FrontgateClientFetchWSConnectionConfig extends FrontgateClientWSConnectionConfig {
+    maximumIdleIntervalInS: number;
+}

package/dist/lib/types/mixins/auth/SessionAuthMixin.d.ts

@@ -0,0 +1,58 @@
+import type { AConstructorTypeOf, Connectable, FrontgateClientWSConnectionConfig, FrontgateMessage, CalledHooksByAuth, CalledHooksByConnection } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import type { PtlMessage } from '../../common/interfaces';
+import { UserPasswordAuthentication } from '../../compat';
+import type { DeploymentStage } from '../../connection';
+import { LogLevel } from '../../logger';
+export type usedHooksBySessionAuth = CalledHooksByConnection;
+export interface SessionConnectable extends Connectable {
+    connectSession: () => Promise<void>;
+    logout: () => Promise<void>;
+}
+export declare const sessionAuth: (config: FrontgateClientWSConnectionConfig, idApplication: number, username: string, password: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksBySessionAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        readonly "__#16@#auth": UserPasswordAuthentication;
+        "__#16@#tokenConnectionAttempt": boolean;
+        "__#16@#logOut": boolean;
+        "__#16@#mdg2wstoken": string | undefined;
+        disconnect: () => Promise<void>;
+        isReadyToConnect: () => boolean;
+        isConnected: () => boolean;
+        isDisconnected: () => boolean;
+        connect(): Promise<void>;
+        connectSession(): Promise<void>;
+        logout(): Promise<void>;
+        "__#16@#requestOtpAuthenticationTokenForSessionHandling"(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<{
+            token: string;
+            expiry: number;
+        }>;
+        "__#16@#toUrlBase64"(strInBase64: string): string;
+        "__#2@#ws": import("ws") | undefined;
+        "__#2@#wsConf": import("../.").InternalFrontgateClientWSConnectionConfig | undefined;
+        "__#2@#wsStateInternal": "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#2@#keepAliveTimer": NodeJS.Timeout | undefined;
+        "__#2@#jobId": number;
+        "__#2@#idApplication": number;
+        "__#2@#idUser": number;
+        readonly "__#2@#wsState": "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#2@#message_buffer_size": number;
+        readonly "__#2@#msgBuffer": FrontgateMessage[];
+        conf: FrontgateClientWSConnectionConfig;
+        "__#2@#getDisconnectMessage"(): import("../../message").DisconnectionMessage;
+        "__#2@#getKeepAliveMessage"(): {
+            Message: string;
+            Version: number;
+        };
+        "__#2@#sendMessage"(msg: PtlMessage): Promise<void>;
+        "__#2@#respondToMessage"(msgObj: PtlMessage): void;
+        "__#2@#addJobIdToMessage"(msg: PtlMessage): number;
+        "__#2@#prepareMessage"(msg: PtlMessage): void;
+        "__#2@#createErrorMessage"(error: string, msg: PtlMessage): import("../../message").ErrorResponse;
+        "__#2@#applyDefaultsToConfig"(conf: FrontgateClientWSConnectionConfig): import("../.").InternalFrontgateClientWSConnectionConfig;
+        logger: import("../../logger").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<import("../ReconnectMixin").CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<import("../ReconnectMixin").CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase>> & import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/auth/TokenAuthMixin.d.ts

@@ -0,0 +1,18 @@
+import { type CalledHooksByAuth, type CalledHooksByConnection, type AConstructorTypeOf } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import { LogLevel } from '../../logger';
+export type usedHooksByTokenAuth = CalledHooksByConnection;
+export interface TokenAuth {
+    token: string;
+}
+export declare const tokenAuth: (token?: string) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByTokenAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        "__#7@#token": string;
+        token: string;
+        logger: import("../../logger").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/auth/UserCredentialAuthMixin.d.ts

@@ -0,0 +1,15 @@
+import { type AConstructorTypeOf, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import type { DeploymentStage } from '../../connection';
+import { UserCredentialAuthentication } from '../../compat';
+export type usedHooksByUserCredentialAuth = CalledHooksByConnection;
+export declare const userCredentialAuth: (idApplication: number, username: string, credentials: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByUserCredentialAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        readonly "__#14@#auth": UserCredentialAuthentication;
+        logger: import("../..").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("../..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/auth/UserPasswordAuthMixin.d.ts

@@ -0,0 +1,15 @@
+import { type AConstructorTypeOf, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import type { DeploymentStage } from '../../connection';
+import { UserPasswordAuthentication } from '../../compat';
+export type usedHooksByUserPasswordAuth = CalledHooksByConnection;
+export declare const userPasswordAuth: (idApplication: number, username: string, password: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByUserPasswordAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        readonly "__#15@#auth": UserPasswordAuthentication;
+        logger: import("../..").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("../..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/auth/index.d.ts

@@ -0,0 +1,16 @@
+import type { ConnectionInterface, DeploymentStage } from '../../connection';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import type { CalledHooksByConnection } from '../connection';
+export * from './CookieTokenAuthMixin';
+export * from './TokenAuthMixin';
+export * from './FetchAuthenticationMixin';
+export interface CalledHooksByAuth {
+    'frontgateConnection:setIdApp': (idApp: number) => void;
+    'frontgateConnection:setIdUser': (idUser: number) => void;
+    'frontgateConnection:authenticated': () => void;
+}
+export declare const createConnectionInterface: (options: {
+    payload_content: string | undefined;
+    deployment_stage: DeploymentStage;
+    maximum_idle_interval: number | undefined;
+}, base: FrontgateClient<CalledHooksByConnection & CalledHooksByAuth & DefaultFrontgateClientHooks>) => ConnectionInterface;

package/dist/lib/types/mixins/connection/FrontgateWSMixin.d.ts

@@ -0,0 +1,67 @@
+import { type CalledHooksByReconnect, type AConstructorTypeOf, type FrontgateMessage, type CalledHooksByAuth, type CalledHooksByConnection } from '../';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import WebSocket from 'isomorphic-ws';
+import type { ClientOptions } from 'ws';
+import { LogLevel } from '../../logger';
+import type { DisconnectionMessage } from '../../message/response/DisconnectionMessage';
+import type { PtlMessage } from '../../common/interfaces';
+import { ErrorResponse } from '../../message';
+export interface FrontgateClientWSConnectionConfig {
+    host: string;
+    port: number;
+    tls?: boolean;
+    pathPrefix?: string;
+    maximumIdleIntervalInS?: number;
+    maximumIdleInterval?: number;
+    payloadContent?: string;
+    wsClientOptions?: ClientOptions;
+    messageBufferSize?: number;
+}
+export interface InternalFrontgateClientWSConnectionConfig {
+    host: string;
+    port: number;
+    tls: boolean;
+    pathPrefix?: string;
+    maximumIdleIntervalInS: number;
+    maximumIdleInterval: number;
+    payloadContent: string;
+    wsClientOptions?: ClientOptions;
+    messageBufferSize: number;
+}
+export type usedHooksByConnection = CalledHooksByReconnect & CalledHooksByAuth;
+export declare const wsConnection: (conf?: FrontgateClientWSConnectionConfig) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByConnection & CalledHooksByReconnect & CalledHooksByConnection & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        "__#2@#ws": WebSocket | undefined;
+        "__#2@#wsConf": InternalFrontgateClientWSConnectionConfig | undefined;
+        "__#2@#wsStateInternal": "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#2@#keepAliveTimer": NodeJS.Timeout | undefined;
+        "__#2@#jobId": number;
+        "__#2@#idApplication": number;
+        "__#2@#idUser": number;
+        readonly "__#2@#wsState": "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#2@#message_buffer_size": number;
+        readonly "__#2@#msgBuffer": FrontgateMessage[];
+        conf: FrontgateClientWSConnectionConfig;
+        connect(): Promise<void>;
+        disconnect(): Promise<void>;
+        "__#2@#getDisconnectMessage"(): DisconnectionMessage;
+        "__#2@#getKeepAliveMessage"(): {
+            Message: string;
+            Version: number;
+        };
+        "__#2@#sendMessage"(msg: PtlMessage): Promise<void>;
+        "__#2@#respondToMessage"(msgObj: PtlMessage): void;
+        "__#2@#addJobIdToMessage"(msg: PtlMessage): number;
+        "__#2@#prepareMessage"(msg: PtlMessage): void;
+        "__#2@#createErrorMessage"(error: string, msg: PtlMessage): ErrorResponse;
+        "__#2@#applyDefaultsToConfig"(conf: FrontgateClientWSConnectionConfig): InternalFrontgateClientWSConnectionConfig;
+        isConnected(): boolean;
+        isDisconnected(): boolean;
+        isReadyToConnect(): boolean;
+        logger: import("../../logger").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,45 @@
+import type { PtlMessage } from '../../common/interfaces';
+import type { DisconnectionMessage } from '../../message';
+import type { CloseEvent } from 'ws';
+import type { FrontgateClientWSConnectionConfig } from './FrontgateWSMixin';
+export * from './FrontgateWSMixin';
+export interface Connectable<Config = FrontgateClientWSConnectionConfig> {
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    isReadyToConnect: () => boolean;
+    isConnected: () => boolean;
+    isDisconnected: () => boolean;
+    conf: Config;
+}
+export interface CalledHooksByConnection {
+    'frontgateConnection:sendMessage': (msg: FrontgateMessage) => void;
+    'frontgateConnection:reset': () => void;
+    'reconnect:success': () => void;
+    'reconnect:failed': (error: CloseEvent) => void;
+    'frontgateConnection:afterSetEncoding': (encoding: {
+        encoding: string;
+    }) => void;
+    'frontgateConnection:beforeConnect': (conf: {
+        url: string;
+        subProtocols: string[];
+    }) => void;
+    'frontgateConnection:connected': (conf: any) => void;
+    'frontgateConnection:error': (err: any) => void;
+    'frontgateConnection:disconnected': (event: DisconnectionMessage | any) => void;
+    'frontgateConnection:beforeSerializeMessage': (msg: PtlMessage) => void;
+    'frontgateConnection:beforeSendMessage': (data: {
+        msg: string;
+    }) => void;
+    'frontgateConnection:afterReceiveMessage': (data: {
+        msg: any;
+    }) => void;
+    'frontgateConnection:message': (msg: PtlMessage) => void;
+    [key: `frontgateConnection:response:${number}`]: (msg: PtlMessage) => void;
+    [key: `frontgateConnection:response:${number}-${number}`]: (msg: PtlMessage) => void;
+    [key: `frontgateConnection:response:${string}`]: (msg: PtlMessage) => void;
+}
+export interface FrontgateMessage {
+    message: PtlMessage;
+    callbackType: 'response' | 'job';
+    callbackId: string;
+}

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

@@ -0,0 +1,28 @@
+export * from './AuthTokenRequestMixin';
+export * from './EndpointRequestMixin';
+export * from './connection';
+export * from './LoggerMixin';
+export * from './MessageCompressorMixin';
+export * from './RequestMixin';
+export * from './subscription';
+export * from './auth';
+export * from './ReconnectMixin';
+export * from './OpenTelemetryMixin';
+export * from './HTTPProxyRequestMixin';
+export type FeatureName = 'AppAuth' | 'CookieTokenAuth' | 'FetchAuth' | 'SessionAuth' | 'TokenAuth' | 'UserCredentialAuth' | 'UserPasswordAuth' | 'WSConnection' | 'TCPConnection' | 'AuthTokenRequest' | 'EndpointRequest' | 'HTTPProxyRequest' | 'Logger' | 'MessageCompressor' | 'OpenTelemetry' | 'Reconnect' | 'Request' | 'EndpointSubscriptions' | 'RawSubscriptions';
+export type FeatureGroup = 'Auth' | 'Connection' | 'Misc';
+export type AConstructorTypeOf<T> = new (...args: any[]) => T;
+export type MixinFactory<TBase, TMixin> = (Base: AConstructorTypeOf<TBase>) => AConstructorTypeOf<TBase & TMixin>;
+export type ExtendedMixinFactory<TBase, TMixin> = ((Base: AConstructorTypeOf<TBase>) => AConstructorTypeOf<TBase & TMixin>) & {
+    featureName?: FeatureName;
+    featureGroups?: FeatureGroup[];
+    disabledFeatures?: FeatureName[];
+    disabledFeatureGroups?: FeatureGroup[];
+};
+export interface ExtendendMixinFactoryOptions {
+    featureName: FeatureName;
+    featureGroups?: FeatureGroup[];
+    disabledFeatures?: FeatureName[];
+    disabledFeatureGroups?: FeatureGroup[];
+}
+export declare const createExtendedMixinFactory: <T>(mixinFactory: T, options: ExtendendMixinFactoryOptions) => T & ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/subscription/DataObserver.d.ts

@@ -0,0 +1,43 @@
+import type { HighLevelResponseData } from '../../message/response';
+import { ErrorResponse } from '../../message/response';
+type Operation = {
+    op: 'add';
+    path: string;
+    value: unknown;
+} | {
+    op: 'remove';
+    path: string;
+} | {
+    op: 'replace';
+    path: string;
+    value: unknown;
+} | {
+    op: 'move';
+    from: string;
+    path: string;
+} | {
+    op: 'copy';
+    from: string;
+    path: string;
+} | {
+    op: 'test';
+    path: string;
+    value: unknown;
+};
+export declare class FrontgateClientDataObserver<ResponseData extends object = object> {
+    #private;
+    idJob: number;
+    get data(): ResponseData;
+    constructor(idJob: number, data: ResponseData);
+    unsubscribe: () => void;
+    subscribe({ next, error }: {
+        next: (data: ResponseData) => void;
+        error?: (error: ErrorResponse) => void;
+    }): void;
+    pushData(data: ResponseData): void;
+    pushError(error: ErrorResponse): void;
+}
+export declare class FrontgateClientEndpointDataObserver<ResponseData extends object = HighLevelResponseData> extends FrontgateClientDataObserver<ResponseData> {
+    pushPatchData(update: Operation[]): void;
+}
+export {};

package/dist/lib/types/mixins/subscription/EndpointSubscriptionMixin.d.ts

@@ -0,0 +1,26 @@
+import { type AConstructorTypeOf, type CalledHooksByConnection, FrontgateClientEndpointDataObserver } from '../';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import { LogLevel } from '../../logger';
+import { type HighLevelRequestMethod, type HighLevelResponseData, type HighLevelRequestOptions } from '../../message';
+export interface EndpointSubscribable {
+    observeEndpoint: (method: HighLevelRequestMethod, path: string, data: Record<string, unknown>, requestOptions?: HighLevelRequestOptions) => Promise<FrontgateClientEndpointDataObserver>;
+}
+export type usedHooksByEndpointSubscribable = CalledHooksByConnection;
+export interface EndpointSubscriptionsConfig {
+    timeout?: number;
+    subscriptionResubscribeTimeout?: number;
+}
+export declare const endpointSubscriptions: (originalConfig?: EndpointSubscriptionsConfig) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByEndpointSubscribable & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        readonly "__#5@#subscriptions": Map<string, {
+            observer: FrontgateClientEndpointDataObserver;
+            count: number;
+        }>;
+        observeEndpoint<ResponseData extends Record<string, any> = Record<string, any>>(method: HighLevelRequestMethod, path: string, data: Record<string, unknown>, requestOptions?: HighLevelRequestOptions): Promise<FrontgateClientEndpointDataObserver<HighLevelResponseData<any>>>;
+        logger: import("../../logger").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/subscription/RawSubscriptionMixin.d.ts

@@ -0,0 +1,27 @@
+import { type AConstructorTypeOf, type CalledHooksByConnection, FrontgateClientDataObserver } from '../';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import type { PtlMessage } from '../../common/interfaces';
+import { LogLevel } from '../../logger';
+import { type AbstractMdg2Request } from '../../message';
+export type ConnectionBasedSubscriptionCancelationRequestConstructor = new (idService: number, idNotation: number) => AbstractMdg2Request;
+export interface RawSubscribable {
+    observe: <ResponseData extends Record<string, any>>(msg: AbstractMdg2Request, timeOutInMs?: number) => Promise<FrontgateClientDataObserver<ResponseData>>;
+    observeConnectionBased: <ResponseData extends Record<string, any>>(msg: AbstractMdg2Request, cancelationRequestConstructor: ConnectionBasedSubscriptionCancelationRequestConstructor, timeOutInMs?: number) => Promise<FrontgateClientDataObserver<ResponseData>>;
+}
+export type usedHooksByRawSubscribable = CalledHooksByConnection;
+export declare const rawSubscriptions: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByRawSubscribable & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        readonly "__#6@#subscriptions": Map<string, {
+            observer: FrontgateClientDataObserver<any>;
+            count: number;
+        }>;
+        observe<ResponseData extends Record<string, any> = PtlMessage>(request: AbstractMdg2Request, timeOutInMs?: number): Promise<FrontgateClientDataObserver<any>>;
+        observeConnectionBased<ResponseData extends Record<string, any> = PtlMessage>(request: AbstractMdg2Request, CancelationRequestConstructor: ConnectionBasedSubscriptionCancelationRequestConstructor, timeOutInMs?: number): Promise<FrontgateClientDataObserver<any>>;
+        "__#6@#rawSubscriptionHelper"<ResponseData extends Record<string, any> = PtlMessage>(request: AbstractMdg2Request, subscriptionType: "job" | "connection", CancelationRequestConstructor: ConnectionBasedSubscriptionCancelationRequestConstructor | undefined, timeOutInMs?: number): Promise<FrontgateClientDataObserver<any>>;
+        logger: import("../../logger").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/subscription/index.d.ts

@@ -0,0 +1,8 @@
+import type { HighLevelRequestMethod } from '../../message/interfaces/HighLevelRequestMethod';
+import type { FrontgateClientEndpointDataObserver } from './DataObserver';
+export * from './EndpointSubscriptionMixin';
+export * from './RawSubscriptionMixin';
+export * from './DataObserver';
+export interface Subscribable {
+    observeEndpoint: <ResponseData extends Record<string, any> = Record<string, any>>(method: HighLevelRequestMethod, path: string, data: Record<string, unknown>) => Promise<FrontgateClientEndpointDataObserver<ResponseData>>;
+}

package/dist/lib/types/util/TimeOutWrapper.d.ts

@@ -0,0 +1,12 @@
+export declare class TimeoutWrapper {
+    _id: number | null;
+    _delay: number | null;
+    static wrap<T>(promise: Promise<T>, delay: number, rejectReason?: string): Promise<T>;
+    constructor();
+    get id(): number | null;
+    get delay(): number | null;
+    set<T>(delay: number, rejectReason?: string): Promise<T>;
+    wrap<T>(promise: Promise<T>, delay: number, rejectReason?: string): Promise<T>;
+    clear(): void;
+    promiseFinally: <T>(promise: Promise<T>, fn: () => void) => Promise<T>;
+}

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

@@ -0,0 +1,20 @@
+import type { SpanContext } from '@opentelemetry/api';
+export interface NavigatorInterface {
+    userAgent: string;
+    platform: string;
+}
+export interface ClientInformation {
+    userAgent: string;
+    platform: string;
+    version: string;
+    package: string;
+    mobile: boolean;
+}
+export declare function getUuid1(): number;
+export declare function getUuid2(): number;
+export declare function getClientInformation(): ClientInformation;
+export declare function getNavigator(): NavigatorInterface;
+export declare const encodeSpanContext: (spanContext: SpanContext) => number[];
+export declare const generateTimeoutPromise: <T>(timeout: number, reason: string) => Promise<T>;
+export declare const useTimeout: <T>(timeout: number, reason: string, promise: Promise<T>) => Promise<T>;
+export declare const addRandomnessToTime: (time: number) => number;

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

@@ -0,0 +1,4 @@
+export declare const PACKAGE_JSON: {
+    version: string;
+    package: string;
+};