@factset/frontgate-js-sdk 6.9.0

package/dist/lib/types/message/request/raw/example/CreateNotationSearchRequest.d.ts

@@ -0,0 +1,146 @@
+export declare const createNotationSearchRequest: () => {
+    Message: string;
+    Version: number;
+    header: {
+        id_job: number;
+        dataset: {
+            id_dataset: number;
+        };
+        flags: number;
+        resend_counter: number;
+        timeout: number;
+        authentication_identifiers: {
+            id_application: number;
+            id_user: number;
+        };
+        cache_key: {
+            value: never[];
+        };
+        previous_response_hash: {
+            value: never[];
+        };
+    };
+    search_parameters: {
+        data_items: ({
+            Message: string;
+            field_instance_selector: {
+                id_field: number;
+                id_dimensions: number[];
+                dv_tuples: {
+                    value_tuple: number[];
+                }[];
+                inner_factors: never[];
+                outer_factors: never[];
+            };
+            bind_source: {
+                index: number;
+            };
+            bind_dimensions: number[];
+            source?: undefined;
+            priority_list?: undefined;
+        } | {
+            Message: string;
+            source: {
+                index: number;
+            };
+            priority_list: string[];
+            field_instance_selector?: undefined;
+            bind_source?: undefined;
+            bind_dimensions?: undefined;
+        })[];
+        selection_criterion: {
+            criterion: {
+                Message: string;
+                criteria: ({
+                    criterion: {
+                        Message: string;
+                        index_data_item: {
+                            index: number;
+                        };
+                        op?: undefined;
+                        constant?: undefined;
+                        criteria?: undefined;
+                    };
+                } | {
+                    criterion: {
+                        Message: string;
+                        op: {
+                            value: number;
+                            negated: number;
+                        };
+                        index_data_item: {
+                            index: number;
+                        };
+                        constant: string;
+                        criteria?: undefined;
+                    };
+                } | {
+                    criterion: {
+                        Message: string;
+                        criteria: {
+                            criterion: {
+                                Message: string;
+                                op: {
+                                    value: number;
+                                    negated: number;
+                                };
+                                index_data_item: {
+                                    index: number;
+                                };
+                                constant: string[];
+                            };
+                        }[];
+                        index_data_item?: undefined;
+                        op?: undefined;
+                        constant?: undefined;
+                    };
+                } | {
+                    criterion: {
+                        Message: string;
+                        op: {
+                            value: number;
+                            negated: number;
+                        };
+                        index_data_item: {
+                            index: number;
+                        };
+                        constant: string[];
+                        criteria?: undefined;
+                    };
+                } | {
+                    criterion: {
+                        Message: string;
+                        op: {
+                            value: number;
+                            negated: number;
+                        };
+                        index_data_item: {
+                            index: number;
+                        };
+                        constant: number;
+                        criteria?: undefined;
+                    };
+                })[];
+            };
+        };
+    };
+    flags: number;
+    search_output_parameters: {
+        sort_data_items_r2: {
+            data_item: {
+                index: number;
+            };
+            order: {
+                direction: number;
+                empty: number;
+            };
+        }[];
+        output_data_items: {
+            index: number;
+        }[];
+        result_window: {
+            maximum: number;
+            offset: number;
+        };
+    };
+};

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

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

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

@@ -0,0 +1,20 @@
+import type { PtlMessage } from '../../common/interfaces';
+export interface AuthenticationByTokenResponse extends PtlMessage {
+    server_info: {
+        description: string;
+        software: string;
+        os: string;
+        uuid: {
+            id_1: string;
+            id_2: string;
+        };
+    };
+    feature_flags_granted: {
+        value: string;
+    };
+    maximum_idle_interval: string;
+    maximum_receivable_message_size: number;
+    time_at_server: {
+        microseconds: string;
+    };
+}

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

@@ -0,0 +1,37 @@
+import type { PtlMessage } from '../../common/interfaces';
+export interface AuthenticationResponse extends PtlMessage {
+    result: {
+        responses: [
+            {
+                salt: {
+                    value: {
+                        b64: string;
+                    };
+                };
+                salted_hash_1: string;
+                salted_hash_2: string;
+                salted_hash_3: string;
+            }
+        ];
+    };
+    challenge: {
+        challenge: {
+            b64: string;
+        };
+    };
+    id_user: number;
+    authentication: {
+        salt: {
+            value: {
+                b64: string;
+            };
+        };
+        encrypted_secrets: [
+            {
+                encrypted_secret: {
+                    b64: string;
+                };
+            }
+        ];
+    };
+}

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

@@ -0,0 +1,8 @@
+import { Mdg2Response } from './Mdg2Response';
+export declare class AuthenticationTokenResponse extends Mdg2Response {
+    private readonly token;
+    private readonly expiry;
+    constructor(raw: any);
+    getToken(): string;
+    getExpiry(): number;
+}

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

@@ -0,0 +1,3 @@
+import { Mdg2Response } from './Mdg2Response';
+export declare class CancelSubscriptionResponse extends Mdg2Response {
+}

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

@@ -0,0 +1,44 @@
+import type { PtlMessage } from '../../common/interfaces';
+export interface ConfigurationResponse extends PtlMessage {
+    server_info: {
+        description: string;
+        software: string;
+        os: string;
+        uuid: {
+            id_1: string;
+            id_2: string;
+        };
+    };
+    payload_info: {
+        payload_type: {
+            value: number;
+        };
+        payload_content: string;
+        stripe_set: {
+            number_stripes: number;
+            bit_array: [];
+        };
+        deployment_stage: {
+            value: number;
+        };
+        payload_details: {
+            payload: [];
+        };
+        location: string;
+        operation_mode: {
+            value: number;
+        };
+    };
+    feature_flags_granted: {
+        value: string;
+    };
+    load: {
+        capacity: number;
+        idle: number;
+    };
+    maximum_idle_interval: string;
+    maximum_receivable_message_size: number;
+    time_at_server: {
+        microseconds: string;
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { PtlMessage } from '../../common/interfaces/PtlMessage';
+export interface DisconnectionMessage extends PtlMessage {
+    reason: {
+        value: number;
+    };
+    details: string;
+}

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

@@ -0,0 +1,5 @@
+import { Mdg2Response } from './Mdg2Response';
+export declare class ErrorResponse extends Mdg2Response {
+    get reason(): string;
+    get jobId(): number;
+}

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

@@ -0,0 +1,30 @@
+import { Mdg2Response } from './Mdg2Response';
+export interface HTTPProxyResponseData {
+    data: any;
+    meta: {
+        status: {
+            code: number;
+        };
+        pagination?: {
+            total: number;
+            isEstimatedTotal: boolean;
+            next?: any;
+            previous?: any;
+        };
+    };
+}
+export interface HTTPProxyResponseInfo {
+    api: string;
+    source_host: string;
+    source_port: number;
+}
+export declare class HTTPProxyResponse extends Mdg2Response {
+    private readonly responseData;
+    private readonly responseInfo;
+    readonly statusCode: number;
+    readonly statusReason: string;
+    constructor(raw: any);
+    get data(): any;
+    get meta(): any;
+    get status(): any;
+}

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

@@ -0,0 +1,25 @@
+import { Mdg2Response } from './Mdg2Response';
+export interface HighLevelResponseData<Data = any> {
+    data: Data;
+    meta: HighLevelResponseMetaData;
+}
+export interface HighLevelResponseMetaData {
+    status: HighLevelResponseMetaStatus;
+    pagination?: {
+        total: number;
+        isEstimatedTotal: boolean;
+        next?: any;
+        previous?: any;
+    };
+}
+export interface HighLevelResponseMetaStatus {
+    code: number;
+}
+export declare class HighLevelResponse<Data = any> extends Mdg2Response {
+    private readonly responseData;
+    constructor(raw: any);
+    get data(): Data;
+    get meta(): HighLevelResponseMetaData;
+    get status(): HighLevelResponseMetaStatus;
+    get statusCode(): number;
+}

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

@@ -0,0 +1,8 @@
+import type { PtlMessage } from '../../common/interfaces';
+export interface LoadNotificationMessage extends PtlMessage {
+    load: {
+        capacity: number;
+        idle: number;
+    };
+    client_load_share: number;
+}

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

@@ -0,0 +1,11 @@
+import type { PtlMessage } from '../../common/interfaces/PtlMessage';
+export declare class Mdg2Response {
+    protected raw: any;
+    constructor(msg: any);
+    get msg(): PtlMessage;
+    get name(): string;
+    get jobId(): number;
+    get serviceId(): number;
+    isUpdateMessage(): boolean;
+    isLossMessage(): boolean;
+}

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

@@ -0,0 +1,4 @@
+import { Mdg2Response } from './Mdg2Response';
+export declare class PermissionDeniedResponse extends Mdg2Response {
+    get reason(): string;
+}

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

@@ -0,0 +1,13 @@
+export declare class PingResponse {
+    static readonly NAME = "Foundation::PingResponse";
+    static readonly VERSION = 2;
+    private readonly _timeAtSender;
+    private readonly _timeFromRequest;
+    private readonly _timeReceivedResponse;
+    constructor(raw: any);
+    get timeAtPeer(): number;
+    get timeOfRequest(): number;
+    get timeOfResponse(): number;
+    get latencyTotal(): number;
+    get latencyAtPeer(): number;
+}

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

@@ -0,0 +1,5 @@
+import { Mdg2Response } from './Mdg2Response';
+export declare class RejectResponse extends Mdg2Response {
+    get reason(): string;
+    get jobId(): number;
+}

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

@@ -0,0 +1,13 @@
+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/types/Time.d.ts

@@ -0,0 +1,6 @@
+export declare enum TimeOptions {
+    MAXIMUM_STRING = "9223372036854775807",
+    MINIMUM_STRING = "-9223372036854775807"
+}
+export type Time = number | bigint | TimeOptions;
+export declare function timeToMilliseconds(time: Time): string;

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

@@ -0,0 +1 @@
+export type TransportLayerClientRequestHeaderFlag = 'add_subscription' | 'no_merge' | 'support_caching' | 'permission_denied_response' | 'internal_client' | 'current_state_refresh' | 'subscription_use_pull_permissions' | 'allow_chunked_response';

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

@@ -0,0 +1,2 @@
+export * from './TransportLayerClientRequestHeaderFlag';
+export * from './Time';

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

@@ -0,0 +1,6 @@
+import { Mdg2Response } from '../response';
+export declare class HighLevelUpdate extends Mdg2Response {
+    private readonly responseData;
+    constructor(raw: any);
+    get data(): any;
+}

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

@@ -0,0 +1,17 @@
+import { Mdg2Response } from '../response';
+import type { PtlMessage } from '../../common/interfaces/PtlMessage';
+export interface ISubscriptionLossMessage extends PtlMessage {
+    header: {
+        id_job?: number;
+        id_service?: number;
+        processing_time?: number;
+    };
+    reason: {
+        value: number;
+    };
+}
+export declare class SubscriptionLossMessage extends Mdg2Response {
+    private readonly reason;
+    constructor(raw: ISubscriptionLossMessage);
+    get reasonValue(): any;
+}

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

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

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

@@ -0,0 +1,22 @@
+import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
+export interface AuthTokenRequestable {
+    requestAuthenticationToken: (lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number) => Promise<{
+        token: string;
+        expiry: number;
+    }>;
+}
+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;
+        }>;
+        logger: import("..").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,23 @@
+import { type AConstructorTypeOf, type CalledHooksByConnection } from '.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../FrontgateClient';
+import type { HighLevelRequestResult, PtlMessage } 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>>;
+}
+export type usedHooksByEndpointRequest = CalledHooksByConnection;
+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>>;
+        "__#1@#hasNextChunk"(msg: PtlMessage): boolean;
+        logger: import("..").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,21 @@
+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';
+export interface HTTProxyRequestable extends HTTPProxyRequestable {
+}
+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>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,12 @@
+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) => {
+    new (...args: any[]): {
+        logger: LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<import("../FrontgateClient").CalledHooksByBase, "base:log">;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,14 @@
+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 "__#3@#compressor": Compressor;
+        logger: import("..").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & import("../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,20 @@
+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[]): {
+        "__#10@#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>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;
+export declare const encodeSpanContext: (spanContext: SpanContext) => number[];

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

@@ -0,0 +1,22 @@
+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: () => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByReconnect & CalledHooksByReconnect & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        "__#9@#reconnectAttempts": number;
+        readonly "__#9@#reconnectDelays": number[];
+        "__#9@#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>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import(".").ExtendendMixinFactoryOptions;

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

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

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

@@ -0,0 +1,15 @@
+import { type AConstructorTypeOf, type CalledHooksByAuth, type CalledHooksByConnection } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import { AppAuthentication } from '../../authentication/AppAuthentication';
+import type { DeploymentStage } from '../../connection';
+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 "__#13@#auth": AppAuthentication;
+        logger: import("../..").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: import("../..").LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;

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

@@ -0,0 +1,13 @@
+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>>;
+        "__#11@#defaultTimeoutInMs": number;
+        defaultTimeoutInMs: number;
+        log(level: LogLevel, ...args: unknown[]): void;
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;