@factset/frontgate-js-sdk 6.9.0

package/dist/lib/types/core/RequestModule.d.ts

@@ -0,0 +1,78 @@
+import type { Subject } from 'rxjs';
+import type { PtlMessage, HighLevelRequestResult } from '../common/interfaces';
+import type { RequestQuality } from '../common/types';
+import type { LoggerInterface } from '../logger';
+import type { AbstractMdg2Request, HighLevelRequestMethod, HighLevelRequestOptions, HTTPMethod, HTTPProxyRequestOptions, PermissionDeniedResponse, HTTPProxyRequestBody } from '../message';
+import { ErrorResponse } from '../message';
+import { CookieTokenAuthenticationFactors } from '../authentication';
+import type { HTTPProxyRequestResult } from '../common/interfaces/result/HTTPProxyRequestResult';
+import type { Mdg2ClientOptions } from '../common/Mdg2ClientOptions';
+import type { ConnectionInterface } from '../connection';
+export interface Job {
+    msg: AbstractMdg2Request;
+    expirationTime: number;
+    request: {
+        json: any;
+        data?: any;
+    };
+    resolve: (arg?: any) => void;
+    reject: (arg?: any) => void;
+}
+export interface DebugMessage {
+    json: PtlMessage;
+    data?: Record<string, unknown>;
+}
+export interface DebugObject {
+    request: DebugMessage;
+    response: ErrorResponse | PermissionDeniedResponse;
+}
+export interface RequestItem {
+    msg: any;
+    resolve: any;
+    reject: any;
+    insertedAt?: number;
+}
+type RequestModuleOptions = Required<Pick<Mdg2ClientOptions, 'defaultTimeoutInMs' | 'defaultTimeoutTokenInMs' | 'maxTimeoutsBeforeReconnect' | 'flagPermissionDenied' | 'replaySubjectBufferSize'>>;
+export declare const DEFAULT_REQUEST_MODULE_OPTIONS: RequestModuleOptions;
+export declare class RequestModule {
+    private readonly getConnection;
+    private logger;
+    private readonly options;
+    private updateMessageHandler?;
+    private lossMessageHandler?;
+    requestSubject: Subject<RequestItem>;
+    private readonly jobs;
+    private readonly replaySubjectBufferSize;
+    private readonly rejectResponsesTimeout;
+    private timeoutCounter;
+    private subscription;
+    private readonly chunks;
+    constructor(getConnection: () => ConnectionInterface | undefined, logger: LoggerInterface, options?: RequestModuleOptions);
+    setLogger(logger: LoggerInterface): void;
+    reset(): void;
+    requestWithQuality(msg: AbstractMdg2Request, quality?: RequestQuality, timeOutInMs?: number): Promise<any>;
+    requestEndpoint(method: HighLevelRequestMethod, path: string, data?: Record<string, unknown>, options?: HighLevelRequestOptions, timeOutInMs?: number): Promise<HighLevelRequestResult>;
+    requestProxyEndpoint(method: HTTPMethod, path: string, body?: HTTPProxyRequestBody, options?: HTTPProxyRequestOptions, timeOutInMs?: number): Promise<HTTPProxyRequestResult>;
+    requestAuthenticationToken(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<string>;
+    requestAuthenticationTokenExpiry(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number, otp?: boolean): Promise<{
+        token: string;
+        expiry: number;
+    }>;
+    requestAuthenticationTokenFactorsForCookieAuthentication(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number): Promise<CookieTokenAuthenticationFactors>;
+    onConnection(): void;
+    setUpdateMessageHandler(handler: (msg: any, jobId: number) => void): void;
+    setLossMessageHandler(handler: (msg: any, jobId: number) => void): void;
+    request(msg: AbstractMdg2Request, timeOutInMs?: number): Promise<any>;
+    reRequest(job: Job): void;
+    private requestBestQuality;
+    private prependCollectedChunks;
+    private collectChunk;
+    private handleMessage;
+    private rejectResponseHandler;
+    private getRejectResponseTimeout;
+    private sendRequest;
+    clearPendingRequests(): void;
+    private static supportedPermissionDeniedResponseMessages;
+    private static supportsChunkedResponse;
+}
+export {};

package/dist/lib/types/core/SubscriptionModule.d.ts

@@ -0,0 +1,24 @@
+import type { ObserveOptions, RequestResult } from '../common/interfaces';
+import type { HighLevelRequestMethod, JobObservable, HighLevelRequestOptions } from '../message';
+import type { RequestModule } from './RequestModule';
+import type { LoggerInterface } from '../logger';
+import type { Mdg2ClientOptions } from '../common/Mdg2ClientOptions';
+export type SubscriptionModuleOptions = Pick<Mdg2ClientOptions, 'shouldRestartSubscriptions'>;
+export declare const DEFAULT_SUBSCRIPTION_MODULE_OPTIONS: SubscriptionModuleOptions;
+export declare class SubscriptionModule {
+    private logger;
+    private readonly options;
+    private readonly subjectManager;
+    private readonly handler;
+    static defaultObserveOptions: ObserveOptions;
+    constructor(requestModule: RequestModule, logger: LoggerInterface, options?: SubscriptionModuleOptions);
+    setLogger(logger: LoggerInterface): void;
+    observeEndpoint(method: HighLevelRequestMethod, path: string, data: Record<string, unknown>, options?: ObserveOptions, requestOptions?: HighLevelRequestOptions): JobObservable<RequestResult>;
+    unobserveEndpoint(idJob: number): Promise<void>;
+    restartSubscriptions(): void;
+    clearPendingSubscriptions(): void;
+    clearPendingSubscription(idJob: number): void;
+    private lossHandler;
+    private updateHandler;
+    private findSubject;
+}

package/dist/lib/types/core/subscription/EndpointHandler.d.ts

@@ -0,0 +1,37 @@
+import type { Operation } from 'fast-json-patch';
+import { Subject } from 'rxjs';
+import type { ObserveOptions, RequestResult } from '../../common/interfaces';
+import type { HighLevelRequestMethod, HighLevelResponse, JobObservable, HighLevelRequestOptions } from '../../message';
+import type { SubjectManager } from './SubjectManager';
+import type { LoggerInterface } from '../../logger';
+import type { RequestModule } from '../RequestModule';
+export interface JobRequest {
+    path: string;
+    data: Record<string, unknown>;
+    method: HighLevelRequestMethod;
+    subject: Subject<JobObservable<RequestResult>>;
+    observable: JobObservable<RequestResult>;
+    options?: ObserveOptions;
+    requestOptions?: HighLevelRequestOptions;
+}
+export declare class EndpointHandler {
+    private readonly responses;
+    private readonly requestToJobMapper;
+    private readonly requestModule;
+    private logger;
+    private readonly subjectManager;
+    private readonly resultMapper;
+    private static readonly highLevelResponseFilter;
+    constructor(requestModule: RequestModule, subjectManager: SubjectManager<HighLevelResponse>, logger: LoggerInterface);
+    setLogger(logger: LoggerInterface): void;
+    observe(method: HighLevelRequestMethod, path: string, data: Record<string, unknown>, options?: ObserveOptions, requestOptions?: HighLevelRequestOptions): JobObservable<RequestResult>;
+    unobserve(idJob: number): Promise<void>;
+    findSubject(idJob: number): Subject<HighLevelResponse> | undefined;
+    registerEndpointResponse(idJob: number, response: HighLevelResponse): void;
+    registerEndpointRequest(idJob: number, subject: Subject<JobObservable<RequestResult>>, observable: JobObservable<RequestResult>, method: HighLevelRequestMethod, path: string, data: Record<string, unknown>, options?: ObserveOptions, requestOptions?: HighLevelRequestOptions): void;
+    applyEndpointJsonPatchUpdate(idJob: number, patch: Operation[]): HighLevelResponse;
+    restartSubscriptions(): void;
+    restartSubscription(jobId: number): void;
+    private resubscribe;
+    private validateOptions;
+}

package/dist/lib/types/core/subscription/SubjectManager.d.ts

@@ -0,0 +1,21 @@
+import type { LoggerInterface } from '../../logger';
+import type { Subject } from 'rxjs';
+import type { RequestQuality } from '../../common/types';
+import type { Mdg2Response } from '../../message';
+export interface SubjectContainer {
+    subject: Subject<Mdg2Response>;
+    serviceId: number;
+    quality: RequestQuality;
+    fieldInstances: number[];
+}
+export declare class SubjectManager<ResponseType = unknown> {
+    private readonly logger;
+    private readonly job;
+    constructor(logger: LoggerInterface);
+    hasJobSubject(idJob: number | string): boolean;
+    registerJobSubject(idJob: number | string, subject: Subject<ResponseType>): void;
+    findJobSubject(identifier: string | number): Subject<ResponseType> | undefined;
+    removeJobSubject(idJob: number | string): void;
+    getJobSubject(idJob: number | string): Subject<ResponseType> | undefined;
+    get jobs(): Map<string, Subject<ResponseType>>;
+}

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

@@ -0,0 +1,10 @@
+export * from './authentication';
+export * from './connection';
+export * from './message';
+export * from './common/interfaces';
+export * from './common/types';
+export * from './logger';
+export * from './mixins';
+export { Mdg2Client } from './Mdg2Client';
+export { FrontgateClientBuilder, FrontgateClient, type DefaultFrontgateClientHooks } from './FrontgateClient';
+export { useTimeout } from './util/functions';

package/dist/lib/types/logger/AbstractLogger.d.ts

@@ -0,0 +1,32 @@
+import type { LoggerInterface } from './LoggerInterface';
+export declare enum LogLevel {
+    TRACE = 10,
+    DEBUG = 20,
+    INFO = 30,
+    WARN = 40,
+    ERROR = 50,
+    FATAL = 60,
+    SILENT = 100
+}
+export type Level = LogLevel.TRACE | LogLevel.DEBUG | LogLevel.INFO | LogLevel.WARN | LogLevel.ERROR | LogLevel.FATAL | LogLevel.SILENT;
+export declare abstract class AbstractLogger {
+    protected name: string;
+    protected level: Level;
+    defaultLevel: Level;
+    protected noop: () => null;
+    trace: any;
+    debug: any;
+    info: any;
+    warn: any;
+    error: any;
+    fatal: any;
+    static readonly loggers: Record<string, LoggerInterface>;
+    constructor(name?: string);
+    getName(): string;
+    setLevel(level: LogLevel): void;
+    getLevel(): number;
+    protected shouldLog(method: string): boolean;
+    private setDefaultLevelFromLocalStorage;
+    static getLogLevel(loglevel: string): LogLevel;
+    static getLogger(name: string, LoggerClass: any): LoggerInterface;
+}

package/dist/lib/types/logger/ConsoleLogger.d.ts

@@ -0,0 +1,14 @@
+import type { LoggerInterface } from './LoggerInterface';
+import type { LogLevel } from './AbstractLogger';
+import { AbstractLogger } from './AbstractLogger';
+export declare class ConsoleLogger extends AbstractLogger implements LoggerInterface {
+    trace: any;
+    debug: any;
+    info: any;
+    warn: any;
+    error: any;
+    fatal: any;
+    setLevel(level: LogLevel): void;
+    protected getLogMethod(level: string): any;
+    static getLogger(name?: string): LoggerInterface;
+}

package/dist/lib/types/logger/LoggerHelper.d.ts

@@ -0,0 +1,4 @@
+import { LogLevel } from './AbstractLogger';
+export declare class LoggerHelper {
+    static getLogLevel(logLevel: string): LogLevel;
+}

package/dist/lib/types/logger/LoggerInterface.d.ts

@@ -0,0 +1,12 @@
+import type { Level } from './AbstractLogger';
+export interface LoggerInterface {
+    trace: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    fatal: (...args: any[]) => void;
+    setLevel: (level: Level, persist?: boolean) => void;
+    getLevel: () => Level;
+    getName: () => string;
+}

package/dist/lib/types/logger/NullLogger.d.ts

@@ -0,0 +1,10 @@
+import type { LoggerInterface } from './LoggerInterface';
+import { AbstractLogger } from './AbstractLogger';
+export declare class NullLogger extends AbstractLogger implements LoggerInterface {
+    trace: () => null;
+    debug: () => null;
+    info: () => null;
+    warn: () => null;
+    error: () => null;
+    static getLogger(name?: string): LoggerInterface;
+}

package/dist/lib/types/logger/WinstonLogger.d.ts

@@ -0,0 +1,22 @@
+import { AbstractLogger, LogLevel } from './AbstractLogger';
+import type { LoggerInterface } from './LoggerInterface';
+import type { LeveledLogMethod, Logger } from 'winston';
+export interface ExtendedLogger extends Logger {
+    trace?: LeveledLogMethod;
+    fatal?: LeveledLogMethod;
+}
+export declare const levels: {
+    silent: number;
+    fatal: number;
+    error: number;
+    warn: number;
+    info: number;
+    debug: number;
+    trace: number;
+};
+export declare class WinstonLogger extends AbstractLogger implements LoggerInterface {
+    private readonly logger;
+    constructor(logger: ExtendedLogger, name?: string);
+    setLevel(level: LogLevel): void;
+    static getLogger(name?: string): LoggerInterface;
+}

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

@@ -0,0 +1,6 @@
+export * from './LoggerHelper';
+export * from './AbstractLogger';
+export * from './ConsoleLogger';
+export * from './LoggerInterface';
+export * from './WinstonLogger';
+export * from './NullLogger';

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

@@ -0,0 +1,29 @@
+import * as responses from './response';
+export declare const FLAG_HAS_NEXT_CHUNK = 8;
+export interface RawMessage {
+    Message: string;
+    header?: {
+        id_job: number;
+        processingTime: number;
+        flags?: number;
+    };
+    body?: {
+        value: string;
+    };
+}
+export interface RawMdg2Response extends RawMessage {
+    header: {
+        id_job: number;
+        processingTime: number;
+        flags?: number;
+    };
+    body: {
+        value: string;
+    };
+}
+export declare class MessageFactory {
+    private static readonly msgNameSeparator;
+    private static readonly msgNameSeparatorLength;
+    static createMessage(msg: any): responses.Mdg2Response;
+    static hasNextChunk(msg: RawMessage): boolean;
+}

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

@@ -0,0 +1,11 @@
+import type { PermissionDeniedResponse } from '../index';
+import type { RawMessage } from './MessageFactory';
+import type { ErrorResponse, HighLevelResponse, Mdg2Response, RejectResponse } from './response';
+import type { HighLevelUpdate } from './update';
+export declare function isErrorResponse(response: Mdg2Response): response is ErrorResponse;
+export declare function isPermissionDeniedResponse(response: Mdg2Response): response is PermissionDeniedResponse;
+export declare function isHighLevelResponse(response: Mdg2Response): response is HighLevelResponse;
+export declare function isHighLevelResponseMessage(response: RawMessage): boolean;
+export declare function isRejectResponse(response: Mdg2Response): response is RejectResponse;
+export declare function isHighLevelUpdate(response: Mdg2Response): response is HighLevelUpdate;
+export declare function isSubscriptionLossMessage(response: Mdg2Response): boolean;

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

@@ -0,0 +1,6 @@
+export * from './guards';
+export * from './types';
+export * from './interfaces';
+export * from './request';
+export * from './response';
+export * from './update';

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

@@ -0,0 +1,15 @@
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT';
+export type HTTPProtocol = 'HTTP' | 'HTTPS';
+export interface HTTPProxyRequestOptions {
+    idApplication?: number;
+    idUser?: number;
+    no_merge?: boolean;
+    protocol?: HTTPProtocol;
+    method?: HTTPMethod;
+    path?: string;
+    host?: string;
+    port?: number;
+    headers?: Record<string, string>;
+    query?: Record<string, string> | string;
+    body?: Record<string, string> | number[];
+}

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

@@ -0,0 +1 @@
+export type HighLevelRequestMethod = 'GET' | 'POST';

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

@@ -0,0 +1,9 @@
+export interface HighLevelRequestOptions {
+    idApplication?: number;
+    idUser?: number;
+    accept?: string;
+    content_type?: string;
+    subscribe?: boolean;
+    no_merge?: boolean;
+    allowChunkedResponse?: boolean;
+}

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

@@ -0,0 +1,4 @@
+import type { Observable } from 'rxjs';
+export interface JobObservable<T> extends Observable<T> {
+    idJob?: number;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { TransportLayerClientRequestHeader } from './TransportLayerClientRequestHeader';
+import type { PtlMessage } from '../../common/interfaces/PtlMessage';
+export declare abstract class AbstractMdg2Request {
+    header: TransportLayerClientRequestHeader;
+    protected coreMembers: {
+        Version: number;
+        Message: string;
+    };
+    protected members: Record<string, any>;
+    protected constructor(message: string, version: number);
+    getPtlMessage(): PtlMessage;
+}

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

@@ -0,0 +1,6 @@
+export declare class AuthenticationByTokenRequest {
+    private readonly token;
+    private readonly maximumIdleInterval;
+    constructor(token: any, maximumIdleInterval: number);
+    toJson(): any;
+}

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

@@ -0,0 +1,17 @@
+import type { PtlMessage } from '../../common/interfaces';
+export interface AuthenticationRequestOptions {
+    encryptedSecrets?: {
+        encrypted_secret: Buffer | number[];
+    }[];
+    idPeer?: number;
+    username?: string;
+    salt?: number[];
+    challenge: number[];
+    idApplication: number;
+}
+export declare class AuthenticationRequest {
+    private static readonly DEFAULT_OPTIONS;
+    private readonly options;
+    constructor(options: AuthenticationRequestOptions);
+    toJson(): PtlMessage;
+}

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

@@ -0,0 +1,9 @@
+import { AbstractMdg2Request } from './AbstractMdg2Request';
+export declare class AuthenticationTokenRequest extends AbstractMdg2Request {
+    static NAME: string;
+    static VERSION: number;
+    static LIFETIME_SECONDS_DEFAULT: number;
+    static LIFETIME_SECONDS_MAXIMUM: number;
+    static FLAG_SINGLE_USAGE: number;
+    constructor(lifetimeSeconds?: number, idUser?: number, idApplication?: number, timeOutInMs?: number, otp?: boolean);
+}

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

@@ -0,0 +1,6 @@
+import { AbstractMdg2Request } from './AbstractMdg2Request';
+export declare class CancelSubscriptionRequest extends AbstractMdg2Request {
+    static readonly NAME = "CancelSubscriptionRequest";
+    static readonly VERSION = 6;
+    constructor(jobId: number);
+}

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

@@ -0,0 +1,14 @@
+import type { DeploymentStage } from '../../connection';
+export interface ConfigurationRequestOptions {
+    shared_secret: Buffer;
+    payload_content: string;
+    deployment_stage: DeploymentStage;
+    maximum_idle_interval: number;
+}
+export declare class ConfigurationRequest {
+    private readonly challenge;
+    private readonly options;
+    constructor(challenge: any, options: ConfigurationRequestOptions);
+    toJson(): any;
+    private static readChallenge;
+}

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

@@ -0,0 +1,28 @@
+import { AbstractMdg2Request } from './AbstractMdg2Request';
+import type { HTTPProxyRequestOptions, HTTPMethod } from '../interfaces';
+export type HTTPProxyRequestBody = string | Record<string, unknown> | unknown[];
+export declare class HTTPProxyRequest extends AbstractMdg2Request {
+    static readonly NAME = "HTTPProxyRequest";
+    static readonly VERSION = 2;
+    static readonly PROTOCOL: {
+        HTTP: number;
+        HTTPS: number;
+    };
+    static readonly METHOD: {
+        GET: number;
+        POST: number;
+        OPTIONS: number;
+        HEAD: number;
+        PUT: number;
+        DELETE: number;
+        TRACE: number;
+        CONNECT: number;
+    };
+    constructor(method: HTTPMethod, path: string, options?: HTTPProxyRequestOptions);
+    private setOptions;
+    private setHeaders;
+    private setQuery;
+    private setMethod;
+    setBody(data?: HTTPProxyRequestBody): HTTPProxyRequest;
+    getData(): string | Record<string, unknown> | undefined;
+}

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

@@ -0,0 +1,17 @@
+import type { HighLevelRequestMethod, HighLevelRequestOptions } from '../interfaces';
+import { AbstractMdg2Request } from './AbstractMdg2Request';
+export declare class HighLevelRequest extends AbstractMdg2Request {
+    static readonly NAME = "HighLevelRequest";
+    static readonly VERSION = 3;
+    static readonly METHOD: {
+        GET: number;
+        POST: number;
+    };
+    constructor(method: HighLevelRequestMethod, path: string, data?: {}, options?: HighLevelRequestOptions);
+    private setOptions;
+    private setMethod;
+    private setBody;
+    getData(): string | Record<string, unknown> | undefined;
+    private setQuery;
+    static ptlToJsonData(data: any): Record<string, unknown> | undefined;
+}

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

@@ -0,0 +1,16 @@
+import type { Time } from '../types';
+import type { PtlMessage } from '../../common/interfaces';
+export interface PingRequestMessage extends PtlMessage {
+    time_at_sender: {
+        microseconds: Time;
+    };
+}
+export declare class PingRequest {
+    static readonly NAME = "PingRequest";
+    static readonly VERSION = 3;
+    private _timeAtSender;
+    constructor();
+    getPtlMessage(): PingRequestMessage;
+    resetTimeAtSender(): void;
+    get timeAtSender(): number;
+}

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

@@ -0,0 +1,53 @@
+import type { Quality } from '../../common/types';
+import type { TransportLayerClientRequestHeaderFlag } from '../types';
+import { type SpanContext } from '@opentelemetry/api';
+export interface PtlTransportLayerClientRequestHeader {
+    dataset: {
+        id_dataset: number;
+    };
+    id_job: number;
+    flags_r2: number;
+    resend_counter: number;
+    timeout: number;
+    authentication_identifiers: {
+        id_application: number;
+        id_user: number;
+    };
+    cache_key: {
+        value: number[];
+    };
+    previous_response_hash: {
+        value: number[];
+    };
+    tracing: {
+        value: {
+            value: number[];
+        };
+    };
+}
+export declare class TransportLayerClientRequestHeader {
+    static PRICE_QUALITY: {
+        RLT: number;
+        DLY: number;
+        EOD: number;
+    };
+    private static readonly FLAG_VALUE;
+    private readonly headerMembers;
+    private readonly flags;
+    getPtlMessage(): PtlTransportLayerClientRequestHeader;
+    getQuality(): Quality;
+    setQuality(quality: Quality): void;
+    setIdApplication(idApplication: number, replaceValueIfSet?: boolean): void;
+    setIdUser(idUser: number, replaceValueIfSet?: boolean): void;
+    setFlag(flag: TransportLayerClientRequestHeaderFlag, enable?: boolean): void;
+    getFlagsValue(): number;
+    isFlagValueSet(flagValue: TransportLayerClientRequestHeaderFlag): boolean;
+    setJobId(jobId: any): void;
+    getJobId(): number;
+    countResend(): void;
+    getResendCounter(): number;
+    setTimeout(timeout: number): void;
+    getTimeout(): number;
+    setTracing(tracing: SpanContext): void;
+    static getDataSet(priceQuality: string): number;
+}

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

@@ -0,0 +1,9 @@
+export * from './AbstractMdg2Request';
+export * from './AuthenticationByTokenRequest';
+export * from './AuthenticationTokenRequest';
+export * from './CancelSubscriptionRequest';
+export * from './HighLevelRequest';
+export * from './HTTPProxyRequest';
+export * from './PingRequest';
+export * from './TransportLayerClientRequestHeader';
+export * from './raw';

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

@@ -0,0 +1,5 @@
+import { AbstractMdg2Request } from '../AbstractMdg2Request';
+export declare class RawRequest extends AbstractMdg2Request {
+    constructor(requestJson: Record<string, any>);
+    private _extractRequestAttributes;
+}

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

@@ -0,0 +1,4 @@
+export declare class RawRequestFactory {
+    static createFromString(json: string): Record<string, any>;
+    static createFromObject(json: any): Record<string, any>;
+}