@factset/frontgate-js-sdk 7.0.11 → 7.1.1

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

@@ -5,8 +5,10 @@ export declare class SecretGenerator {
     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 generateClientSecret(username: string, password: string): string;
+    static generateClientSecret(username: string, password: string, callback: (err: Error | null, encrypted: string | undefined) => void): undefined;
+    static generateSharedSecret(username: string, password: string): string;
+    static generateSharedSecret(username: string, password: string, callback: (err: Error | null, encrypted: string | undefined) => void): undefined;
     static getEncryptionKey(salt: Buffer, secret: Buffer): Buffer;
     private static generateSalt;
     private static create128bitSeed;

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

@@ -9,17 +9,4 @@ export interface AuthTokenRequestable {
     requestAuthenticationTokenForCookieTokenAuthentication: (lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number) => Promise<CookieTokenAuthenticationFactors>;
 }
 export type usedHooksByAuthTokenRequest = CalledHooksByConnection;
-export declare const authTokenRequest: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByAuthTokenRequest & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        requestAuthenticationToken(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<{
-            token: string;
-            expiry: number;
-        }>;
-        requestAuthenticationTokenForCookieTokenAuthentication(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<CookieTokenAuthenticationFactors>;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const authTokenRequest: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByAuthTokenRequest & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<AuthTokenRequestable>) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,6 +1,6 @@
 import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
-import type { HighLevelRequestResult, PtlMessage } from '../common/interfaces';
+import type { HighLevelRequestResult } from '../common/interfaces';
 import { type HighLevelRequestMethod, type HighLevelRequestOptions } from '../message';
 export interface EndpointRequestable {
     requestEndpoint: <ResponseData = any>(method: HighLevelRequestMethod, path: string, data?: Record<string, unknown>, options?: HighLevelRequestOptions, timeOutInMs?: number) => Promise<HighLevelRequestResult<ResponseData>>;
@@ -10,14 +10,4 @@ export interface EndpointRequestMixinOptions {
     disableChunkedResponse?: boolean;
     allowPermissionDeniedResponse?: boolean;
 }
-export declare const endpointRequest: (config?: EndpointRequestMixinOptions) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByEndpointRequest & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        requestEndpoint<ResponseData = any>(method: HighLevelRequestMethod, path: string, data?: Record<string, unknown>, options?: HighLevelRequestOptions, timeOutInMs?: number): Promise<HighLevelRequestResult<ResponseData>>;
-        "__#private@#hasNextChunk"(msg: PtlMessage): boolean;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const endpointRequest: (config?: EndpointRequestMixinOptions) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByEndpointRequest & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<EndpointRequestable>) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,18 +1,9 @@
 import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
 import type { HTTPProxyRequestResult } from '../common/interfaces/result/HTTPProxyRequestResult';
-import type { HTTPProxyRequestBody, HTTPMethod, HTTPProxyRequestOptions } from '../message';
+import type { HTTPMethod, HTTPProxyRequestOptions } from '../message';
 export interface HTTPProxyRequestable {
     requestProxyEndpoint: (method: HTTPMethod, path: string, body?: Record<string, unknown>, options?: HTTPProxyRequestOptions, timeOutInMs?: number) => Promise<HTTPProxyRequestResult>;
 }
 export type usedHooksByHTTPProxyRequest = CalledHooksByConnection;
-export declare const httpProxyRequest: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByHTTPProxyRequest & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        requestProxyEndpoint(method: HTTPMethod, path: string, body?: HTTPProxyRequestBody, options?: HTTPProxyRequestOptions, timeOutInMs?: number): Promise<HTTPProxyRequestResult>;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const httpProxyRequest: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByHTTPProxyRequest & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<HTTPProxyRequestable>) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,12 +1,4 @@
 import { type AConstructorTypeOf } from '.';
 import type { FrontgateClient } from '../FrontgateClient';
 import type { LogLevel, LoggerInterface } from '../logger';
-export declare const logger: (loggerInstance: LoggerInterface, logLevel?: LogLevel) => (<T extends AConstructorTypeOf<FrontgateClient>>(Base: T) => {
-    new (...args: any[]): {
-        logger: LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<import("../FrontgateClient").CalledHooksByBase, "base:log">;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const logger: (loggerInstance: LoggerInterface, logLevel?: LogLevel) => (<T extends AConstructorTypeOf<FrontgateClient>>(Base: T) => typeof Base) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,14 +1,4 @@
 import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
-import { Compressor } from '../connection/util/Compressor';
 export type usedHooksByMessageCompressor = CalledHooksByConnection;
-export declare const messageCompressor: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByMessageCompressor & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        readonly "__#private@#compressor": Compressor;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const messageCompressor: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByMessageCompressor & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,20 +1,5 @@
 import { type SpanContext } from '@opentelemetry/api';
 import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
-export declare const openTelemetry: () => (<T extends AConstructorTypeOf<FrontgateClient<CalledHooksByConnection & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        "__#private@#createSpanHeader"(tracing: SpanContext): {
-            tracing: {
-                value: {
-                    value: number[];
-                };
-            };
-        } | undefined;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const openTelemetry: () => (<T extends AConstructorTypeOf<FrontgateClient<CalledHooksByConnection & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import(".").ExtendendMixinFactoryOptions;
 export declare const encodeSpanContext: (spanContext: SpanContext) => number[];

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

@@ -5,13 +5,4 @@ export interface Pingable {
     ping: (timeOutInMs?: number) => Promise<PingResponse>;
 }
 export type usedHooksByPingRequest = CalledHooksByConnection;
-export declare const pingRequests: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByPingRequest & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        ping(timeOutInMs?: number): Promise<PingResponse>;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const pingRequests: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByPingRequest & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<Pingable>) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,22 +1,10 @@
 import type { CloseEvent } from 'ws';
 import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
-import { LogLevel } from '../logger';
 export type usedHooksByReconnect = CalledHooksByConnection;
 export interface CalledHooksByReconnect {
     'reconnect:attempt': (error: CloseEvent) => void;
     'reconnect:failed': (error: CloseEvent) => void;
     'reconnect:success': () => void;
 }
-export declare const reconnect: (reconnectDelaysInMs?: number[]) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByReconnect & CalledHooksByReconnect & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        "__#private@#reconnectAttempts": number;
-        readonly "__#private@#reconnectDelays": number[];
-        "__#private@#reconnectTimer": NodeJS.Timeout | undefined;
-        logger: import("../logger").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByReconnect & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByReconnect & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const reconnect: (reconnectDelaysInMs?: number[]) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByReconnect & CalledHooksByReconnect & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import(".").ExtendendMixinFactoryOptions;

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

@@ -4,13 +4,4 @@ export interface RemoteLoggable {
     logRemotely: (msg: string) => Promise<void>;
 }
 export type usedHooksByRemoteLogger = CalledHooksByConnection;
-export declare const remotelogger: (identifier?: number) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByRemoteLogger & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        logRemotely(message: string): Promise<any>;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const remotelogger: (identifier?: number) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByRemoteLogger & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<RemoteLoggable>) & import(".").ExtendendMixinFactoryOptions;

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

@@ -5,13 +5,4 @@ export interface Requestable {
     request: (msg: AbstractMdg2Request, timeOutInMs?: number) => Promise<Mdg2Response>;
 }
 export type usedHooksByRequest = CalledHooksByConnection;
-export declare const requests: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByRequest & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        request(request: AbstractMdg2Request, timeOutInMs?: number): Promise<Mdg2Response>;
-        logger: import("..").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: import("..").LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const requests: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByRequest & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<Requestable>) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,23 +1,5 @@
-import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, CalledHooksByAuth, CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, CalledHooksByAuth, CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
-import type { PtlMessage } from '../../common/interfaces';
-import { AuthenticationRequest, ConfigurationRequest } from '../../compat';
 import { type DeploymentStage } from '../../connection';
-import { LogLevel } from '../../logger';
-import type { AuthenticationResponse } from '../../message/response/AuthenticationResponse';
 export type usedHooksByAppAuth = CalledHooksByConnection;
-export declare const appAuth: (idApplication: number, idUser: number, clientCredentials: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByAppAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        readonly "__#private@#sharedSecret": Buffer;
-        readonly "__#private@#clientSecret": Buffer;
-        "__#private@#createAuthenticationRequest"(): AuthenticationRequest;
-        "__#private@#createConfigurationRequest"(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
-        "__#private@#createTransportLayerRequestHeaderConfigurationRequest"(): PtlMessage;
-        "__#private@#submit"<M extends PtlMessage>(message: PtlMessage): Promise<M>;
-        logger: import("../../logger").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import("../.").ExtendendMixinFactoryOptions;
+export declare const appAuth: (idApplication: number, idUser: number, clientCredentials: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByAppAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,13 +1,4 @@
 import { type AConstructorTypeOf, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
-import { LogLevel } from '../../logger';
 export type usedHooksByCookieTokenAuth = CalledHooksByConnection;
-export declare const cookieTokenAuth: (secondFactor: string) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByCookieTokenAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
-    new (...args: any[]): {
-        logger: import("../../logger").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import("../.").ExtendendMixinFactoryOptions;
+export declare const cookieTokenAuth: (secondFactor: string) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByCookieTokenAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,54 +1,7 @@
-import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, FrontgateMessage, CalledHooksByAuth, CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, 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[]): {
-        "__#private@#token": string;
-        "__#private@#secondFactor": string;
-        readonly "__#private@#requestInfo": RequestInfo;
-        readonly "__#private@#requestInit": RequestInit | undefined;
-        "__#private@#fetchConnectionConfiguration"(): Promise<{
-            url: string;
-            authtenticationType: string | null;
-            authenticationToken: string | null;
-            splitAuthenticationTokenSecondFactor: string | null;
-        }>;
-        "__#private@#ws": import("ws") | undefined;
-        "__#private@#wsConf": import("../.").InternalFrontgateClientWSConnectionConfig | undefined;
-        "__#private@#wsStateInternal": "connecting" | "connected" | "authenticated" | "disconnected";
-        "__#private@#keepAliveTimer": NodeJS.Timeout | undefined;
-        "__#private@#jobId": number;
-        "__#private@#idApplication": number;
-        "__#private@#idUser": number;
-        get "__#private@#wsState"(): "connecting" | "connected" | "authenticated" | "disconnected";
-        "__#private@#message_buffer_size": number;
-        readonly "__#private@#msgBuffer": FrontgateMessage[];
-        set conf(newConf: FrontgateClientWSConnectionConfig);
-        connect(): Promise<void>;
-        disconnect(): Promise<void>;
-        "__#private@#getDisconnectMessage"(): import("../..").DisconnectionMessage;
-        "__#private@#getKeepAliveMessage"(): {
-            Message: string;
-            Version: number;
-        };
-        "__#private@#sendMessage"(msg: PtlMessage): Promise<void>;
-        "__#private@#respondToMessage"(msgObj: PtlMessage): void;
-        "__#private@#addJobIdToMessage"(msg: PtlMessage): number;
-        "__#private@#prepareMessage"(msg: PtlMessage): void;
-        "__#private@#createErrorMessage"(error: string, msg: PtlMessage): import("../..").ErrorResponse;
-        "__#private@#applyDefaultsToConfig"(oldConf: 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>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
-    };
-} & T) & import("../.").ExtendendMixinFactoryOptions;
+export declare const fetchAuth: (config: FrontgateClientFetchWSConnectionConfig, input: RequestInfo, init?: RequestInit) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByFetchAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import("../.").ExtendendMixinFactoryOptions;
 export interface FrontgateClientFetchWSConnectionConfig {
     maximumIdleIntervalInS: number;
     [key: string]: unknown;

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

@@ -0,0 +1,4 @@
+import type { AConstructorTypeOf, CalledHooksByAuth, CalledHooksByConnection, FrontgateClientFetchWSConnectionConfig } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+export type usedHooksByFetchAuthWithOptionalCompressor = CalledHooksByConnection;
+export declare const fetchAuthWithOptionalCompressor: (config: FrontgateClientFetchWSConnectionConfig, input: RequestInfo, init?: RequestInit) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByFetchAuthWithOptionalCompressor & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,64 +1,9 @@
-import type { AConstructorTypeOf, Connectable, FrontgateClientWSConnectionConfig, FrontgateMessage, CalledHooksByAuth, CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, Connectable, FrontgateClientWSConnectionConfig, CalledHooksByAuth, CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
-import type { PtlMessage } from '../../common/interfaces';
-import { AuthenticationRequest, ConfigurationRequest } from '../../compat';
 import { type DeploymentStage } from '../../connection';
-import { LogLevel } from '../../logger';
-import type { AuthenticationResponse } from '../../message/response/AuthenticationResponse';
 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[]): {
-        "__#private@#tokenConnectionAttempt": boolean;
-        "__#private@#logOut": boolean;
-        "__#private@#mdg2wstoken": string | undefined;
-        readonly "__#private@#sharedSecret": Buffer;
-        readonly "__#private@#clientSecret": Buffer;
-        disconnect: () => Promise<void>;
-        isReadyToConnect: () => boolean;
-        isConnected: () => boolean;
-        isDisconnected: () => boolean;
-        connect(): Promise<void>;
-        connectSession(): Promise<void>;
-        logout(): Promise<void>;
-        "__#private@#requestOtpAuthenticationTokenForSessionHandling"(lifetimeSeconds?: number, idUser?: number, idApplicationOtp?: number, timeOutInMs?: number): Promise<{
-            token: string;
-            expiry: number;
-        }>;
-        "__#private@#toUrlBase64"(strInBase64: string): string;
-        "__#private@#createAuthenticationRequest"(): AuthenticationRequest;
-        "__#private@#createConfigurationRequest"(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
-        "__#private@#createTransportLayerRequestHeaderConfigurationRequest"(): PtlMessage;
-        "__#private@#submit"<M extends PtlMessage>(message: PtlMessage): Promise<M>;
-        "__#private@#ws": import("ws") | undefined;
-        "__#private@#wsConf": import("../.").InternalFrontgateClientWSConnectionConfig | undefined;
-        "__#private@#wsStateInternal": "connecting" | "connected" | "authenticated" | "disconnected";
-        "__#private@#keepAliveTimer": NodeJS.Timeout | undefined;
-        "__#private@#jobId": number;
-        "__#private@#idApplication": number;
-        "__#private@#idUser": number;
-        get "__#private@#wsState"(): "connecting" | "connected" | "authenticated" | "disconnected";
-        "__#private@#message_buffer_size": number;
-        readonly "__#private@#msgBuffer": FrontgateMessage[];
-        set conf(newConf: FrontgateClientWSConnectionConfig);
-        "__#private@#getDisconnectMessage"(): import("../../message").DisconnectionMessage;
-        "__#private@#getKeepAliveMessage"(): {
-            Message: string;
-            Version: number;
-        };
-        "__#private@#sendMessage"(msg: PtlMessage): Promise<void>;
-        "__#private@#respondToMessage"(msgObj: PtlMessage): void;
-        "__#private@#addJobIdToMessage"(msg: PtlMessage): number;
-        "__#private@#prepareMessage"(msg: PtlMessage): void;
-        "__#private@#createErrorMessage"(error: string, msg: PtlMessage): import("../../message").ErrorResponse;
-        "__#private@#applyDefaultsToConfig"(oldConf: 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>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
-    };
-} & T) & import("../.").ExtendendMixinFactoryOptions;
+export declare const sessionAuth: (config: FrontgateClientWSConnectionConfig, idApplication: number, username: string, password: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksBySessionAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<SessionConnectable>) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,18 +1,7 @@
 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[]): {
-        "__#private@#token": string;
-        set token(newToken: string);
-        logger: import("../../logger").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import("../.").ExtendendMixinFactoryOptions;
+export declare const tokenAuth: (token?: string) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByTokenAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<TokenAuth>) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,23 +1,5 @@
-import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, CalledHooksByAuth, CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, CalledHooksByAuth, CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
 import { type DeploymentStage } from '../../connection';
-import { AuthenticationRequest, ConfigurationRequest } from '../../compat';
-import type { PtlMessage } from '../../common/interfaces';
-import { LogLevel } from '../../logger';
-import type { AuthenticationResponse } from '../../message/response/AuthenticationResponse';
 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 "__#private@#sharedSecret": Buffer;
-        readonly "__#private@#clientSecret": Buffer;
-        "__#private@#createAuthenticationRequest"(): AuthenticationRequest;
-        "__#private@#createConfigurationRequest"(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
-        "__#private@#createTransportLayerRequestHeaderConfigurationRequest"(): PtlMessage;
-        "__#private@#submit"<M extends PtlMessage>(message: PtlMessage): Promise<M>;
-        logger: import("../../logger").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import("../.").ExtendendMixinFactoryOptions;
+export declare const userCredentialAuth: (idApplication: number, username: string, credentials: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByUserCredentialAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,23 +1,5 @@
-import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, CalledHooksByAuth, CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, CalledHooksByAuth, CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
 import { type DeploymentStage } from '../../connection';
-import { AuthenticationRequest, ConfigurationRequest } from '../../compat';
-import type { PtlMessage } from '../../common/interfaces';
-import { LogLevel } from '../../logger';
-import type { AuthenticationResponse } from '../../message/response/AuthenticationResponse';
 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 "__#private@#sharedSecret": Buffer;
-        readonly "__#private@#clientSecret": Buffer;
-        "__#private@#createAuthenticationRequest"(): AuthenticationRequest;
-        "__#private@#createConfigurationRequest"(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
-        "__#private@#createTransportLayerRequestHeaderConfigurationRequest"(): PtlMessage;
-        "__#private@#submit"<M extends PtlMessage>(message: PtlMessage): Promise<M>;
-        logger: import("../../logger").LoggerInterface | undefined;
-        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import("../.").ExtendendMixinFactoryOptions;
+export declare const userPasswordAuth: (idApplication: number, username: string, password: string, deploymentStage: DeploymentStage) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByUserPasswordAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,6 +1,7 @@
 export * from './CookieTokenAuthMixin';
 export * from './TokenAuthMixin';
 export * from './FetchAuthenticationMixin';
+export * from './FetchAuthenticationWithOptionalCompressionMixin';
 export interface CalledHooksByAuth {
     'frontgateConnection:setIdApp': (idApp: number) => void;
     'frontgateConnection:setIdUser': (idUser: number) => void;

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

@@ -1,11 +1,6 @@
-import { type CalledHooksByReconnect, type AConstructorTypeOf, type FrontgateMessage, type CalledHooksByAuth, type CalledHooksByConnection } from '../';
+import { type CalledHooksByReconnect, type AConstructorTypeOf, type Connectable, 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;
@@ -29,39 +24,4 @@ export interface InternalFrontgateClientWSConnectionConfig {
     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[]): {
-        "__#private@#ws": WebSocket | undefined;
-        "__#private@#wsConf": InternalFrontgateClientWSConnectionConfig | undefined;
-        "__#private@#wsStateInternal": "connecting" | "connected" | "authenticated" | "disconnected";
-        "__#private@#keepAliveTimer": NodeJS.Timeout | undefined;
-        "__#private@#jobId": number;
-        "__#private@#idApplication": number;
-        "__#private@#idUser": number;
-        get "__#private@#wsState"(): "connecting" | "connected" | "authenticated" | "disconnected";
-        "__#private@#message_buffer_size": number;
-        readonly "__#private@#msgBuffer": FrontgateMessage[];
-        set conf(newConf: FrontgateClientWSConnectionConfig);
-        connect(): Promise<void>;
-        disconnect(): Promise<void>;
-        "__#private@#getDisconnectMessage"(): DisconnectionMessage;
-        "__#private@#getKeepAliveMessage"(): {
-            Message: string;
-            Version: number;
-        };
-        "__#private@#sendMessage"(msg: PtlMessage): Promise<void>;
-        "__#private@#respondToMessage"(msgObj: PtlMessage): void;
-        "__#private@#addJobIdToMessage"(msg: PtlMessage): number;
-        "__#private@#prepareMessage"(msg: PtlMessage): void;
-        "__#private@#createErrorMessage"(error: string, msg: PtlMessage): ErrorResponse;
-        "__#private@#applyDefaultsToConfig"(oldConf: 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>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import("../").ExtendendMixinFactoryOptions;
+export declare const wsConnection: (conf?: FrontgateClientWSConnectionConfig) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByConnection & CalledHooksByReconnect & CalledHooksByConnection & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<Connectable>) & import("../").ExtendendMixinFactoryOptions;

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

@@ -8,7 +8,7 @@ export interface Connectable<Config = FrontgateClientWSConnectionConfig> {
     isReadyToConnect: () => boolean;
     isConnected: () => boolean;
     isDisconnected: () => boolean;
-    conf: Config;
+    conf?: Config;
 }
 export interface CalledHooksByConnection {
     'frontgateConnection:sendMessage': (msg: FrontgateMessage) => void;

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

@@ -11,8 +11,8 @@ export * from './OpenTelemetryMixin';
 export * from './HTTPProxyRequestMixin';
 export * from './PingMixin';
 export * from './RemoteLoggerMixin';
-export type FeatureName = 'AppAuth' | 'CookieTokenAuth' | 'FetchAuth' | 'SessionAuth' | 'TokenAuth' | 'UserCredentialAuth' | 'UserPasswordAuth' | 'WSConnection' | 'TCPConnection' | 'AuthTokenRequest' | 'EndpointRequest' | 'HTTPProxyRequest' | 'Logger' | 'MessageCompressor' | 'OpenTelemetry' | 'Reconnect' | 'Request' | 'EndpointSubscriptions' | 'Pingable' | 'RawSubscriptions' | 'RemoteLogger' | 'Custom';
-export type FeatureGroup = 'Auth' | 'Connection' | 'Misc';
+export type FeatureName = 'AppAuth' | 'CookieTokenAuth' | 'FetchAuth' | 'SessionAuth' | 'TokenAuth' | 'UserCredentialAuth' | 'UserPasswordAuth' | 'WSConnection' | 'TCPConnection' | 'AuthTokenRequest' | 'EndpointRequest' | 'HTTPProxyRequest' | 'Logger' | 'MessageCompressor' | 'OpenTelemetry' | 'Reconnect' | 'Request' | 'EndpointSubscriptions' | 'Pingable' | 'RawSubscriptions' | 'RemoteLogger' | 'FetchAuthWithOptionalCompressor' | 'Custom';
+export type FeatureGroup = 'Auth' | 'Connection' | 'Compression' | '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>) & {

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

@@ -29,7 +29,7 @@ export declare class FrontgateClientDataObserver<ResponseData extends object = o
     idJob: number;
     get data(): ResponseData;
     constructor(idJob: number, data: ResponseData);
-    unsubscribe: () => void;
+    unsubscribe: (() => void) | undefined;
     subscribe({ next, error }: {
         next: (data: ResponseData) => void;
         error?: (error: ErrorResponse) => void;

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

@@ -1,7 +1,6 @@
 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';
+import { type HighLevelRequestMethod, type HighLevelRequestOptions } from '../../message';
 export interface EndpointSubscribable {
     observeEndpoint: (method: HighLevelRequestMethod, path: string, data: Record<string, unknown>, requestOptions?: HighLevelRequestOptions) => Promise<FrontgateClientEndpointDataObserver>;
 }
@@ -10,16 +9,4 @@ 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 "__#private@#subscriptions": Map<string, FrontgateClientEndpointDataObserver>;
-        readonly "__#private@#subscriptionCounts": Map<string, number>;
-        readonly "__#private@#inFlights": Map<string, Promise<FrontgateClientEndpointDataObserver<HighLevelResponseData<unknown>>>>;
-        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>>;
-        readonly "__#private@#defaultTimeoutInMs": number;
-        get defaultTimeoutInMs(): number;
-        log(level: LogLevel, ...args: unknown[]): void;
-    };
-} & T) & import("../").ExtendendMixinFactoryOptions;
+export declare const endpointSubscriptions: (originalConfig?: EndpointSubscriptionsConfig) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByEndpointSubscribable & DefaultFrontgateClientHooks>>>(Base: T) => typeof Base & AConstructorTypeOf<EndpointSubscribable>) & import("../").ExtendendMixinFactoryOptions;