@factset/frontgate-js-sdk 7.0.1 → 7.0.4

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

@@ -23,6 +23,6 @@ export declare class HTTPProxyRequest extends AbstractMdg2Request {
     private setHeaders;
     private setQuery;
     private setMethod;
-    setBody(data?: HTTPProxyRequestBody): HTTPProxyRequest;
+    setBody(data?: HTTPProxyRequestBody): this;
     getData(): string | Record<string, unknown> | undefined;
 }

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

@@ -18,7 +18,7 @@ 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>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -13,10 +13,10 @@ export interface EndpointRequestMixinOptions {
 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>>;
-        #hasNextChunk(msg: PtlMessage): boolean;
+        "__#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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -1,8 +1,7 @@
 import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
 import type { HTTPProxyRequestResult } from '../common/interfaces/result/HTTPProxyRequestResult';
-import type { HTTPProxyRequestBody } from '../message';
-import { type HTTPMethod, type HTTPProxyRequestOptions } from '../message';
+import type { HTTPProxyRequestBody, HTTPMethod, HTTPProxyRequestOptions } from '../message';
 export interface HTTPProxyRequestable {
     requestProxyEndpoint: (method: HTTPMethod, path: string, body?: Record<string, unknown>, options?: HTTPProxyRequestOptions, timeOutInMs?: number) => Promise<HTTPProxyRequestResult>;
 }
@@ -12,7 +11,7 @@ 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>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -1,11 +1,11 @@
 import { type AConstructorTypeOf } from '.';
 import type { FrontgateClient } from '../FrontgateClient';
 import type { LogLevel, LoggerInterface } from '../logger';
-export declare const logger: (logger: LoggerInterface, logLevel?: LogLevel) => (<T extends AConstructorTypeOf<FrontgateClient>>(Base: T) => {
+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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -4,10 +4,10 @@ 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 #compressor: Compressor;
+        readonly "__#private@#compressor": Compressor;
         logger: import("..").LoggerInterface | undefined;
         hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -3,7 +3,7 @@ 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[]): {
-        #createSpanHeader(tracing: SpanContext): {
+        "__#private@#createSpanHeader"(tracing: SpanContext): {
             tracing: {
                 value: {
                     value: number[];
@@ -12,7 +12,7 @@ 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>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -10,7 +10,7 @@ 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>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -10,12 +10,12 @@ export interface CalledHooksByReconnect {
 }
 export declare const reconnect: (reconnectDelaysInMs?: number[]) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByReconnect & CalledHooksByReconnect & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        #reconnectAttempts: number;
-        readonly #reconnectDelays: number[];
-        #reconnectTimer: NodeJS.Timeout | undefined;
+        "__#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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -9,7 +9,7 @@ export declare const remotelogger: (identifier?: number) => (<T extends AConstru
         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;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -10,7 +10,7 @@ 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>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: import("..").LogLevel, ...args: unknown[]): void;
     };

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

@@ -1,4 +1,4 @@
-import { type AConstructorTypeOf, type FrontgateClientWSConnectionConfig, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, CalledHooksByAuth, CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
 import type { PtlMessage } from '../../common/interfaces';
 import { AuthenticationRequest, ConfigurationRequest } from '../../compat';
@@ -8,15 +8,15 @@ import type { AuthenticationResponse } from '../../message/response/Authenticati
 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 #sharedSecret: Buffer;
-        readonly #clientSecret: Buffer;
-        #createAuthenticationRequest(): AuthenticationRequest;
-        #createConfigurationRequest(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
-        #createTransportLayerRequestHeaderConfigurationRequest(): PtlMessage;
-        #submit<M extends PtlMessage>(message: PtlMessage): Promise<M>;
+        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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -6,7 +6,7 @@ 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>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -5,46 +5,46 @@ 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[]): {
-        #token: string;
-        #secondFactor: string;
-        readonly #requestInfo: RequestInfo;
-        readonly #requestInit: RequestInit | undefined;
-        #fetchConnectionConfiguration(): Promise<{
+        "__#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;
         }>;
-        #ws: import("ws") | undefined;
-        #wsConf: import("../.").InternalFrontgateClientWSConnectionConfig | undefined;
-        #wsStateInternal: "connecting" | "connected" | "authenticated" | "disconnected";
-        #keepAliveTimer: NodeJS.Timeout | undefined;
-        #jobId: number;
-        #idApplication: number;
-        #idUser: number;
-        get #wsState(): "connecting" | "connected" | "authenticated" | "disconnected";
-        #message_buffer_size: number;
-        readonly #msgBuffer: FrontgateMessage[];
-        set conf(conf: FrontgateClientWSConnectionConfig);
+        "__#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>;
-        #getDisconnectMessage(): import("../..").DisconnectionMessage;
-        #getKeepAliveMessage(): {
+        "__#private@#getDisconnectMessage"(): import("../..").DisconnectionMessage;
+        "__#private@#getKeepAliveMessage"(): {
             Message: string;
             Version: number;
         };
-        #sendMessage(msg: PtlMessage): Promise<void>;
-        #respondToMessage(msgObj: PtlMessage): void;
-        #addJobIdToMessage(msg: PtlMessage): number;
-        #prepareMessage(msg: PtlMessage): void;
-        #createErrorMessage(error: string, msg: PtlMessage): import("../..").ErrorResponse;
-        #applyDefaultsToConfig(conf: FrontgateClientWSConnectionConfig): import("../.").InternalFrontgateClientWSConnectionConfig;
+        "__#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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
     };

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

@@ -12,11 +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[]): {
-        #tokenConnectionAttempt: boolean;
-        #logOut: boolean;
-        #mdg2wstoken: string | undefined;
-        readonly #sharedSecret: Buffer;
-        readonly #clientSecret: Buffer;
+        "__#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;
@@ -24,40 +24,40 @@ export declare const sessionAuth: (config: FrontgateClientWSConnectionConfig, id
         connect(): Promise<void>;
         connectSession(): Promise<void>;
         logout(): Promise<void>;
-        #requestOtpAuthenticationTokenForSessionHandling(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<{
+        "__#private@#requestOtpAuthenticationTokenForSessionHandling"(lifetimeSeconds?: number, idUser?: number, idApplicationOtp?: number, timeOutInMs?: number): Promise<{
             token: string;
             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";
-        #keepAliveTimer: NodeJS.Timeout | undefined;
-        #jobId: number;
-        #idApplication: number;
-        #idUser: number;
-        get #wsState(): "connecting" | "connected" | "authenticated" | "disconnected";
-        #message_buffer_size: number;
-        readonly #msgBuffer: FrontgateMessage[];
-        set conf(conf: FrontgateClientWSConnectionConfig);
-        #getDisconnectMessage(): import("../../message").DisconnectionMessage;
-        #getKeepAliveMessage(): {
+        "__#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;
         };
-        #sendMessage(msg: PtlMessage): Promise<void>;
-        #respondToMessage(msgObj: PtlMessage): void;
-        #addJobIdToMessage(msg: PtlMessage): number;
-        #prepareMessage(msg: PtlMessage): void;
-        #createErrorMessage(error: string, msg: PtlMessage): import("../../message").ErrorResponse;
-        #applyDefaultsToConfig(conf: FrontgateClientWSConnectionConfig): import("../.").InternalFrontgateClientWSConnectionConfig;
+        "__#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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
     };

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

@@ -7,11 +7,11 @@ export interface TokenAuth {
 }
 export declare const tokenAuth: (token?: string) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByTokenAuth & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        #token: string;
-        set token(token: string);
+        "__#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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -1,4 +1,4 @@
-import { type AConstructorTypeOf, type FrontgateClientWSConnectionConfig, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, CalledHooksByAuth, CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
 import { type DeploymentStage } from '../../connection';
 import { AuthenticationRequest, ConfigurationRequest } from '../../compat';
@@ -8,15 +8,15 @@ import type { AuthenticationResponse } from '../../message/response/Authenticati
 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 #sharedSecret: Buffer;
-        readonly #clientSecret: Buffer;
-        #createAuthenticationRequest(): AuthenticationRequest;
-        #createConfigurationRequest(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
-        #createTransportLayerRequestHeaderConfigurationRequest(): PtlMessage;
-        #submit<M extends PtlMessage>(message: PtlMessage): Promise<M>;
+        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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -1,4 +1,4 @@
-import { type AConstructorTypeOf, type FrontgateClientWSConnectionConfig, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, CalledHooksByAuth, CalledHooksByConnection } from '../.';
 import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
 import { type DeploymentStage } from '../../connection';
 import { AuthenticationRequest, ConfigurationRequest } from '../../compat';
@@ -8,15 +8,15 @@ import type { AuthenticationResponse } from '../../message/response/Authenticati
 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 #sharedSecret: Buffer;
-        readonly #clientSecret: Buffer;
-        #createAuthenticationRequest(): AuthenticationRequest;
-        #createConfigurationRequest(msg: AuthenticationResponse, conf: FrontgateClientWSConnectionConfig): ConfigurationRequest;
-        #createTransportLayerRequestHeaderConfigurationRequest(): PtlMessage;
-        #submit<M extends PtlMessage>(message: PtlMessage): Promise<M>;
+        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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

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

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

@@ -1,5 +1,4 @@
 import type { PtlMessage } from '../../common/interfaces';
-import type { DisconnectionMessage } from '../../message';
 import type { CloseEvent } from 'ws';
 import type { FrontgateClientWSConnectionConfig } from './FrontgateWSMixin';
 export * from './FrontgateWSMixin';
@@ -25,7 +24,7 @@ export interface CalledHooksByConnection {
     }) => void;
     'frontgateConnection:connected': (conf: any) => void;
     'frontgateConnection:error': (err: any) => void;
-    'frontgateConnection:disconnected': (event: DisconnectionMessage | any) => void;
+    'frontgateConnection:disconnected': (event: any) => void;
     'frontgateConnection:beforeSerializeMessage': (msg: PtlMessage) => void;
     'frontgateConnection:beforeSendMessage': (data: {
         msg: string;

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

@@ -12,13 +12,13 @@ export interface EndpointSubscriptionsConfig {
 }
 export declare const endpointSubscriptions: (originalConfig?: EndpointSubscriptionsConfig) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByEndpointSubscribable & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        readonly #subscriptions: Map<string, FrontgateClientEndpointDataObserver>;
-        readonly #subscriptionCounts: Map<string, number>;
-        readonly #inFlights: Map<string, Promise<FrontgateClientEndpointDataObserver<HighLevelResponseData<unknown>>>>;
+        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 #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -11,16 +11,16 @@ export interface RawSubscribable {
 export type usedHooksByRawSubscribable = CalledHooksByConnection;
 export declare const rawSubscriptions: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByRawSubscribable & DefaultFrontgateClientHooks>>>(Base: T) => {
     new (...args: any[]): {
-        readonly #subscriptions: Map<string, {
+        readonly "__#private@#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>>;
-        #rawSubscriptionHelper<ResponseData extends Record<string, any> = PtlMessage>(request: AbstractMdg2Request, subscriptionType: "job" | "connection", CancelationRequestConstructor: ConnectionBasedSubscriptionCancelationRequestConstructor | undefined, timeOutInMs?: number): Promise<FrontgateClientDataObserver<any>>;
+        "__#private@#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>>;
-        readonly #defaultTimeoutInMs: number;
+        readonly "__#private@#defaultTimeoutInMs": number;
         get defaultTimeoutInMs(): number;
         log(level: LogLevel, ...args: unknown[]): void;
     };

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

@@ -1,7 +1,6 @@
 import type { SpanContext } from '@opentelemetry/api';
 export interface NavigatorInterface {
-    userAgent: string;
-    platform: string;
+    userAgent?: string;
 }
 export interface ClientInformation {
     userAgent: string;