@unblu/embedded-app-component 8.19.1 → 8.21.0

package/dist/lib/index.d.ts

@@ -0,0 +1,39 @@
+import { ApiState } from "./shared/api-state";
+import { CallState } from "./shared/model/call-state";
+import { ConnectionState } from './shared/model/connection-state';
+import { ConversationType } from './shared/model/conversation-type';
+import { ConversationRecipientType } from "./shared/model/conversation-recipient-type";
+import { NewConversationRecipientType } from "./shared/model/new-conversation-recipient-type";
+import { ConversationParticipationType } from "./shared/model/conversation-participation-type";
+import { AgentAvailabilityState } from "./shared/model/agent-availability-state";
+import { ViewMode } from "./view-mode";
+import { UnbluApiError, UnbluErrorType } from "./shared/unblu-api-error";
+import { ConversationState } from "./shared/model/conversation-state";
+import { ConversationEventType } from "./shared/internal/module/conversation-module";
+import { CallStateListener, ConnectionStateListener, ConversationStateListener, CustomActionInvocationListener } from "./shared/conversation";
+export { UnbluEmbeddedAppElement, StateChangeEvent, ReadyEvent, ErrorEvent, DeinitializationStartedEvent, DeinitializationFinishedEvent, ActiveConversationChangeEvent, FullscreenChangeEvent, ViewModeChangeEvent } from "./unblu-embedded-app-element";
+export { UnbluEmbeddedApi, ActiveConversationChangeListener, AgentAvailabilityChangeListener, AgentAvailableChangeListener, ConversationsChangeListener, DeinitializationListener, NotificationCountChangeListener, PersonChangeListener, PersonActivityListener, FullscreenChangeListener, ViewModeChangeListener } from "./unblu-embedded-api";
+export { PersonInfo } from "./shared/model/person-info";
+export { Conversation } from "./shared/conversation";
+export { ConversationInfo } from "./shared/model/conversation-info";
+export { NewConversationInterceptor } from "./shared/new-conversation-interceptor";
+export { NewConversationInterceptorResult } from "./shared/model/new-conversation-interceptor-result";
+export { ConversationRecipient } from "./shared/model/conversation-recipient";
+export { NewConversationRecipient } from "./shared/model/new-conversation-recipient";
+export { ConversationParticipant } from "./shared/model/conversation-participant";
+export { CustomActionInvocation } from "./shared/model/customaction/custom-action-invocation";
+export { ApiState, CallState, ConnectionState, ConversationType, ConversationState, ConversationEventType, ConversationRecipientType, NewConversationRecipientType, ConversationParticipationType, AgentAvailabilityState, ViewMode, UnbluErrorType, UnbluApiError, ConnectionStateListener, ConversationStateListener, CallStateListener, CustomActionInvocationListener, };
+declare const _default: {
+    ApiState: typeof ApiState;
+    CallState: typeof CallState;
+    ConnectionState: typeof ConnectionState;
+    ConversationState: typeof ConversationState;
+    ConversationType: typeof ConversationType;
+    ConversationRecipientType: typeof ConversationRecipientType;
+    NewConversationRecipientType: typeof NewConversationRecipientType;
+    ConversationParticipationType: typeof ConversationParticipationType;
+    AgentAvailabilityState: typeof AgentAvailabilityState;
+    ViewMode: typeof ViewMode;
+    UnbluErrorType: typeof UnbluErrorType;
+};
+export default _default;

package/dist/lib/internal/internal-embedded-api.d.ts

@@ -0,0 +1,16 @@
+import { ApiBridge } from '../shared/internal/api-bridge';
+import { EmbeddedMetaModule } from './module/embedded-meta-module';
+import { ConversationModule } from '../shared/internal/module/conversation-module';
+import { AgentAvailabilityModule } from '../shared/internal/module/agent-availability-module';
+import { GeneralModule } from "./module/general-module";
+import { Configuration } from "../shared/model/configuration";
+export declare class InternalEmbeddedApi {
+    private readonly bridge;
+    readonly configuration: Configuration;
+    readonly meta: EmbeddedMetaModule;
+    readonly general: GeneralModule;
+    readonly conversation: ConversationModule;
+    readonly agentAvailability: AgentAvailabilityModule;
+    constructor(bridge: ApiBridge, configuration: Configuration);
+    checkCompatibility(): void;
+}

package/dist/lib/internal/module/embedded-meta-module.d.ts

@@ -0,0 +1,17 @@
+import { InternalModule } from '../../shared/internal/module/module';
+import { ApiBridge } from '../../shared/internal/api-bridge';
+import { UnbluEmbeddedAppElement } from "../../unblu-embedded-app-element";
+import { DestroyOptions } from "../../shared/internal/model/destroy-options";
+export type EmbeddedMetaEventType = 'deinitializing' | 'deinitialized';
+declare const enum EmbeddedMetaFunction {
+    setUnbluEmbeddedAppElement = "setUnbluEmbeddedAppElement",
+    waitUntilInitialized = "waitUntilInitialized",
+    deinitialize = "deinitialize"
+}
+export declare class EmbeddedMetaModule extends InternalModule<EmbeddedMetaFunction, EmbeddedMetaEventType> {
+    constructor(bridge: ApiBridge);
+    setUnbluEmbeddedAppElement(appElement: UnbluEmbeddedAppElement): Promise<void>;
+    waitUntilInitialized(): Promise<void>;
+    deinitialize(destroyOptions?: DestroyOptions): Promise<boolean>;
+}
+export {};

package/dist/lib/internal/module/general-module.d.ts

@@ -0,0 +1,16 @@
+import { BaseGeneralEventType, BaseGeneralModule } from "../../shared/internal/module/base-general-module";
+import { ViewMode } from "../../view-mode";
+export type GeneralEventType = BaseGeneralEventType | 'fullscreenChange' | 'viewModeChange';
+declare const enum GeneralFunction {
+    isFullscreen = "isFullscreen",
+    setFullscreen = "setFullscreen",
+    getViewMode = "getViewMode",
+    setViewMode = "setViewMode"
+}
+export declare class GeneralModule extends BaseGeneralModule<GeneralFunction, GeneralEventType> {
+    isFullscreen(): Promise<boolean>;
+    setFullscreen(enable: boolean): Promise<void>;
+    getViewMode(): Promise<ViewMode>;
+    setViewMode(mode: ViewMode): Promise<any>;
+}
+export {};

package/dist/lib/shared/api-state.d.ts

@@ -0,0 +1,8 @@
+export declare enum ApiState {
+    INITIAL = "INITIAL",
+    INITIALIZING = "INITIALIZING",
+    INITIALIZED = "INITIALIZED",
+    ERROR = "ERROR",
+    DEINITIALIZING = "DEINITIALIZING",
+    DEINITIALIZED = "DEINITIALIZED"
+}

package/dist/lib/shared/conversation.d.ts

@@ -0,0 +1,313 @@
+import { CallState } from './model/call-state';
+import { ConversationEventType, ConversationModule, ConversationQueueStatus } from './internal/module/conversation-module';
+import { Listener } from './internal/util/event-emitter';
+import { ConversationState } from './model/conversation-state';
+import { ConnectionState } from './model/connection-state';
+import { CustomActionInvocation } from './model/customaction/custom-action-invocation';
+import { CallConnectionState } from "./model/call-connection-state";
+export type ConnectionStateListener = (connectionState: ConnectionState) => void;
+export type ConversationStateListener = (conversationState: ConversationState) => void;
+export type CallStateListener = (callState: CallState) => void;
+export type QueueStatusChangeListener = (conversationQueueStatus: ConversationQueueStatus) => void;
+export type CallConnectionStateChangeListener = (callConnectionState: CallConnectionState) => void;
+/**
+ * Listener called whenever a custom action invocation triggers an API event for the client
+ * @param customActionInvocation The details of the custom action invocation
+ */
+export type CustomActionInvocationListener = (customActionInvocation: CustomActionInvocation) => void;
+/**
+ * #### This class gives API access to the currently active conversation.
+ *
+ * As long as a conversation is active one can register and receive the events provided by this class and call the methods.
+ * Once the conversation is closed this API object will be destroyed and no more event callbacks will be called.
+ * Any subsequent calls will fail.
+ *
+ * Use the {@link CLOSE} event to de-init any code connected to this conversation.
+ */
+export declare class Conversation {
+    private conversationModule;
+    private conversationId;
+    /**
+     * Event emitted when the {@link ConnectionState} of this conversation changes.
+     * @event connectionStateChange
+     * @see {@link on} for listener registration
+     */
+    static readonly CONNECTION_STATE_CHANGE: 'connectionStateChange';
+    /**
+     * Event emitted when the {@link ConversationState} of this conversation changes.
+     * @event conversationStateChange
+     * @see {@link on} for listener registration
+     */
+    static readonly CONVERSATION_STATE_CHANGE: 'conversationStateChange';
+    /**
+     * Event emitted when the {@link CallState} of this conversation changes.
+     * @event callStateChange
+     * @see {@link on} for listener registration
+     */
+    static readonly CALL_STATE_CHANGE: 'callStateChange';
+    /**
+     * Event emitted when the queue status of this conversation changes.
+     * @event queueStatusChange
+     * @see {@link on} for listener registration
+     */
+    static readonly QUEUE_STATUS_CHANGE: 'queueStatusChange';
+    /**
+     * Event emitted when the {@link CallConnectionState} of the conversation changes
+     * @event callConnectionStateChange
+     * @see {@link on} for listener registration
+     */
+    static readonly CALL_CONNECTION_STATE_CHANGE: 'callConnectionStateChange';
+    /**
+     * Event emitted when the conversation ends.
+     * @deprecated The end event is not always available, depending on the configuration. Use the {@link CONVERSATION_STATE_CHANGE} event instead.
+     * @event end
+     * @see {@link on} for listener registration
+     */
+    static readonly END: 'end';
+    /**
+     * Event emitted when the conversation is closed.
+     *
+     * This may happen due to a UI-navigation or an API-call.
+     *
+     * @event close
+     * @see {@link on} for listener registration
+     */
+    static readonly CLOSE: 'close';
+    /**
+     * Event emitted every time a custom action is configured to trigger a JS API event for the current client when a custom action is invoked
+     *
+     * @event customActionInvocation
+     * @see {@link CustomActionInvocationListener}
+     * @see {@link on} for listener registration
+     */
+    static readonly CUSTOM_ACTION_INVOCATION: 'customActionInvocation';
+    private eventEmitter;
+    private internalListeners;
+    private destroyed;
+    /**
+     * @hidden
+     */
+    constructor(conversationModule: ConversationModule, conversationId: string);
+    /**
+     * Registers an event listener for the given event.
+     * @param event The call state change event.
+     * @param listener The listener to be called.
+     * @see {@link CONNECTION_STATE_CHANGE}
+     */
+    on(event: typeof Conversation.CONNECTION_STATE_CHANGE, listener: ConnectionStateListener): void;
+    /**
+     * Registers an event listener for the given event.
+     * @param event The conversation state change event.
+     * @param listener The listener to be called.
+     * @see {@link CONVERSATION_STATE_CHANGE}
+     */
+    on(event: typeof Conversation.CONVERSATION_STATE_CHANGE, listener: ConversationStateListener): void;
+    /**
+     * Registers an event listener for the given event.
+     * @param event The call state change event.
+     * @param listener The listener to be called.
+     * @see {@link CALL_STATE_CHANGE}
+     */
+    on(event: typeof Conversation.CALL_STATE_CHANGE, listener: CallStateListener): void;
+    /**
+     * Registers an event listener for the given event
+     * @param event The call state change event
+     * @param listener The listener to be called
+     * @see {@link QUEUE_STATUS_CHANGE}
+     */
+    on(event: typeof Conversation.QUEUE_STATUS_CHANGE, listener: QueueStatusChangeListener): void;
+    /**
+     * Registers an event listener for the given event
+     * @param event The call connection state change event
+     * @param listener The listener to be called
+     * @see {@link CALL_CONNECTION_STATE_CHANGE}
+     */
+    on(event: typeof Conversation.CALL_CONNECTION_STATE_CHANGE, listener: CallConnectionStateChangeListener): void;
+    /**
+     * Registers an event listener for the given event.
+     * @deprecated The end event is not always available, depending on the configuration. Use instead {@link CONVERSATION_STATE_CHANGE} event.
+     * @param event The end event.
+     * @param listener The listener to be called.
+     * @see {@link END}
+     */
+    on(event: typeof Conversation.END, listener: () => void): void;
+    /**
+     * Registers an event listener for the given event.
+     * @param event The close event.
+     * @param listener The listener to be called.
+     * @see {@link CLOSE}
+     */
+    on(event: typeof Conversation.CLOSE, listener: () => void): void;
+    /**
+     * Registers an event listener for the given event.
+     * @param event The customActionInvocation event.
+     * @param listener The listener to be called.
+     * @see {@link CUSTOM_ACTION_INVOCATION}
+     */
+    on(event: typeof Conversation.CUSTOM_ACTION_INVOCATION, listener: CustomActionInvocationListener): void;
+    /**
+     * Removes a previously registered listener.
+     * @param event The event to unregister from.
+     * @param listener The listener to remove.
+     */
+    off(event: ConversationEventType, listener: Listener): boolean;
+    private onInternal;
+    private offInternal;
+    /**
+     * Returns the ID of this conversation.
+     */
+    getConversationId(): string;
+    /**
+     * Returns the current connection state the conversation is in.
+     *
+     * If the connection is lost, the conversation will automatically try to reconnect using an exponential back-off strategy.
+     * If a fatal error is detected, the state will change to {@link ConnectionState.ERROR}.
+     *
+     * If this happens, the conversation is in it's terminal state. A dialog or other UI will be displayed to the user with details on the failure.
+     * The conversation is not automatically closed in this case.
+     * It may either be closed through a manual action by the visitor (confirming the error) or via the API.
+     *
+     * @see {@link CONNECTION_STATE_CHANGE} if you need to listen to changes.
+     * @return A promise that resolves to the current connection state of the conversation
+     * or is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    getConnectionState(): Promise<ConnectionState>;
+    /**
+     * Returns the current state the conversation is in.
+     * @return A promise that resolves to the current state of the conversation
+     * or is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    getConversationState(): Promise<ConversationState>;
+    /**
+     * Gets the conversation's call state the local participant has, check {@link CallState}
+     * for possible states.
+     * @see {@link CALL_STATE_CHANGE} if you need to listen to changes
+     * @return A promise that resolves to the current call state of the local participant
+     */
+    getCallState(): Promise<CallState>;
+    /**
+     * Gets the conversation's queue status. The position and/or averageWaitingTime
+     * of the return value can be null, if the
+     * feature is disabled for them in the {@link https://www.unblu.com/en/docs/latest/reference/configuration-properties.html#com-unblu-conversation-queuestatus-queuestatusdisplaymode configuration}.
+     * @see {@link QUEUE_STATUS_CHANGE} if you need to listen to changes.
+     * @return A promise that either resolves to the current queue status of the conversation
+     * or resolves empty if the conversation isn't queued.
+     * The promise is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    getQueueStatus(): Promise<ConversationQueueStatus>;
+    /**
+     * Gets the call connection state for the current active call of the local participant.
+     * Check {@link CallConnectionState} for possible states.
+     * @see {@link CALL_CONNECTION_STATE_CHANGE} if you need to listen to changes.
+     * @return A promise that resolves to the current call connection state of the conversation
+     * or is rejected with a {@link UnbluApiError} if the call fails. The promise resolves to
+     * {@link CallConnectionState.DISCONNECTED} if there's no active call.
+     */
+    getCallConnectionState(): Promise<CallConnectionState>;
+    /**
+     * Set custom visitor data on the conversation. Don't use for confidential information. Security-related
+     * data should be stored in the conversation metadata.
+     *
+     * @param visitorData Custom data for the visitor in any format.
+     */
+    setVisitorData(visitorData: String): Promise<void>;
+    /**
+     * Get the custom visitor data from the conversation.
+     *
+     * @return The custom visitor data in the conversation
+     */
+    getVisitorData(): Promise<String>;
+    /**
+     * Starts a voice call in this conversation.
+     *
+     * - If a call is already active, this call will be ignored.
+     * - If the local person doesn't have the right to start a voice call,
+     * the returned promise will be rejected with the unblu error type {@link UnbluErrorType.ACTION_NOT_GRANTED}.
+     * @see {@link CALL_STATE_CHANGE} If you need to listen to changes.
+     * @return A Promise that resolves to null or is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    startAudioCall(): Promise<void>;
+    /**
+     * Starts a video call in this conversation.
+     *
+     * - If a call is already active, this call will be ignored.
+     * - If the local person doesn't have the right to start a video call,
+     * the returned promise will be rejected with the unblu error type {@link UnbluErrorType.ACTION_NOT_GRANTED}.
+     * @see {@link CALL_STATE_CHANGE} If you need to listen to changes.
+     * @return A Promise that resolves to null or is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    startVideoCall(): Promise<void>;
+    /**
+     * Ends and closes this conversation.
+     *
+     * If the local person doesn't have the right to end the conversation,
+     * the returned promise will be rejected with the unblu error type {@link UnbluErrorType.ACTION_NOT_GRANTED}.
+     * @see {@link END} fired after this call.
+     * @see {@link closeConversation} for details on closing a conversation.
+     * @return A Promise that resolves to null or is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    endConversation(): Promise<void>;
+    /**
+     * Leaves and closes this conversation.
+     *
+     * By leaving, the visitor is removed from the active participant list of the conversation.
+     * Once a conversation is left, the visitor can not re-open it. It will not be visible in the conversation history either.
+     *
+     * If the local person doesn't have the right to leave the conversation,
+     * the returned promise will be rejected with the unblu error type {@link UnbluErrorType.ACTION_NOT_GRANTED}.
+     * @see {@link CLOSE} fired after this call.
+     * @see {@link closeConversation} for details on closing a conversation without leaving.
+     * @return A Promise that resolves to null or is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    leaveConversation(): Promise<void>;
+    /**
+     * Closes this conversation locally.
+     *
+     * When called, the connection to this conversation is closed and the overview is displayed.
+     *
+     * **Note that:**
+     * - Closing does NOT end the conversation.
+     * - The person does NOT leave the conversation.
+     * - All Conversation api instances for this conversation will be destroyed.
+     *
+     * The conversation can be joined again either via the UI or using {@link UnbluApi.openConversation}.
+     * @see {@link CLOSE} fired after this call.
+     * @see {@link endConversation} for details on ending a conversation.
+     * @see {@link leaveConversation} for details on leaving a conversation.
+     * @see {@link destroy} for details on destroying a conversation.
+     * @return A Promise that resolves to null or is rejected with a {@link UnbluApiError} if the call fails.
+     */
+    closeConversation(): Promise<void>;
+    private checkNotDestroyed;
+    /**
+     * Returns weather this conversation is destroyed or not.
+     *
+     * Conversations are destroyed if {@link destroy} is called or the conversation is closed.
+     * This usually happens when the user navigates back to an overview or into an other conversation.
+     * @see {@link destroy}
+     * @see {@link CLOSE}
+     * @return Weather this conversation is destroyed or not.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Destroys this conversation API instance.
+     *
+     * Calling destroy will unregister all event listeners and prohibit any further calls to this object.
+     * Once the conversation is destroyed, any subsequent calls will reject the returned promise with {@link UnbluErrorType.ILLEGAL_STATE} as the reason.
+     *
+     * **Note that:**
+     * - Destroying does NOT close the conversation .
+     * - Destroying does NOT end the conversation.
+     * - Destroying does NOT leave the conversation.
+     * - Other instances of the same Conversation will NOT be destroyed.
+     *
+     * This call simply destroys this local API instance to the conversation.
+     *
+     * A destroyed but still open conversation can be accessed again using {@link UnbluApi.getActiveConversation}.
+     *
+     * @see {@link isDestroyed}
+     * @see {@link closeConversation} for details on how to close a conversation
+     * @see {@link endConversation} for details on how to end a conversation
+     */
+    destroy(): void;
+}

package/dist/lib/shared/internal/api-bridge.d.ts

@@ -0,0 +1,36 @@
+import { EventCallback } from './event';
+export declare class ApiBridge {
+    private mountPoint;
+    private mountName;
+    private internal;
+    private readonly eventHandler;
+    /**
+     * instantiates the bridge that links the UNBLU internal API provided by the collaboration server with the UNBLU JS-API
+     * @param mountPoint the global unblu object under which the internal API is registered.
+     */
+    constructor(mountPoint: any, mountName: string);
+    waitUntilLoaded(timeout: number, promise?: Promise<void>): Promise<void>;
+    private checkLoaded;
+    checkCompatibility(): void;
+    /**
+     * Calls an API function of the internal unblu collaboration server API.
+     * @param moduleName The module to which the function belongs.
+     * @param functionName The function to call.
+     * @param args The arguments to pass to the function.
+     */
+    callApiFunction(moduleName: string, functionName: string, args: any[]): Promise<any>;
+    /**
+     * Registers a callback for an event emitted by the internal unblu collaboration server API.
+     * @param module The module that emits the event.
+     * @param event The event name.
+     * @param callback The callback which will be called every time the event is emitted.
+     */
+    on(module: string, event: string, callback: EventCallback): Promise<void>;
+    /**
+     * Unregisters a callback for an event emitted by the internal unblu collaboration server API.
+     * @param module The module that emits the event.
+     * @param event The event name.
+     * @param callback Optionally callback which will be removed, if none is provided all listeners of the event will be removed.
+     */
+    off(module: string, event: string, callback?: EventCallback): Promise<void>;
+}

package/dist/lib/shared/internal/event.d.ts

@@ -0,0 +1,6 @@
+export interface Event<T> {
+    module: string;
+    name: string;
+    data: T;
+}
+export type EventCallback = (event: Event<any>) => void;

package/dist/lib/shared/internal/initialized-unblu-api.d.ts

@@ -0,0 +1,10 @@
+import { DestroyOptions } from "./model/destroy-options";
+/**
+ * @hidden
+ */
+export declare interface InitializedUnbluApi {
+    /**
+     @hidden
+     */
+    deinitialize(destroyOptions?: DestroyOptions): Promise<void>;
+}

package/dist/lib/shared/internal/initialized-unblu-element.d.ts

@@ -0,0 +1,10 @@
+import { DestroyOptions } from "./model/destroy-options";
+/**
+ * @hidden
+ */
+export declare interface InitializedUnbluElement extends HTMLElement {
+    /**
+     @hidden
+     */
+    deinitialize(destroyOptions?: DestroyOptions): Promise<void>;
+}

package/dist/lib/shared/internal/java-error-codes.d.ts

@@ -0,0 +1,5 @@
+export declare const CATEGORY_INVALID_FUNCTION_CALL = 1;
+export declare const CATEGORY_INVALID_FUNCTION_ARGUMENTS = 2;
+export declare const CATEGORY_EXECUTION_EXCEPTION = 3;
+export declare const CATEGORY_ACTION_NOT_GRANTED = 4;
+export declare const CATEGORY_TIMEOUT = 5;

package/dist/lib/shared/internal/model/destroy-mode.d.ts

@@ -0,0 +1,4 @@
+export declare enum DestroyMode {
+    FULL = "FULL",
+    REINIT = "REINIT"
+}

package/dist/lib/shared/internal/model/destroy-options.d.ts

@@ -0,0 +1,4 @@
+import { DestroyMode } from "./destroy-mode";
+export declare class DestroyOptions {
+    destroyMode: DestroyMode;
+}

package/dist/lib/shared/internal/module/agent-availability-module.d.ts

@@ -0,0 +1,14 @@
+import { InternalModule } from './module';
+import { ApiBridge } from '../api-bridge';
+import { AgentAvailabilityState } from '../../model/agent-availability-state';
+export type AgentAvailabilityEventType = 'availableChange' | 'availabilityChange';
+declare const enum AgentAvailabilityFunction {
+    isAgentAvailable = "isAgentAvailable",
+    getAgentAvailabilityState = "getAgentAvailabilityState"
+}
+export declare class AgentAvailabilityModule extends InternalModule<AgentAvailabilityFunction, AgentAvailabilityEventType> {
+    constructor(bridge: ApiBridge);
+    isAgentAvailable(): Promise<boolean>;
+    getAgentAvailabilityState(): Promise<AgentAvailabilityState>;
+}
+export {};

package/dist/lib/shared/internal/module/base-general-module.d.ts

@@ -0,0 +1,35 @@
+import { ApiBridge } from "../api-bridge";
+import { InternalModule } from "./module";
+import { NewConversationInterceptor } from "../../new-conversation-interceptor";
+import { ConversationType } from "../../model/conversation-type";
+import { PersonInfo } from "../../model/person-info";
+import { ConversationInfo } from "../../model/conversation-info";
+import { NewConversationRecipient } from "../../model/new-conversation-recipient";
+export type BaseGeneralEventType = 'activeConversationChange' | 'conversationsChange' | 'notificationCountChange' | 'personChange' | 'personActivity';
+export declare enum BaseGeneralFunction {
+    startConversation = "startConversation",
+    setNewConversationInterceptor = "setNewConversationInterceptor",
+    joinConversation = "joinConversation",
+    openConversation = "openConversation",
+    getActiveConversation = "getActiveConversation",
+    getConversations = "getConversations",
+    getNotificationCount = "getNotificationCount",
+    getPersonInfo = "getPersonInfo",
+    setPersonNickname = "setPersonNickname",
+    addPersonLabel = "addPersonLabel",
+    removePersonLabel = "removePersonLabel"
+}
+export declare class BaseGeneralModule<T extends string | BaseGeneralFunction, E extends BaseGeneralEventType | string> extends InternalModule<BaseGeneralFunction | T, E> {
+    constructor(bridge: ApiBridge);
+    startConversation(type: ConversationType, visitorName?: string, visitorData?: string, recipient?: NewConversationRecipient, languageTag?: string): Promise<string>;
+    setNewConversationInterceptor(callback: NewConversationInterceptor): Promise<void>;
+    joinConversation(pin: string, visitorName?: string): Promise<string>;
+    openConversation(conversationId: string): Promise<void>;
+    getActiveConversation(): Promise<string | null>;
+    getConversations(): Promise<ConversationInfo[]>;
+    getNotificationCount(): Promise<number>;
+    getPersonInfo(): Promise<PersonInfo>;
+    setPersonNickname(nickname: string): Promise<void>;
+    addPersonLabel(labelName: string): Promise<void>;
+    removePersonLabel(labelName: string): Promise<void>;
+}

package/dist/lib/shared/internal/module/conversation-module.d.ts

@@ -0,0 +1,64 @@
+import { InternalModule } from './module';
+import { ApiBridge } from '../api-bridge';
+import { CallState } from '../../model/call-state';
+import { ConversationState } from '../../model/conversation-state';
+import { ConnectionState } from '../../model/connection-state';
+import { CallConnectionState } from "../../model/call-connection-state";
+export interface ConversationCallState {
+    conversationId: string;
+    callState: CallState;
+}
+export interface ConversationConnectionState {
+    conversationId: string;
+    connectionState: ConnectionState;
+}
+export interface ConversationWithState {
+    conversationId: string;
+    conversationState: ConversationState;
+}
+export interface ConversationQueueStatus {
+    conversationId: string;
+    /**
+     * Current position in the queue, can be null or left out if feature is disabled
+     */
+    position?: number | null;
+    /**
+     * Calculated waiting time in milliseconds, can be null or left out if feature is disabled
+     */
+    averageWaitingTime?: number | null;
+}
+export interface ConversationCallConnectionState {
+    conversationId: string;
+    callConnectionState: ConversationState;
+}
+export type ConversationEventType = 'connectionStateChange' | 'conversationStateChange' | 'end' | 'close' | 'personChange' | 'callStateChange' | 'invitationsChange' | 'customActionInvocation' | 'queueStatusChange' | 'callConnectionStateChange';
+declare const enum ConversationFunction {
+    getConnectionState = "getConnectionState",
+    getConversationState = "getConversationState",
+    getCallState = "getCallState",
+    startAudioCall = "startAudioCall",
+    startVideoCall = "startVideoCall",
+    endConversation = "endConversation",
+    leaveConversation = "leaveConversation",
+    closeConversation = "closeConversation",
+    setVisitorData = "setVisitorData",
+    getVisitorData = "getVisitorData",
+    getQueueStatus = "getQueueStatus",
+    getCallConnectionState = "getCallConnectionState"
+}
+export declare class ConversationModule extends InternalModule<ConversationFunction, ConversationEventType> {
+    constructor(bridge: ApiBridge);
+    getConnectionState(conversationId: string): Promise<ConnectionState>;
+    getConversationState(conversationId: string): Promise<ConversationState>;
+    getCallState(conversationId: string): Promise<CallState>;
+    startAudioCall(conversationId: string): Promise<void>;
+    startVideoCall(conversationId: string): Promise<void>;
+    endConversation(conversationId: string): Promise<void>;
+    leaveConversation(conversationId: string): Promise<void>;
+    closeConversation(conversationId: string): Promise<void>;
+    setVisitorData(visitorData: String): Promise<void>;
+    getVisitorData(): Promise<String>;
+    getQueueStatus(conversationId: string): Promise<ConversationQueueStatus>;
+    getCallConnectionState(conversationId: string): Promise<CallConnectionState>;
+}
+export {};

package/dist/lib/shared/internal/module/module.d.ts

@@ -0,0 +1,10 @@
+import { ApiBridge } from '../api-bridge';
+import { EventCallback } from '../event';
+export declare class InternalModule<T extends string, E extends string> {
+    private bridge;
+    moduleName: string;
+    constructor(bridge: ApiBridge, moduleName: string);
+    protected callApiFunction(functionName: T, args: any[]): Promise<any>;
+    on(eventName: E, listener: EventCallback): Promise<void>;
+    off(eventName: E, listener: EventCallback): Promise<void>;
+}

package/dist/lib/shared/internal/unblu-floating-api.d.ts

@@ -0,0 +1,15 @@
+import { ApiState } from "../api-state";
+import { InitializedUnbluApi } from "./initialized-unblu-api";
+/**
+ * @hidden
+ */
+export declare interface UnbluFloatingApi {
+    api: UnbluFloatingApiFactory;
+}
+/**
+ * @hidden
+ */
+export declare interface UnbluFloatingApiFactory {
+    initialize(): Promise<InitializedUnbluApi>;
+    getApiState(): ApiState;
+}