@wxcc-desktop/sdk 1.2.6 → 1.2.10

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+import { createActionsJsApi } from "./jsapi/actions-jsapi";
+import { createAgentContactJsApi } from "./jsapi/agent-contact-jsapi";
+import { createAgentStateInfoJsApi } from "./jsapi/agent-state-info-jsapi";
+import { createConfigJsApi } from "./jsapi/config-jsapi";
+import { createDialerJsApi } from "./jsapi/dialer-jsapi";
+import { createI18NJsApi } from "./jsapi/i18n-jsapi";
+import { createLoggerJsApi } from "./jsapi/logger-jsapi";
+import { createScreenPopJsApi } from "./jsapi/screenpop-jsapi";
+import { createShortcutKeyJsApi } from "./jsapi/shortcut-key-jsapi";
+export declare type AgentXJsApi = {
+    config: ReturnType<typeof createConfigJsApi>;
+    logger: ReturnType<typeof createLoggerJsApi>;
+    shortcutKey: ReturnType<typeof createShortcutKeyJsApi>;
+    agentContact: ReturnType<typeof createAgentContactJsApi>;
+    agentStateInfo: ReturnType<typeof createAgentStateInfoJsApi>;
+    dialer: ReturnType<typeof createDialerJsApi>;
+    screenpop: ReturnType<typeof createScreenPopJsApi>;
+    i18n: ReturnType<typeof createI18NJsApi>;
+    actions: ReturnType<typeof createActionsJsApi>;
+};
+export declare const Desktop: AgentXJsApi;

package/dist/types/jsapi/actions-jsapi.d.ts

@@ -0,0 +1,33 @@
+import type { AgentContactSharedActions, GeneralNotificationsSharedActions } from "@wxcc-desktop/sdk-types";
+import { AgentxService } from "@wxcc-desktop/sdk-types";
+import { createJsApiLogger } from "./common/_logger";
+import { createServiceChecker } from './common/_service-checker';
+declare type Config = {
+    logger: ReturnType<typeof createJsApiLogger>;
+    serviceChecker: ReturnType<typeof createServiceChecker>;
+};
+export declare class ActionsJsApi {
+    private readonly logger;
+    private readonly serviceChecker;
+    private SERVICE?;
+    private sourceActionsChannels;
+    private destinationActionsChannels;
+    private checkService;
+    private lastReqTs;
+    private lastReqN;
+    private getNextReqId;
+    constructor(config: Config);
+    init(SERVICE?: AgentxService): void;
+    cleanup(): void;
+    fireGeneralSilentNotification(...args: GeneralNotificationsSharedActions.FireSilent.ReqPayloadParameters): void;
+    fireGeneralAutoDismissNotification(...args: GeneralNotificationsSharedActions.FireAutoDismiss.ReqPayloadParameters): Promise<GeneralNotificationsSharedActions.FireAutoDismiss.ResPayloadParameters | undefined>;
+    fireGeneralAcknowledgeNotification(...args: GeneralNotificationsSharedActions.FireAcknowledge.ReqPayloadParameters): Promise<GeneralNotificationsSharedActions.FireAcknowledge.ResPayloadParameters | undefined>;
+    addCustomTask(...args: AgentContactSharedActions.AddCustomContact.ReqPayloadParameters): void;
+    getTaskMap(): Promise<import("@wxcc-desktop/sdk-types/agentx/store/store-agent-contact").TaskMap | undefined>;
+    getMediaTypeQueue(mediaType: string): Promise<import("@wxcc-desktop/sdk-types/agentx/store/store-agent-contact").TaskMap | undefined>;
+    getToken(): Promise<string | undefined>;
+    getIdleCodes(): Promise<import("@agentx/agentx-services").Service.Aqm.Configs.Entity[] | undefined>;
+    getWrapUpCodes(): Promise<import("@agentx/agentx-services").Service.Aqm.Configs.WrapUpReason[] | undefined>;
+}
+export declare const createActionsJsApi: () => ActionsJsApi;
+export {};

package/dist/types/jsapi/agent-contact-jsapi.d.ts

@@ -0,0 +1,430 @@
+import { AgentxService, Service } from "@wxcc-desktop/sdk-types";
+import { createJsApiLogger } from "./common/_logger";
+import { createServiceChecker } from "./common/_service-checker";
+import { AqmServiceEntityEvents } from "./common/_service-events";
+declare type Listeners = {
+    eAgentContact: Parameters<AgentxService["aqm"]["contact"]["eAgentContact"]["listen"]>[0];
+    eAgentContactAssigned: Parameters<AgentxService["aqm"]["contact"]["eAgentContactAssigned"]["listen"]>[0];
+    eAgentContactEnded: Parameters<AgentxService["aqm"]["contact"]["eAgentContactEnded"]["listen"]>[0];
+    eAgentContactWrappedUp: Parameters<AgentxService["aqm"]["contact"]["eAgentContactWrappedUp"]["listen"]>[0];
+    eAgentOfferContact: Parameters<AgentxService["aqm"]["contact"]["eAgentOfferContact"]["listen"]>[0];
+    eAgentOfferContactRona: Parameters<AgentxService["aqm"]["contact"]["eAgentOfferContactRona"]["listen"]>[0];
+    eAgentOfferConsult: Parameters<AgentxService["aqm"]["contact"]["eAgentOfferConsult"]["listen"]>[0];
+    eAgentWrapup: Parameters<AgentxService["aqm"]["contact"]["eAgentWrapup"]["listen"]>[0];
+    eAgentContactHeld: Parameters<AgentxService["aqm"]["contact"]["eAgentContactHeld"]["listen"]>[0];
+    eAgentContactUnHeld: Parameters<AgentxService["aqm"]["contact"]["eAgentContactUnHeld"]["listen"]>[0];
+    eCallRecordingStarted: Parameters<AgentxService["aqm"]["contact"]["eCallRecordingStarted"]["listen"]>[0];
+    eAgentConsultCreated: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultCreated"]["listen"]>[0];
+    eAgentConsultConferenced: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultConferenced"]["listen"]>[0];
+    eAgentConsultEnded: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultEnded"]["listen"]>[0];
+    eAgentCtqCancelled: Parameters<AgentxService["aqm"]["contact"]["eAgentCtqCancelled"]["listen"]>[0];
+    eAgentConsulting: Parameters<AgentxService["aqm"]["contact"]["eAgentConsulting"]["listen"]>[0];
+    eAgentConsultFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultFailed"]["listen"]>[0];
+    eAgentConsultEndFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultEndFailed"]["listen"]>[0];
+    eAgentCtqFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentCtqFailed"]["listen"]>[0];
+    eAgentCtqCancelFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentCtqCancelFailed"]["listen"]>[0];
+    eAgentConsultConferenceEndFailed: Parameters<AgentxService["aqm"]["contact"]["eAgentConsultConferenceEndFailed"]["listen"]>[0];
+};
+declare type AqmContactEvents = AqmServiceEntityEvents<Listeners>;
+declare type Config = {
+    logger: ReturnType<typeof createJsApiLogger>;
+    serviceChecker: ReturnType<typeof createServiceChecker>;
+    aqmEvents: AqmContactEvents;
+};
+export declare class AgentContactJsApi {
+    private readonly logger;
+    private readonly serviceChecker;
+    private readonly aqmEvents;
+    private SERVICE?;
+    private checkService;
+    constructor(config: Config);
+    init(SERVICE?: AgentxService): void;
+    cleanup(): void;
+    accept(p: {
+        interactionId: string;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    consultAccept(p: {
+        interactionId: string;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    buddyAgents(p: {
+        data: Service.Aqm.Contact.BuddyAgents;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        eventType: string;
+        agentId: string;
+        trackingId: string;
+        agentSessionId: string;
+        orgId: string;
+        type: string;
+        agentList: Service.Aqm.Contact.BuddyDetails[];
+    }> | undefined>;
+    end(p: {
+        interactionId: string;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    consultEnd(p: {
+        interactionId: string;
+        isConsult: boolean;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    cancelCtq(p: {
+        interactionId: string;
+        data: Service.Aqm.Contact.cancelCtq;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    wrapup(p: {
+        interactionId: string;
+        data: Service.Aqm.Contact.WrapupPayLoad;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    vteamTransfer(p: {
+        interactionId: string;
+        data: Service.Aqm.Contact.vteamTransferPayLoad;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    blindTransfer(p: {
+        interactionId: string;
+        data: Service.Aqm.Contact.blindTransferPayLoad;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    hold(p: {
+        interactionId: string;
+        data: {
+            mediaResourceId: string;
+        };
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    unHold(p: {
+        interactionId: string;
+        data: {
+            mediaResourceId: string;
+        };
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    consult(p: {
+        interactionId: string;
+        data: Service.Aqm.Contact.ConsultPayload | Service.Aqm.Contact.ConsultDN | Service.Aqm.Contact.ConsultAgent | Service.Aqm.Contact.ConsultQueue;
+        url: string;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    consultConference(p: {
+        interactionId: string;
+        data: Service.Aqm.Contact.ConsultPayload;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    decline(p: {
+        interactionId: string;
+        data: {
+            mediaResourceId: string;
+        };
+        isConsult: boolean;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    consultTransfer(p: {
+        interactionId: string;
+        data: Service.Aqm.Contact.consultTransferPayLoad;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    vteamList(p: {
+        data: Service.Aqm.Contact.VTeam;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        data: {
+            vteamList: Service.Aqm.Contact.VteamDetails[];
+            allowConsultToQueue: boolean;
+        };
+        jsMethod: string;
+        callData: string;
+        agentSessionId: string;
+    }> | undefined>;
+    pauseRecording(p: {
+        interactionId: string;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    resumeRecording(p: {
+        interactionId: string;
+        data: {
+            autoResumed: boolean;
+        };
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        mediaResourceId: string;
+        eventType: string;
+        agentId: string;
+        destAgentId: string;
+        trackingId: string;
+        consultMediaResourceId: string;
+        interaction: Service.Aqm.Contact.Interaction;
+        interactionId: string;
+        orgId: string;
+        owner: string;
+        queueMgr: string;
+        type: string;
+        ronaTimeout?: number | undefined;
+        isConsulted?: boolean | undefined;
+        isConferencing: boolean;
+        updatedBy?: string | undefined;
+        destinationType?: string | undefined;
+    }> | undefined>;
+    addEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]): void;
+    addOnceEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]): void;
+    removeEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]): void;
+    removeOnceEventListener<T extends keyof Listeners>(eventName: T, listener: Listeners[T]): void;
+    removeAllEventListeners(): void;
+}
+export declare const createAgentContactJsApi: () => AgentContactJsApi;
+export {};

package/dist/types/jsapi/agent-state-info-jsapi.d.ts

@@ -0,0 +1,88 @@
+import { AgentxService, Service } from "@wxcc-desktop/sdk-types";
+import { createJsApiLogger } from "./common/_logger";
+import { createServiceChecker } from "./common/_service-checker";
+declare type IdleCodeData = {
+    id: number;
+    name: string;
+};
+declare type LatestInfoData = {
+    agentName?: string;
+    agentProfileID?: string;
+    agentSessionId?: string;
+    teamId?: string;
+    teamName?: string;
+    dn?: string;
+    status?: string;
+    subStatus?: string;
+    idleCode?: IdleCodeData;
+    idleCodes?: Service.Aqm.Configs.Entity[];
+    wrapupCodes?: Service.Aqm.Configs.Entity[];
+    outDialRegex?: string;
+    isOutboundEnabledForTenant?: boolean;
+    isOutboundEnabledForAgent?: boolean;
+    isAdhocDialingEnabled?: boolean;
+    isEndCallEnabled?: boolean;
+    isEndConsultEnabled?: boolean;
+    allowConsultToQueue?: boolean;
+    isAgentAvailableAfterOutdial?: boolean;
+    isCampaignManagementEnabled?: boolean;
+    agentPersonalStatsEnabled?: boolean;
+};
+declare type Listeners = {
+    updated: (p: {
+        name: keyof LatestInfoData;
+        value?: string;
+        oldValue?: string;
+    }[]) => void;
+};
+declare type Events = keyof Listeners;
+declare type Config = {
+    logger: ReturnType<typeof createJsApiLogger>;
+    serviceChecker: ReturnType<typeof createServiceChecker>;
+};
+export declare class AgentStateInfoJsapi {
+    private readonly emitter;
+    private readonly logger;
+    private readonly serviceChecker;
+    private SERVICE?;
+    private checkService;
+    private listeners;
+    private emit;
+    private update;
+    private static getOutdialRegex;
+    constructor(config: Config);
+    private static findTeamName;
+    private teams;
+    private idleCodes;
+    latestData: LatestInfoData;
+    init(SERVICE?: AgentxService): Promise<void>;
+    cleanup(): void;
+    private fetchLatestData;
+    private subscribeSelfDataEvents;
+    private unsubscribeSelfDataEvents;
+    stateChange(stateData: {
+        state: "Available" | "Idle";
+        auxCodeIdArray: string;
+    }): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        eventType: "AgentDesktopMessage";
+        agentId: string;
+        trackingId: string;
+        auxCodeId: string;
+        agentSessionId: string;
+        orgId: string;
+        status: string;
+        subStatus: "Available" | "Idle";
+        lastIdleCodeChangeTimestamp: number;
+        lastStateChangeTimestamp: number;
+        type: "AgentStateChangeSuccess";
+    }> | undefined>;
+    mockOutdialAniList(): Promise<import("@wxcc-desktop/sdk-types/agentx-services/core/aqm-reqs").Msg<{
+        data: Record<string, any>;
+    }> | undefined>;
+    fetchAddressBooks(): Promise<Service.Aqm.Agent.AddressBooks | undefined>;
+    addEventListener<T extends Events>(eventName: T, listener: Listeners[T]): void;
+    removeEventListener<T extends Events>(eventName: T, listener: Listeners[T]): void;
+    removeAllEventListeners(): void;
+}
+export declare const createAgentStateInfoJsApi: () => AgentStateInfoJsapi;
+export {};

package/dist/types/jsapi/common/_logger.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from "@uuip/unified-ui-platform-sdk";
+declare type SeverityLogger = Pick<Logger.Service, "info" | "warn" | "error">;
+export declare const createJsApiLogger: (logger: SeverityLogger, subPrefix: string) => SeverityLogger;
+export {};

package/dist/types/jsapi/common/_service-checker.d.ts

@@ -0,0 +1,12 @@
+import { AgentxService } from "@wxcc-desktop/sdk-types";
+import { createJsApiLogger } from "./_logger";
+declare type Config = {
+    logger: ReturnType<typeof createJsApiLogger>;
+};
+export declare class ServiceChecker {
+    private readonly logger;
+    constructor(config: Config);
+    check(SERVICE?: AgentxService): boolean;
+}
+export declare const createServiceChecker: (config: Config) => ServiceChecker;
+export {};

package/dist/types/jsapi/common/_service-events.d.ts

@@ -0,0 +1,31 @@
+import { AgentxService } from "@wxcc-desktop/sdk-types";
+import { createJsApiLogger } from "./_logger";
+declare type AqmServiceEntities = AgentxService["aqm"]["agent"] | AgentxService["aqm"]["configs"] | AgentxService["aqm"]["contact"] | AgentxService["aqm"]["dialer"] | AgentxService["aqm"]["screenpop"];
+declare type Events<Listeners> = keyof Listeners;
+declare type Config = {
+    logger: ReturnType<typeof createJsApiLogger>;
+};
+declare type InitConfig = {
+    aqmServiceEntity: AqmServiceEntities;
+    aqmServiceEntityString: string;
+};
+export declare class AqmServiceEntityEvents<Listeners> {
+    private readonly logger;
+    private aqmServiceEntity?;
+    private aqmServiceEntityString?;
+    isInited: boolean;
+    constructor(config: Config);
+    init(config: InitConfig): void;
+    cleanup(): void;
+    private listeners;
+    private listenersOnce;
+    private _addEventListener;
+    private _removeEventListener;
+    addEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]): void;
+    addOnceEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]): void;
+    removeEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]): void;
+    removeOnceEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]): void;
+    removeAllEventListeners(): void;
+}
+export declare const createServiceEvents: <Listeners>(config: Config) => AqmServiceEntityEvents<Listeners>;
+export {};

package/dist/types/jsapi/config-jsapi.d.ts

@@ -0,0 +1,26 @@
+import { AgentxService } from "@wxcc-desktop/sdk-types";
+import { createJsApiLogger } from "./common/_logger";
+declare type Listeners = {
+    inited: () => void;
+    cleaned: () => void;
+};
+declare type Events = keyof Listeners;
+export declare class ConfigJsApi {
+    private readonly emitter;
+    private readonly logger;
+    private agentxSERVICE?;
+    private waitUntil;
+    constructor(config: {
+        logger: ReturnType<typeof createJsApiLogger>;
+        SERVICE: AgentxService;
+    });
+    private checkService;
+    private emit;
+    init(): Promise<void>;
+    cleanup(): void;
+    get clientLocale(): string;
+    addEventListener<T extends Events>(eventName: T, listener: Listeners[T]): void;
+    removeEventListener<T extends Events>(eventName: T, listener: Listeners[T]): void;
+}
+export declare const createConfigJsApi: (SERVICE: AgentxService) => ConfigJsApi;
+export {};