barracuda-client-api/dist/BarracudaClient.d.ts

API Client to connect to Barracuda Enterprise Service Bus

import { IBarracudaClientFullDuplex, BarracudaConnectionStatus, BarracudaConnectionProps, IBarracudaBridgeSubscriptionResponse, IBarracudaBridgeConnectionStatus, BarracudaTopicInfoType, BarracudaBridgeSubscriptionStatus, IBarracudaBridgeRequestResponse, IBarracudaClient, BarracudaBuildInfo, BarracudaPublishingProps, BarracudaErrorHandler, BarracudaQuery, QuerySubscription, BarracudaQuerySort, BarracudaDefaultProps, ConnectionStateChangeHandler, SubscriptionUpdateHandler } from "./IBarracudaClient";
import { loglevels } from "./logging/index";
export declare enum BarracudaCommand {
    close = "close"
}
export declare enum BarracudaBridgeReadQueryCommands {
    aggregate = "aggregate",
    diffSubscribe = "diffSubscribe",
    snapshot = "snapshot",
    snapshotAndDiffSubscribe = "snapshotAndDiffSubscribe",
    snapshotAndSubscribe = "snapshotAndSubscribe",
    subscribe = "subscribe"
}
export declare enum BarracudaBridgeAggregateCommands {
    unsubscribe = "unsubscribe"
}
export interface IBarracudaSubscriptionStatus extends Omit<IBarracudaSubscription<unknown>, "onMessage" | "inboundQueue"> {
}
interface IBarracudaSubscription<T> {
    unsubscribed: boolean;
    pendingUnsubscribe: boolean;
    subscriptionId: string;
    requestBarracudaQuery?: BarracudaQuery<T>;
    requestCommandType?: BarracudaBridgeReadQueryCommands;
    responseMsg: IBarracudaBridgeRequestResponse | undefined;
    onMessage?: (msg: IBarracudaBridgeSubscriptionResponse<T>) => void;
    inboundQueue: IBarracudaBridgeSubscriptionResponse<T>[];
    lastServerStatus: BarracudaBridgeSubscriptionStatus;
    confirmed: boolean;
    lastServerStatusDt: Date;
    heartbeatPeriod: number;
    messageCount: number;
    lastError?: string;
    excludeFromRecovery?: boolean;
}
export declare const DefaultQueryTopValue = 50000;
export declare class BarracudaClient implements IBarracudaClientFullDuplex {
    private skipReconnecting;
    private readonly _uid;
    private ws;
    private _requests;
    private _onStale;
    private _staleTriggerTimer;
    private _staleNotice;
    private _defaultRestPublishEndPoint;
    private _defaultInstance;
    private _connectedAckAtLeastOnce;
    private _reconnectCounter;
    private _subscriptionHistory;
    constructor(defaultProps?: BarracudaDefaultProps);
    static get Build(): BarracudaBuildInfo;
    private _appName;
    get appName(): string | undefined;
    private _appVersion;
    get appVersion(): string | undefined;
    private _lastConnectionProps;
    private _lastPong;
    get lastPong(): Date | undefined;
    get serverClientId(): any;
    private _serverDebug?;
    get serverDebug(): boolean;
    get restPublishEndPoint(): string;
    private _gaToken;
    get gaToken(): string | undefined;
    private _connectionCounter;
    private _connectionAckMessage;
    get serviceHost(): string | undefined;
    private _reconnect;
    get reconnect(): boolean;
    set reconnect(value: boolean);
    private _onConnectionError?;
    get onConnectionError(): BarracudaErrorHandler | undefined;
    set onConnectionError(value: BarracudaErrorHandler | undefined);
    private _onError?;
    get onError(): BarracudaErrorHandler;
    set onError(value: BarracudaErrorHandler);
    private _onConnectionStateChange?;
    get onConnectionStateChange(): ConnectionStateChangeHandler | undefined;
    set onConnectionStateChange(value: ConnectionStateChangeHandler | undefined);
    private _onSubscriptionUpdate;
    get onSubscriptionUpdate(): SubscriptionUpdateHandler | undefined;
    set onSubscriptionUpdate(value: SubscriptionUpdateHandler | undefined);
    private _loglevel;
    get loglevel(): loglevels;
    set loglevel(value: loglevels);
    connectionState: BarracudaConnectionStatus;
    get uid(): string;
    private _logUid;
    get logUid(): string;
    get connectionAckMessage(): IBarracudaBridgeConnectionStatus | undefined;
    get lastConnectionProps(): BarracudaConnectionProps;
    get defaultConnectionProps(): BarracudaDefaultProps;
    connect(overrideProps?: BarracudaConnectionProps): Promise<IBarracudaClient>;
    _emulateServerDisconnect(): void;
    close(): void;
    get connectionCounter(): number;
    bcLog(props: BarracudaConnectionProps): string;
    disconnect(): Promise<{
        code: number;
        reason: string;
    }>;
    private _subscriptions;
    get subscriptions(): IBarracudaSubscriptionStatus[];
    get previousSessionSubscriptions(): IBarracudaSubscriptionStatus[];
    snapshot<T>(instance: string, topic: string, message: (m: IBarracudaBridgeSubscriptionResponse<T>) => void, filter?: string, top?: number, project?: string[], sort?: BarracudaQuerySort, heartbeatPeriod?: number): Promise<string>;
    snapshotAndSubscribe<T>(instance: string, topic: string, message: (m: IBarracudaBridgeSubscriptionResponse<T>) => void, filter?: string, top?: number, project?: string[], sort?: BarracudaQuerySort, heartbeatPeriod?: number): Promise<string>;
    snapshotAndDiffSubscribe<T>(instance: string, topic: string, message: (m: IBarracudaBridgeSubscriptionResponse<T>) => void, filter?: string, top?: number, project?: string[], sort?: BarracudaQuerySort, heartbeatPeriod?: number): Promise<string>;
    subscribeDiff<T>(instance: string, topic: string, message: (m: IBarracudaBridgeSubscriptionResponse<T>) => void, filter?: string, top?: number, project?: string[], sort?: BarracudaQuerySort, heartbeatPeriod?: number): Promise<string>;
    subscribe<T>(instance: string, topic: string, message: (m: IBarracudaBridgeSubscriptionResponse<T>) => void, filter?: string, top?: number, project?: string[], sort?: BarracudaQuerySort, heartbeatPeriod?: number): Promise<string>;
    unsubscribe(subscriptionId: string): Promise<void>;
    aggregate<T>(topic: any, pipeline: any[], instance?: any, maxTimeMS?: number, batchSize?: number): Promise<any[] | undefined>;
    subscribeQuery<T>(commandType: BarracudaBridgeReadQueryCommands, queryDetails: BarracudaQuery<T>): Promise<QuerySubscription>;
    getTopicInfo(topic: string, infoType: BarracudaTopicInfoType, instance?: string): Promise<{
        result: any | any[];
    } | undefined>;
    setOnStaleSubscriptionAlert(onStale: SubscriptionUpdateHandler, seconds?: number): void;
    private _endpoint?;
    get endpoint(): string | undefined;
    set endpoint(value: string | undefined);
    get instance(): string | undefined;
    set instance(value: string | undefined);
    private _staleTimeOutMs;
    get staleTimeOutMs(): number;
    private get ll();
    private static getConnectionProps;
    private static createRequest;
    private static createBBMsgType;
    private static createRequestSubscription;
    private static shareSubscriptionDetails;
    private static hasError;
    send(topic: string, msg: any, type: BarracudaPublisherCommandType, props?: BarracudaPublishingProps): Promise<{
        reply?: string;
        message?: string;
    } | undefined>;
    sendWithKey(topic: string, key: string, msg: any): Promise<void>;
    private safeTriggerOnSubscriptionChanged;
    private safeTriggerOnStale;
    private sendMessage;
    private handleSendError;
    private setProps;
    private triggerOnConnectionStateChange;
    private scheduleReconnect;
    private callHandlerSafely;
    private startSubscriptionListener;
    private handleUnknownMessageType;
    private requestQueryCommand;
    private sendRequest;
    private handleSubscriptionResponse;
    private processSubscriptionMessageQueue;
    private handleRequestResponse;
    private throwIfMissingField;
    private isMissingFields;
    private handleSubscriptionStatus;
    private detectStaleSubscriptions;
    private clearConnectionState;
    private pong;
    private ping;
    private handlePing;
}
export declare enum BarracudaPublisherCommandType {
    replace = "replace",
    update = "update",
    upsert = "upsert",
    delete = "delete"
}
export interface IBarracudaPublisherMeta {
    _ver: number;
    _payload_ver: number;
    topic: string;
    expiration: number;
    sequenceId: number;
    bPublisherCommand: BarracudaPublisherCommandType;
    bPublisherTst: number;
    bPublisherClient: {
        lang: string;
        version: string;
    };
    bPublisherName: string;
}
export interface IBarracudaPublisherMessage {
    _barracuda_meta: IBarracudaPublisherMeta;
}
export {};
//# sourceMappingURL=BarracudaClient.d.ts.map