npm - @factset/frontgate-js-sdk - Versions diffs - 7.1.0 → 7.1.1 - Mend

@factset/frontgate-js-sdk 7.1.0 → 7.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -1,6 +1,60 @@
+## <small>7.1.1 (2026-05-22)</small>
+* fix(abstract-logger): make sure a loglevel is always defined [d039198]
+* fix(compressor): initialize members with null as typed [a056cf1]
+* fix(connectable): mark config as potentially undefined [b8f7dca]
+* fix(data-observer): unsubscribe can be undefined [e6947ab]
+* fix(frontgate-ws): init message_buffer to avoid null comparison [f6aa80f]
+* fix(ga): add environment to docs job [1d62d6f]
+* fix(hooks): hook needs to accept generic PtlMessage [6554b6a]
+* fix(session-auth): resolve incompatibility with Connectable interface [95104a8]
+* fix(winston-logger): check for existing trace method [b533a24]
+* feat(ga): add workflow dispatch for docs job [fb6c9eb]
+* feat(ga): permit token for docs upload [ec22600]
+* feat(tsconfig): migrate to TS 6 [731dcd7]
+* docs(client-download): prefer factset.com domain [27a963f]
+* chore(deps): lock file maintenance [3df42bb]
+* chore(deps): lock file maintenance [3719301]
+* chore(deps): lock file maintenance [fbc6d86]
+* chore(deps): lock file maintenance [17f1a93]
+* chore(deps): update actions/deploy-pages action to v5 [f721a0b]
+* chore(deps): update actions/setup-node action to v6.4.0 [f772230]
+* chore(deps): update actions/upload-pages-artifact action to v5 [3df9da3]
+* chore(deps): update dependency axios to ^1.15.2 [security] [5838528]
+* chore(deps): update dependency happy-dom to ^20.8.8 [security] [9995d98]
+* chore(deps): update dependency happy-dom to ^20.8.9 [security] [261bacc]
+* chore(deps): update dependency typescript to v6 [287cb5f]
+* chore(deps): update dependency vite to v8 [62e69e7]
+* chore(deps): update dependency vite-plugin-node-polyfills to ^0.26.0 [869bd24]
+* chore(deps): update dependency vite-plugin-node-polyfills to ^0.27.0 [656c8ac]
+* chore(deps): update dependency vite-plugin-node-polyfills to ^0.28.0 [24884b1]
+* chore(deps): update factset/backstage-entity-validator action to v0.6.0 [2c8fd5e]
+* chore(deps): update factset/waffle-actions action to v2.7.0 [77ea193]
+* chore(deps): update factset/waffle-actions action to v2.7.2 [00db486]
+* chore(deps): update factset/waffle-actions action to v2.7.3 [791475b]
+* chore(deps): update factset/waffle-actions action to v2.8.0 [42b68da]
+* chore(deps): update lockfile [6862184]
+* chore(deps): update lockfile [31ab993]
+* chore(deps): update lockfile [18ff49b]
+* chore(deps): update lockfile [018f63e]
+* chore(deps): update lockfile [88635d5]
+* chore(deps): update shared-actions-public/sonarsource_sonarqube-scan-action action to v7.1.0 [09e2402]
+* chore(deps): update shared-actions-public/sonarsource_sonarqube-scan-action action to v7.2.0 [dcad76d]
+* chore(deps): update shared-actions-public/sonarsource_sonarqube-scan-action action to v8 [1571e4e]
+* chore(deps): update shared-actions-public/sonarsource_sonarqube-scan-action action to v8.1.0 [14ed672]
+* chore(deps): update yarn to v4.13.0 [e510119]
+* chore(deps): update yarn to v4.14.0 [aed4c63]
+* chore(deps): update yarn to v4.14.1 [9a00c87]
+* chore(docs): use @factset/ instead of @fds/ prefix [9f6835f]
+* chore(ga): downgrade actions for GHES support [d09c2a8]
+* refactor(error-handling): type errors [331915c]
+* refactor(frontgate-ws-mixin): deduplicate import [6d36bbf]
+* refactor(mixins): make previously implicit type signature explicit [e7c067a]
+* refactor(secret-generator): improve type signature to avoid null check [230dea6]
+* tests(data-observer): type test inputs [e88596c]
 ## 7.1.0 (2026-03-10)
-* feat(auth): add fetch auth with compression [13af8dc]
 * chore(deps): lock file maintenance [a9f36a7]
 * chore(deps): lock file maintenance [62ab9e8]
 * chore(deps): lock file maintenance [2453f92]
@@ -12,6 +66,8 @@
 * chore(deps): update factset/waffle-actions action to v2.6.3 [e1c8a5a]
 * chore(deps): update lockfile [093f343]
 * chore(deps): update lockfile [6c9ea37]
+* chore(release): update changelog for v7.1.0 [e473077]
+* feat(auth): add fetch auth with compression [13af8dc]
 * fix(dependencies): upgrade axios due to a security issue [5c72eaf]
 ## <small>7.0.11 (2026-02-10)</small>

package/dist/lib/esnext/connection/util/Compressor.js CHANGED Viewed

@@ -11,6 +11,8 @@ const concat = (buffers) => {
 };
 export class Compressor {
     constructor() {
+        this.compressor = null;
+        this.decompressor = null;
         this.reset();
     }
     reset() {

package/dist/lib/esnext/logger/AbstractLogger.js CHANGED Viewed

@@ -13,6 +13,7 @@ export class AbstractLogger {
         this.defaultLevel = LogLevel.WARN;
         this.noop = () => null;
         this.name = name;
+        this.level = this.defaultLevel;
         this.setDefaultLevelFromLocalStorage();
         Object.assign(AbstractLogger.loggers, { [name]: this });
     }

package/dist/lib/esnext/logger/WinstonLogger.js CHANGED Viewed

@@ -13,7 +13,9 @@ export class WinstonLogger extends AbstractLogger {
         super(name);
         this.name = name;
         this.logger = logger;
-        this.trace = Function.prototype.bind.call(logger.trace, logger);
+        if (logger.trace) {
+            this.trace = Function.prototype.bind.call(logger.trace, logger);
+        }
         this.debug = Function.prototype.bind.call(logger.debug, logger);
         this.info = Function.prototype.bind.call(logger.info, logger);
         this.warn = Function.prototype.bind.call(logger.warn, logger);

package/dist/lib/esnext/mixins/auth/SessionAuthMixin.js CHANGED Viewed

@@ -30,12 +30,27 @@ export const sessionAuth = (config, idApplication, username, password, deploymen
                     _mdg2wstoken.set(this, void 0);
                     _sharedSecret.set(this, void 0);
                     _clientSecret.set(this, void 0);
+                    this.connect = async () => {
+                        __classPrivateFieldSet(this, _logOut, false, "f");
+                        try {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                        }
+                        catch (e) {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
+                            await super.connect();
+                            const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
+                            __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
+                            await super.disconnect();
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                            __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
+                        }
+                    };
                     const plainSharedSecret = SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:beforeConnect', (settings) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
                         void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);
@@ -83,23 +98,6 @@ export const sessionAuth = (config, idApplication, username, password, deploymen
                         await this.hooks.callHook('frontgateConnection:authenticated');
                     });
                 }
-                async connect() {
-                    __classPrivateFieldSet(this, _logOut, false, "f");
-                    try {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                    }
-                    catch (e) {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
-                        await super.connect();
-                        const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
-                        __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
-                        await super.disconnect();
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                        __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
-                    }
-                }
                 async connectSession() {
                     __classPrivateFieldSet(this, _logOut, false, "f");
                     __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");

package/dist/lib/esnext/mixins/auth/UserPasswordAuthMixin.js CHANGED Viewed

@@ -26,10 +26,8 @@ export const userPasswordAuth = (idApplication, username, password, deploymentSt
                     _clientSecret.set(this, void 0);
                     const plainSharedSecret = SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:connected', async (conf) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', idApplication);
                         void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);

package/dist/lib/esnext/mixins/connection/FrontgateWSMixin.js CHANGED Viewed

@@ -34,7 +34,7 @@ export const wsConnection = (conf) => {
                     _jobId.set(this, 0);
                     _idApplication.set(this, void 0);
                     _idUser.set(this, void 0);
-                    _message_buffer_size.set(this, void 0);
+                    _message_buffer_size.set(this, 0);
                     _msgBuffer.set(this, []);
                     __classPrivateFieldSet(this, _idApplication, ID_APP_AUTHENTICATED, "f");
                     __classPrivateFieldSet(this, _idUser, ID_USER_NONE, "f");

package/dist/lib/esnext/mixins/subscription/EndpointSubscriptionMixin.js CHANGED Viewed

@@ -111,7 +111,7 @@ export const endpointSubscriptions = (originalConfig) => {
                                             observer.idJob = resp.header.id_job;
                                             if (subscriptionZombie) {
                                                 this.log(LogLevel.WARN, `Zombie subscription detected for ${key}. Initiating unsubscribe.`);
-                                                observer.unsubscribe();
+                                                observer.unsubscribe?.();
                                                 res();
                                                 return;
                                             }

package/dist/lib/esnext/version.js CHANGED Viewed

	@@ -1 +1 @@
1	- export const PACKAGE_JSON = { version: '7.1.0', package: '@factset/frontgate-js-sdk' };
1	+ export const PACKAGE_JSON = { version: '7.1.1', package: '@factset/frontgate-js-sdk' };

package/dist/lib/node/connection/util/Compressor.js CHANGED Viewed

@@ -14,6 +14,8 @@ const concat = (buffers) => {
 };
 class Compressor {
     constructor() {
+        this.compressor = null;
+        this.decompressor = null;
         this.reset();
     }
     reset() {

package/dist/lib/node/logger/AbstractLogger.js CHANGED Viewed

@@ -16,6 +16,7 @@ class AbstractLogger {
         this.defaultLevel = LogLevel.WARN;
         this.noop = () => null;
         this.name = name;
+        this.level = this.defaultLevel;
         this.setDefaultLevelFromLocalStorage();
         Object.assign(AbstractLogger.loggers, { [name]: this });
     }

package/dist/lib/node/logger/WinstonLogger.js CHANGED Viewed

@@ -16,7 +16,9 @@ class WinstonLogger extends AbstractLogger_1.AbstractLogger {
         super(name);
         this.name = name;
         this.logger = logger;
-        this.trace = Function.prototype.bind.call(logger.trace, logger);
+        if (logger.trace) {
+            this.trace = Function.prototype.bind.call(logger.trace, logger);
+        }
         this.debug = Function.prototype.bind.call(logger.debug, logger);
         this.info = Function.prototype.bind.call(logger.info, logger);
         this.warn = Function.prototype.bind.call(logger.warn, logger);

package/dist/lib/node/mixins/auth/SessionAuthMixin.js CHANGED Viewed

@@ -33,12 +33,27 @@ const sessionAuth = (config, idApplication, username, password, deploymentStage)
                     _mdg2wstoken.set(this, void 0);
                     _sharedSecret.set(this, void 0);
                     _clientSecret.set(this, void 0);
+                    this.connect = async () => {
+                        __classPrivateFieldSet(this, _logOut, false, "f");
+                        try {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                        }
+                        catch (e) {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
+                            await super.connect();
+                            const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
+                            __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
+                            await super.disconnect();
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                            __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
+                        }
+                    };
                     const plainSharedSecret = compat_1.SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = compat_1.SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:beforeConnect', (settings) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', authentication_1.ID_APP_AUTHENTICATED);
                         void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);
@@ -86,23 +101,6 @@ const sessionAuth = (config, idApplication, username, password, deploymentStage)
                         await this.hooks.callHook('frontgateConnection:authenticated');
                     });
                 }
-                async connect() {
-                    __classPrivateFieldSet(this, _logOut, false, "f");
-                    try {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                    }
-                    catch (e) {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
-                        await super.connect();
-                        const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
-                        __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
-                        await super.disconnect();
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                        __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
-                    }
-                }
                 async connectSession() {
                     __classPrivateFieldSet(this, _logOut, false, "f");
                     __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");

package/dist/lib/node/mixins/auth/UserPasswordAuthMixin.js CHANGED Viewed

@@ -29,10 +29,8 @@ const userPasswordAuth = (idApplication, username, password, deploymentStage) =>
                     _clientSecret.set(this, void 0);
                     const plainSharedSecret = compat_1.SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = compat_1.SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:connected', async (conf) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', idApplication);
                         void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);

package/dist/lib/node/mixins/connection/FrontgateWSMixin.js CHANGED Viewed

@@ -40,7 +40,7 @@ const wsConnection = (conf) => {
                     _jobId.set(this, 0);
                     _idApplication.set(this, void 0);
                     _idUser.set(this, void 0);
-                    _message_buffer_size.set(this, void 0);
+                    _message_buffer_size.set(this, 0);
                     _msgBuffer.set(this, []);
                     __classPrivateFieldSet(this, _idApplication, authentication_1.ID_APP_AUTHENTICATED, "f");
                     __classPrivateFieldSet(this, _idUser, authentication_1.ID_USER_NONE, "f");

package/dist/lib/node/mixins/subscription/EndpointSubscriptionMixin.js CHANGED Viewed

@@ -114,7 +114,7 @@ const endpointSubscriptions = (originalConfig) => {
                                             observer.idJob = resp.header.id_job;
                                             if (subscriptionZombie) {
                                                 this.log(logger_1.LogLevel.WARN, `Zombie subscription detected for ${key}. Initiating unsubscribe.`);
-                                                observer.unsubscribe();
+                                                observer.unsubscribe?.();
                                                 res();
                                                 return;
                                             }

package/dist/lib/node/version.js CHANGED Viewed

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_JSON = void 0;
-exports.PACKAGE_JSON = { version: '7.1.0', package: '@factset/frontgate-js-sdk' };
+exports.PACKAGE_JSON = { version: '7.1.1', package: '@factset/frontgate-js-sdk' };

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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;