@factset/frontgate-js-sdk 6.11.1 → 7.0.1

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

@@ -1,19 +1 @@
-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;

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

@@ -5,6 +5,5 @@ export * from './common/interfaces';
 export * from './common/types';
 export * from './logger';
 export * from './mixins';
-export { Mdg2Client } from './Mdg2Client';
 export { FrontgateClientBuilder, FrontgateClient, type DefaultFrontgateClientHooks } from './FrontgateClient';
 export { useTimeout } from './util/functions';

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

@@ -1,6 +1,6 @@
-export * from './guards';
 export * from './types';
 export * from './interfaces';
 export * from './request';
 export * from './response';
 export * from './update';
+export declare const FLAG_HAS_NEXT_CHUNK = 8;

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

@@ -1,4 +1,3 @@
 export * from './HighLevelRequestMethod';
 export * from './HighLevelRequestOptions';
 export * from './HTTPProxyRequestOptions';
-export * from './JobObservable';

package/dist/lib/types/message/request/TransportLayerClientRequestHeader.d.ts

@@ -1,6 +1,7 @@
 import type { Quality } from '../../common/types';
 import type { TransportLayerClientRequestHeaderFlag } from '../types';
 import { type SpanContext } from '@opentelemetry/api';
+export declare const DEFAULT_TIMEOUT_IN_MS = 6000;
 export interface PtlTransportLayerClientRequestHeader {
     dataset: {
         id_dataset: number;

package/dist/lib/types/message/request/raw/index.d.ts

@@ -1,2 +1 @@
-export * from './RawRequestFactory';
 export * from './RawRequest';

package/dist/lib/types/message/response/index.d.ts

@@ -1,13 +1,8 @@
 export * from './AuthenticationTokenResponse';
-export * from './AuthenticationByTokenResponse';
-export * from './CancelSubscriptionResponse';
 export * from './ConfigurationResponse';
 export * from './DisconnectionMessage';
 export * from './ErrorResponse';
 export * from './HighLevelResponse';
 export * from './HTTPProxyResponse';
-export * from './LoadNotificationMessage';
 export * from './Mdg2Response';
-export * from './PermissionDeniedResponse';
 export * from './PingResponse';
-export * from './RejectResponse';

package/dist/lib/types/message/update/index.d.ts

@@ -1,2 +1 @@
 export * from './HighLevelUpdate';
-export * from './SubscriptionLossMessage';

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

@@ -18,9 +18,8 @@ export declare const authTokenRequest: () => (<T extends AConstructorTypeOf<Fron
         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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -16,9 +16,8 @@ export declare const endpointRequest: (config?: EndpointRequestMixinOptions) =>
         #hasNextChunk(msg: PtlMessage): boolean;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -3,8 +3,6 @@ import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateC
 import type { HTTPProxyRequestResult } from '../common/interfaces/result/HTTPProxyRequestResult';
 import type { HTTPProxyRequestBody } from '../message';
 import { type HTTPMethod, type HTTPProxyRequestOptions } from '../message';
-export interface HTTProxyRequestable extends HTTPProxyRequestable {
-}
 export interface HTTPProxyRequestable {
     requestProxyEndpoint: (method: HTTPMethod, path: string, body?: Record<string, unknown>, options?: HTTPProxyRequestOptions, timeOutInMs?: number) => Promise<HTTPProxyRequestResult>;
 }
@@ -14,9 +12,8 @@ export declare const httpProxyRequest: () => (<T extends AConstructorTypeOf<Fron
         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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -5,9 +5,8 @@ export declare const logger: (logger: LoggerInterface, logLevel?: LogLevel) => (
     new (...args: any[]): {
         logger: LoggerInterface | undefined;
         hooks: import("hookable").Hookable<import("../FrontgateClient").CalledHooksByBase, "base:log">;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -7,9 +7,8 @@ export declare const messageCompressor: () => (<T extends AConstructorTypeOf<Fro
         readonly #compressor: Compressor;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -12,9 +12,8 @@ export declare const openTelemetry: () => (<T extends AConstructorTypeOf<Frontga
         } | undefined;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -10,9 +10,8 @@ export declare const pingRequests: () => (<T extends AConstructorTypeOf<Frontgat
         ping(timeOutInMs?: number): Promise<PingResponse>;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -15,9 +15,8 @@ export declare const reconnect: (reconnectDelaysInMs?: number[]) => (<T extends
         #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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,16 @@
+import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
+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 #defaultTimeoutInMs: number;
+        get defaultTimeoutInMs(): number;
+        log(level: import("..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -10,9 +10,8 @@ export declare const requests: () => (<T extends AConstructorTypeOf<FrontgateCli
         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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };
 } & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -1,16 +1,23 @@
-import { type AConstructorTypeOf, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import { type AConstructorTypeOf, type FrontgateClientWSConnectionConfig, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
-import { AppAuthentication } from '../../authentication/AppAuthentication';
-import type { DeploymentStage } from '../../connection';
+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 #auth: AppAuthentication;
-        logger: import("../..").LoggerInterface | undefined;
+        readonly #sharedSecret: Buffer;
+        readonly #clientSecret: Buffer;
+        #createAuthenticationRequest(): AuthenticationRequest;
+        #createConfigurationRequest(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
+        #createTransportLayerRequestHeaderConfigurationRequest(): PtlMessage;
+        #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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
-        log(level: import("../..").LogLevel, ...args: unknown[]): void;
+        log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -6,9 +6,8 @@ export declare const cookieTokenAuth: (secondFactor: string) => (<T extends ACon
     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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -44,9 +44,8 @@ export declare const fetchAuth: (config: FrontgateClientFetchWSConnectionConfig,
         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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
     };
 } & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,9 +1,10 @@
 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 { 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>;
@@ -11,10 +12,11 @@ export interface SessionConnectable extends Connectable {
 }
 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 #auth: UserPasswordAuthentication;
         #tokenConnectionAttempt: boolean;
         #logOut: boolean;
         #mdg2wstoken: string | undefined;
+        readonly #sharedSecret: Buffer;
+        readonly #clientSecret: Buffer;
         disconnect: () => Promise<void>;
         isReadyToConnect: () => boolean;
         isConnected: () => boolean;
@@ -27,6 +29,10 @@ export declare const sessionAuth: (config: FrontgateClientWSConnectionConfig, id
             expiry: number;
         }>;
         #toUrlBase64(strInBase64: string): string;
+        #createAuthenticationRequest(): AuthenticationRequest;
+        #createConfigurationRequest(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
+        #createTransportLayerRequestHeaderConfigurationRequest(): PtlMessage;
+        #submit<M extends PtlMessage>(message: PtlMessage): Promise<M>;
         #ws: import("ws") | undefined;
         #wsConf: import("../.").InternalFrontgateClientWSConnectionConfig | undefined;
         #wsStateInternal: "connecting" | "connected" | "authenticated" | "disconnected";
@@ -51,9 +57,8 @@ export declare const sessionAuth: (config: FrontgateClientWSConnectionConfig, id
         #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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
     };
 } & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -11,9 +11,8 @@ export declare const tokenAuth: (token?: string) => (<T extends AConstructorType
         set token(token: string);
         logger: import("../../logger").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,16 +1,23 @@
-import { type AConstructorTypeOf, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import { type AConstructorTypeOf, type FrontgateClientWSConnectionConfig, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
-import type { DeploymentStage } from '../../connection';
-import { UserCredentialAuthentication } from '../../compat';
+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 #auth: UserCredentialAuthentication;
-        logger: import("../..").LoggerInterface | undefined;
+        readonly #sharedSecret: Buffer;
+        readonly #clientSecret: Buffer;
+        #createAuthenticationRequest(): AuthenticationRequest;
+        #createConfigurationRequest(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
+        #createTransportLayerRequestHeaderConfigurationRequest(): PtlMessage;
+        #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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
-        log(level: import("../..").LogLevel, ...args: unknown[]): void;
+        log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,16 +1,23 @@
-import { type AConstructorTypeOf, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import { type AConstructorTypeOf, type FrontgateClientWSConnectionConfig, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
-import type { DeploymentStage } from '../../connection';
-import { UserPasswordAuthentication } from '../../compat';
+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 #auth: UserPasswordAuthentication;
-        logger: import("../..").LoggerInterface | undefined;
+        readonly #sharedSecret: Buffer;
+        readonly #clientSecret: Buffer;
+        #createAuthenticationRequest(): AuthenticationRequest;
+        #createConfigurationRequest(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
+        #createTransportLayerRequestHeaderConfigurationRequest(): PtlMessage;
+        #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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
-        log(level: import("../..").LogLevel, ...args: unknown[]): void;
+        log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -1,6 +1,3 @@
-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';
@@ -9,8 +6,3 @@ export interface CalledHooksByAuth {
     '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

@@ -60,9 +60,8 @@ export declare const wsConnection: (conf?: FrontgateClientWSConnectionConfig) =>
         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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../").ExtendendMixinFactoryOptions;

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

@@ -10,7 +10,8 @@ export * from './ReconnectMixin';
 export * from './OpenTelemetryMixin';
 export * from './HTTPProxyRequestMixin';
 export * from './PingMixin';
-export type FeatureName = 'AppAuth' | 'CookieTokenAuth' | 'FetchAuth' | 'SessionAuth' | 'TokenAuth' | 'UserCredentialAuth' | 'UserPasswordAuth' | 'WSConnection' | 'TCPConnection' | 'AuthTokenRequest' | 'EndpointRequest' | 'HTTPProxyRequest' | 'Logger' | 'MessageCompressor' | 'OpenTelemetry' | 'Reconnect' | 'Request' | 'EndpointSubscriptions' | 'Pingable' | 'RawSubscriptions' | 'Custom';
+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 AConstructorTypeOf<T> = new (...args: any[]) => T;
 export type MixinFactory<TBase, TMixin> = (Base: AConstructorTypeOf<TBase>) => AConstructorTypeOf<TBase & TMixin>;

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

@@ -12,16 +12,14 @@ export interface EndpointSubscriptionsConfig {
 }
 export declare const endpointSubscriptions: (originalConfig?: EndpointSubscriptionsConfig) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByEndpointSubscribable & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        readonly #subscriptions: Map<string, {
-            observer: FrontgateClientEndpointDataObserver;
-            count: number;
-        }>;
+        readonly #subscriptions: Map<string, FrontgateClientEndpointDataObserver>;
+        readonly #subscriptionCounts: Map<string, number>;
+        readonly #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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../").ExtendendMixinFactoryOptions;

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

@@ -20,9 +20,8 @@ export declare const rawSubscriptions: () => (<T extends AConstructorTypeOf<Fron
         #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>>;
-        #defaultTimeoutInMs: number;
+        readonly #defaultTimeoutInMs: number;
         get defaultTimeoutInMs(): number;
-        set defaultTimeoutInMs(value: number);
         log(level: LogLevel, ...args: unknown[]): void;
     };
 } & T) & import("../").ExtendendMixinFactoryOptions;