@trii/types 2.10.760 → 2.10.761

package/dist/src/Conversations/Queue.d.ts

@@ -0,0 +1,107 @@
+import { ID } from './Conversation';
+import { QueueRoutingPolicy } from './Routing';
+export declare const CONVERSATION_QUEUES_COLLECTION = "conversation_queues";
+export type QueueSlaTransferBehavior = 'preserve' | 'restart' | 'recalculate';
+export type ConversationQueueSlaConfig = {
+    enabled: false;
+    policyId?: never;
+    policyVersion?: never;
+    onTransferIn?: never;
+} | {
+    enabled: true;
+    policyId: ID;
+    policyVersion: number;
+    onTransferIn: QueueSlaTransferBehavior;
+};
+/**
+ * distribution:
+ *   visibility follows shared, manual_pull or exclusive routing semantics.
+ * all_current:
+ *   all authorized queue members can see current queue conversations.
+ */
+export type QueueMemberAudienceMode = 'distribution' | 'all_current' | 'none';
+export type QueueSupervisorAudienceMode = 'all_current' | 'sla_only' | 'escalations_only' | 'none';
+export interface ConversationQueueAudienceConfig {
+    members: {
+        mode: QueueMemberAudienceMode;
+        requireActiveParticipation: boolean;
+        includeResolved: boolean;
+    };
+    supervisors: {
+        mode: QueueSupervisorAudienceMode;
+        includeResolved: boolean;
+    };
+}
+export interface ConversationQueueInfo {
+    id: ID;
+    name: string;
+    color?: string;
+    enabled: boolean;
+}
+/**
+ * Conversation routing, supervision and reporting boundary.
+ * Groups only provide user membership; they never own conversations.
+ */
+export interface ConversationQueue {
+    id: ID;
+    spaceId: ID;
+    name: string;
+    description?: string;
+    color?: string;
+    enabled: boolean;
+    /**
+     * Higher values are evaluated first when multiple queues match.
+     */
+    priority: number;
+    memberGroupIds: ID[];
+    supervisorGroupIds: ID[];
+    routing: QueueRoutingPolicy;
+    sla: ConversationQueueSlaConfig;
+    audience: ConversationQueueAudienceConfig;
+    version: number;
+    createdAt: Date;
+    createdByUserId?: ID;
+    updatedAt: Date;
+    updatedByUserId?: ID;
+}
+/**
+ * Editable Queue definition sent by clients.
+ *
+ * It excludes id, version and audit fields controlled by the backend. Nested
+ * routing, SLA and audience objects use full-replacement semantics.
+ */
+export interface ConversationQueueDefinitionInput {
+    name: string;
+    description?: string;
+    color?: string;
+    enabled: boolean;
+    priority: number;
+    memberGroupIds: ID[];
+    supervisorGroupIds: ID[];
+    routing: QueueRoutingPolicy;
+    sla: ConversationQueueSlaConfig;
+    audience: ConversationQueueAudienceConfig;
+}
+/**
+ * Creates a Queue. commandId makes retries idempotent. The backend assigns
+ * queue id, version and audit fields.
+ */
+export interface CreateConversationQueueRequest {
+    commandId: ID;
+    spaceId: ID;
+    definition: ConversationQueueDefinitionInput;
+}
+/**
+ * Replaces the editable definition of an existing Queue.
+ *
+ * expectedVersion is the version loaded by the client; it is not incremented
+ * by the client. The backend rejects stale writes and returns the updated
+ * ConversationQueue with its new version and audit fields.
+ */
+export interface UpdateConversationQueueRequest {
+    commandId: ID;
+    spaceId: ID;
+    queueId: ID;
+    expectedVersion: number;
+    definition: ConversationQueueDefinitionInput;
+}

package/dist/src/Conversations/Queue.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONVERSATION_QUEUES_COLLECTION = void 0;
+exports.CONVERSATION_QUEUES_COLLECTION = 'conversation_queues';

package/dist/src/Conversations/Routing.d.ts

@@ -0,0 +1,164 @@
+import { ChannelType } from '../Common/Channels/ChannelType';
+interface QueueRoutingPolicyBase {
+    requiredSkills?: string[];
+    optionalSkills?: string[];
+    acceptedChannelTypes: ChannelType[];
+    requireActiveParticipation: boolean;
+    requireAvailablePresence: boolean;
+    requireAcceptance: boolean;
+    capacityPolicy: {
+        maxConcurrentByChannelType: Partial<Record<ChannelType, number>>;
+        weightByChannelType: Partial<Record<ChannelType, number>>;
+    };
+    fallback: {
+        action: 'keep_queued' | 'overflow_queue' | 'assign_supervisor';
+        overflowQueueId?: string;
+        timeoutSeconds?: number;
+    };
+}
+/**
+ * Resolves the ownerUserId of the contact or business associated with the
+ * conversation. The resolved user is still subject to every Queue eligibility
+ * rule.
+ */
+export interface PartyOwnerAssigneeResolver {
+    type: 'party_owner';
+    mode: 'prefer' | 'required';
+}
+export type QueueOwnerAssigneeResolver = PartyOwnerAssigneeResolver;
+export type QueueRoutingPolicy = (QueueRoutingPolicyBase & {
+    distributionMode: 'shared';
+    strategy?: never;
+    ownerResolver?: never;
+}) | (QueueRoutingPolicyBase & {
+    distributionMode: 'manual_pull';
+    strategy?: never;
+    ownerResolver?: never;
+}) | (QueueRoutingPolicyBase & {
+    distributionMode: 'exclusive';
+    strategy: QueueRoutingStrategy;
+    ownerResolver?: undefined | (PartyOwnerAssigneeResolver & {
+        mode: 'prefer';
+    });
+}) | (QueueRoutingPolicyBase & {
+    distributionMode: 'exclusive';
+    strategy?: never;
+    ownerResolver: PartyOwnerAssigneeResolver & {
+        mode: 'required';
+    };
+});
+export type QueueRoutingConfig = QueueRoutingPolicy & {
+    queueId: string;
+    spaceId: string;
+    version: number;
+    updatedAt: Date;
+};
+export type QueueDistributionMode = 'shared' | 'exclusive' | 'manual_pull';
+export type QueueRoutingStrategy = 'round_robin' | 'least_busy' | 'random' | 'highest_capacity' | 'skills' | 'account_affinity' | 'longest_idle' | 'manual';
+export interface RoutingCandidate {
+    userId: string;
+    queueId: string;
+    authorized: boolean;
+    participating: boolean;
+    available: boolean;
+    channelEligible: boolean;
+    capacityUsed: number;
+    capacityTotal: number;
+    lastAssignedAt?: Date;
+    idleSince?: Date;
+    skills: string[];
+    accountAffinityScore?: number;
+}
+export type RoutingPartyType = 'contact' | 'business';
+/**
+ * Snapshot resolved by the command producer. The routing worker must not read
+ * Contacts again to obtain ownerUserId.
+ */
+export type RoutingPartyContext = {
+    status: 'not_found';
+    partyType: RoutingPartyType;
+    partyId?: string;
+    ownerUserId?: never;
+} | {
+    status: 'without_owner';
+    partyType: RoutingPartyType;
+    partyId: string;
+    ownerUserId?: never;
+} | {
+    status: 'resolved';
+    partyType: RoutingPartyType;
+    partyId: string;
+    ownerUserId: string;
+};
+/**
+ * Idempotent request for routing a queued conversation.
+ *
+ * contact/business ownership is captured in party by the producer so the
+ * routing worker can evaluate it against candidates without another read.
+ */
+export interface RouteConversationCommand {
+    commandId: string;
+    sourceEventId: string;
+    spaceId: string;
+    conversationId: string;
+    queueId: string;
+    expectedConversationVersion: number;
+    queueConfigVersion: number;
+    party: RoutingPartyContext;
+    requestedAt: Date;
+}
+export type RoutingSelectionSource = 'party_owner' | 'strategy' | 'fallback';
+export type PartyOwnerResolutionFailure = 'party_not_found' | 'party_without_owner' | 'owner_user_not_found' | 'not_authorized' | 'not_participating' | 'unavailable' | 'channel_ineligible' | 'capacity_exhausted';
+type FailedPartyOwnerEvaluation = {
+    party: Extract<RoutingPartyContext, {
+        status: 'not_found';
+    }>;
+    outcome: 'party_not_found';
+} | {
+    party: Extract<RoutingPartyContext, {
+        status: 'without_owner';
+    }>;
+    outcome: 'party_without_owner';
+} | {
+    party: Extract<RoutingPartyContext, {
+        status: 'resolved';
+    }>;
+    outcome: Exclude<PartyOwnerResolutionFailure, 'party_not_found' | 'party_without_owner'>;
+};
+export type PartyOwnerAssigneeEvaluation = {
+    type: 'party_owner';
+    mode: PartyOwnerAssigneeResolver['mode'];
+    party: Extract<RoutingPartyContext, {
+        status: 'resolved';
+    }>;
+    outcome: 'selected';
+    nextStep?: never;
+} | (FailedPartyOwnerEvaluation & {
+    type: 'party_owner';
+    mode: 'prefer';
+    nextStep: 'strategy';
+}) | (FailedPartyOwnerEvaluation & {
+    type: 'party_owner';
+    mode: 'required';
+    nextStep: 'fallback';
+});
+export interface RoutingDecision {
+    decisionId: string;
+    spaceId: string;
+    conversationId: string;
+    queueId: string;
+    distributionMode: QueueDistributionMode;
+    strategy?: QueueRoutingStrategy;
+    eligibleUserIds: string[];
+    selectedUserId?: string;
+    selectionSource?: RoutingSelectionSource;
+    ownerEvaluation?: PartyOwnerAssigneeEvaluation;
+    rejected: Array<{
+        userId: string;
+        reasons: string[];
+    }>;
+    queueConfigVersion: number;
+    conversationVersion: number;
+    createdAt: Date;
+}
+export {};

package/dist/src/Conversations/Routing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/Conversations/Sla.d.ts

@@ -0,0 +1,227 @@
+import type { ISchedule } from '../Common/Schedules/Schedules';
+import type { ConversationEventType, ConversationStatus, ID } from './Conversation';
+import type { OutboxEvent } from './Outbox';
+export declare const CONVERSATION_SLA_POLICIES_COLLECTION = "conversation_sla_policies";
+export declare const CONVERSATION_SLA_CYCLES_COLLECTION = "conversation_sla_cycles";
+export declare const CONVERSATION_SLA_EVENTS_COLLECTION = "conversation_sla_events";
+export type ConversationSlaMetric = 'first_response' | 'next_response' | 'assignment' | 'acceptance' | 'resolution';
+/**
+ * continuous counts natural elapsed time, including nights and holidays.
+ * schedule counts only ranges allowed by the referenced customer ISchedule.
+ */
+export type ConversationSlaTimeCalculation = {
+    mode: 'continuous';
+    scheduleId?: never;
+} | {
+    mode: 'schedule';
+    scheduleId: Exclude<ISchedule['id'], null>;
+};
+export interface ConversationSlaWarningThreshold {
+    id: ID;
+    percentage: number;
+}
+export interface ConversationSlaTarget {
+    metric: ConversationSlaMetric;
+    durationSeconds: number;
+    warningThresholds: ConversationSlaWarningThreshold[];
+}
+/**
+ * Threshold received by the SLA policy write API.
+ *
+ * Existing thresholds keep their id. New thresholds may omit it so the
+ * backend can assign the canonical identifier returned in
+ * ConversationSlaPolicy.
+ */
+export interface ConversationSlaWarningThresholdInput {
+    id?: ID;
+    percentage: number;
+}
+/**
+ * Target received by the SLA policy write API.
+ * durationSeconds is stored as seconds regardless of the unit used by the UI.
+ */
+export interface ConversationSlaTargetInput {
+    metric: ConversationSlaMetric;
+    durationSeconds: number;
+    warningThresholds: ConversationSlaWarningThresholdInput[];
+}
+export type ConversationSlaResumeBehavior = 'continue' | 'restart' | 'recalculate';
+export type ConversationSlaReopenBehavior = 'preserve' | 'restart' | 'recalculate' | 'do_not_start';
+export interface ConversationSlaClockBehavior {
+    /**
+     * Conversation statuses that pause every running SLA cycle.
+     *
+     * Entering one of these statuses pauses the clock. Leaving all of them
+     * resumes it according to onResume. An empty array means that conversation
+     * status changes never pause the SLA clock.
+     */
+    pauseOnStatuses: ConversationStatus[];
+    /**
+     * Behavior applied when the conversation leaves the last status included
+     * in pauseOnStatuses.
+     *
+     * continue: keeps the current cycle and its consumed/remaining time.
+     * restart: resets the current cycle from the resume timestamp.
+     * recalculate: keeps the applied policy snapshot and recalculates the
+     * schedule-derived warnings/deadline. It does not select another policy
+     * version.
+     */
+    onResume: ConversationSlaResumeBehavior;
+    /**
+     * Behavior applied when a resolved/finalized conversation is reopened.
+     * Reopening is independent from resuming a status-paused clock.
+     *
+     * preserve: preserves the previous cycle state.
+     * restart: starts a new cycle from the reopen timestamp.
+     * recalculate: recalculates the cycle using the applied policy snapshot.
+     * do_not_start: does not start an SLA cycle because of the reopen action.
+     */
+    onReopen: ConversationSlaReopenBehavior;
+}
+/**
+ * Immutable, versioned policy referenced by ConversationQueue.sla.
+ * Editing a published policy creates a new version.
+ */
+export interface ConversationSlaPolicy {
+    id: ID;
+    spaceId: ID;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    version: number;
+    timeCalculation: ConversationSlaTimeCalculation;
+    targets: ConversationSlaTarget[];
+    clockBehavior: ConversationSlaClockBehavior;
+    createdAt: Date;
+    createdByUserId?: ID;
+    updatedAt: Date;
+    updatedByUserId?: ID;
+}
+/**
+ * Editable definition sent by clients.
+ *
+ * It intentionally excludes policy id/version and audit fields controlled by
+ * the backend. targets is full-replacement: omitted metrics are disabled in
+ * the newly published policy version.
+ */
+export interface ConversationSlaPolicyDefinitionInput {
+    name: string;
+    description?: string;
+    enabled: boolean;
+    timeCalculation: ConversationSlaTimeCalculation;
+    targets: ConversationSlaTargetInput[];
+    clockBehavior: ConversationSlaClockBehavior;
+}
+/**
+ * Creates the first immutable version of an SLA policy.
+ *
+ * commandId provides idempotency for retries. The authenticated backend
+ * context supplies createdByUserId and the audit timestamps.
+ */
+export interface CreateConversationSlaPolicyRequest {
+    commandId: ID;
+    spaceId: ID;
+    definition: ConversationSlaPolicyDefinitionInput;
+}
+/**
+ * Publishes a new immutable version of an existing SLA policy.
+ *
+ * expectedVersion implements optimistic concurrency. The backend rejects the
+ * request when another version was published after the client loaded it.
+ * version, updatedAt and updatedByUserId are always assigned by the backend.
+ */
+export interface PublishConversationSlaPolicyVersionRequest {
+    commandId: ID;
+    spaceId: ID;
+    policyId: ID;
+    expectedVersion: number;
+    definition: ConversationSlaPolicyDefinitionInput;
+}
+export type ConversationSlaClockAction = 'start' | 'evaluate' | 'pause' | 'resume' | 'complete' | 'recalculate' | 'cancel';
+export type ConversationSlaClockReason = 'conversation_created' | 'conversation_enqueued' | 'customer_message' | 'agent_response' | 'assignment_changed' | 'status_changed' | 'queue_transfer' | 'conversation_reopened' | 'deadline_due' | 'policy_override';
+/**
+ * Idempotent input for the conversation-sla-worker.
+ * policyId/policyVersion identify the immutable policy snapshot to apply.
+ */
+export interface SlaClockCommand {
+    commandId: ID;
+    sourceEventId: ID;
+    spaceId: ID;
+    conversationId: ID;
+    expectedConversationVersion: number;
+    action: ConversationSlaClockAction;
+    reason: ConversationSlaClockReason;
+    metric?: ConversationSlaMetric;
+    policyId: ID;
+    policyVersion: number;
+    queueId?: ID;
+    occurredAt: Date;
+    requestedAt: Date;
+}
+export type ConversationSlaCycleStatus = 'running' | 'paused' | 'met' | 'breached' | 'cancelled';
+export interface ConversationSlaPausePeriod {
+    startedAt: Date;
+    endedAt?: Date;
+    reason: ConversationSlaClockReason;
+    sourceEventId: ID;
+}
+/**
+ * Durable metric cycle. The target and time calculation are copied from the
+ * selected policy version so later policy edits cannot alter active history.
+ */
+export interface ConversationSlaCycle {
+    id: ID;
+    spaceId: ID;
+    conversationId: ID;
+    metric: ConversationSlaMetric;
+    sequence: number;
+    status: ConversationSlaCycleStatus;
+    policyId: ID;
+    policyVersion: number;
+    timeCalculation: ConversationSlaTimeCalculation;
+    target: ConversationSlaTarget;
+    startedAt: Date;
+    deadlineAt?: Date;
+    nextWarningAt?: Date;
+    pausedAt?: Date;
+    completedAt?: Date;
+    breachedAt?: Date;
+    cancelledAt?: Date;
+    elapsedSeconds: number;
+    pausedSeconds: number;
+    pausePeriods: ConversationSlaPausePeriod[];
+    startedByEventId: ID;
+    completedByEventId?: ID;
+    version: number;
+    updatedAt: Date;
+}
+export type ConversationSlaEventType = Extract<ConversationEventType, 'sla_started' | 'sla_paused' | 'sla_resumed' | 'sla_warning' | 'sla_breached' | 'sla_met' | 'sla_overridden'>;
+/**
+ * Immutable SLA event. Corrections are represented by a later event.
+ */
+export interface ConversationSlaEvent {
+    eventId: ID;
+    sourceEventId: ID;
+    type: ConversationSlaEventType;
+    schemaVersion: 1;
+    spaceId: ID;
+    conversationId: ID;
+    conversationVersion: number;
+    cycleId: ID;
+    metric: ConversationSlaMetric;
+    policyId: ID;
+    policyVersion: number;
+    status: ConversationSlaCycleStatus;
+    deadlineAt?: Date;
+    warningThresholdId?: ID;
+    reason: ConversationSlaClockReason;
+    correlationId: ID;
+    causationId: ID;
+    occurredAt: Date;
+    recordedAt: Date;
+}
+export type ConversationSlaOutboxEvent = OutboxEvent<ConversationSlaEvent> & {
+    aggregateType: 'conversation';
+    eventType: `conversation.${ConversationSlaEventType}`;
+    schemaVersion: 1;
+};

package/dist/src/Conversations/Sla.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONVERSATION_SLA_EVENTS_COLLECTION = exports.CONVERSATION_SLA_CYCLES_COLLECTION = exports.CONVERSATION_SLA_POLICIES_COLLECTION = void 0;
+exports.CONVERSATION_SLA_POLICIES_COLLECTION = 'conversation_sla_policies';
+exports.CONVERSATION_SLA_CYCLES_COLLECTION = 'conversation_sla_cycles';
+exports.CONVERSATION_SLA_EVENTS_COLLECTION = 'conversation_sla_events';

package/dist/src/Conversations/Transfer.d.ts

@@ -0,0 +1,73 @@
+import { OutboxEvent } from './Outbox';
+import { AssignmentActorReference, AssignmentStateReference, ConversationAssignmentReason } from './Assignment';
+import { ID } from './Conversation';
+export type TransferConversationReason = Extract<ConversationAssignmentReason, 'manual_transfer' | 'flow_routing' | 'sla_escalation' | 'system_recovery'>;
+export type TransferConversationTarget = {
+    type: 'queue';
+    queueId: ID;
+} | {
+    type: 'user';
+    queueId: ID;
+    userId: ID;
+};
+export interface TransferConversationCommand {
+    commandId: ID;
+    spaceId: ID;
+    conversationId: ID;
+    target: TransferConversationTarget;
+    expectedConversationVersion: number;
+    actor: AssignmentActorReference;
+    reason: TransferConversationReason;
+    requestedAt: Date;
+}
+export type TransferConversationRejectionCode = 'conversation_not_found' | 'target_queue_not_found' | 'target_queue_disabled' | 'target_user_not_found' | 'target_user_not_authorized' | 'target_user_not_available' | 'target_user_has_no_capacity' | 'channel_not_supported' | 'same_queue' | 'same_owner' | 'actor_not_authorized' | 'conversation_not_transferable';
+export type TransferConversationResult = {
+    status: 'transferred';
+    commandId: ID;
+    conversationId: ID;
+    previousVersion: number;
+    conversationVersion: number;
+    previous: AssignmentStateReference;
+    current: AssignmentStateReference;
+    assignmentEventId: ID;
+    outboxEventId: ID;
+} | {
+    status: 'already_applied';
+    commandId: ID;
+    conversationId: ID;
+    conversationVersion: number;
+    assignmentEventId: ID;
+    outboxEventId: ID;
+} | {
+    status: 'version_conflict';
+    commandId: ID;
+    conversationId: ID;
+    expectedVersion: number;
+    currentVersion: number;
+} | {
+    status: 'rejected';
+    commandId: ID;
+    conversationId: ID;
+    code: TransferConversationRejectionCode;
+};
+export interface ConversationAssignmentChanged {
+    eventId: ID;
+    sourceEventId: ID;
+    type: 'conversation.assignment.changed';
+    schemaVersion: 1;
+    spaceId: ID;
+    conversationId: ID;
+    conversationVersion: number;
+    reason: ConversationAssignmentReason;
+    previous?: AssignmentStateReference;
+    current: AssignmentStateReference;
+    actor: AssignmentActorReference;
+    correlationId: ID;
+    causationId: ID;
+    occurredAt: Date;
+}
+export type ConversationAssignmentChangedOutboxEvent = OutboxEvent<ConversationAssignmentChanged> & {
+    aggregateType: 'conversation';
+    eventType: 'conversation.assignment.changed';
+    schemaVersion: 1;
+};

package/dist/src/Conversations/Transfer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/Conversations/WebHook.d.ts

@@ -5,7 +5,7 @@ import { AuthType } from '../Common/API/AuthType';
 import { Method } from '../Common/API/Method';
 interface IWebhook {
     id?: string | null;
-    tenantId?: string | null;
+    spaceId?: string | null;
     name?: string | null;
     apiUrl?: string | null;
     apiMethod?: Method | null;

package/dist/src/Conversations/index.d.ts

@@ -1,13 +1,21 @@
 export * as Flows from './Flows/index';
 export * as Groups from './Groups/Group';
+export * from './Assignment';
 export * from './Conversation';
+export * from './InboxMongo';
+export * from './InboxProjection';
+export * from './Outbox';
 export * from './Ending';
 export * from './Label';
 export * from './WebHook';
 export * from './SocialWalls';
 export * from './QuickResponse';
 export * from './DashBoard/dashboard';
-export * from './DashBoard/dashboardForms';
+export * from '../Forms/API';
 export * from './DashBoard/dashboardChannels';
 export * from './DashBoard/dashboardMessages';
 export * from './Survey';
+export * from './Queue';
+export * from './Routing';
+export * from './Sla';
+export * from './Transfer';

package/dist/src/Conversations/index.js

@@ -39,14 +39,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Groups = exports.Flows = void 0;
 exports.Flows = __importStar(require("./Flows/index"));
 exports.Groups = __importStar(require("./Groups/Group"));
+__exportStar(require("./Assignment"), exports);
 __exportStar(require("./Conversation"), exports);
+__exportStar(require("./InboxMongo"), exports);
+__exportStar(require("./InboxProjection"), exports);
+__exportStar(require("./Outbox"), exports);
 __exportStar(require("./Ending"), exports);
 __exportStar(require("./Label"), exports);
 __exportStar(require("./WebHook"), exports);
 __exportStar(require("./SocialWalls"), exports);
 __exportStar(require("./QuickResponse"), exports);
 __exportStar(require("./DashBoard/dashboard"), exports);
-__exportStar(require("./DashBoard/dashboardForms"), exports);
+__exportStar(require("../Forms/API"), exports);
 __exportStar(require("./DashBoard/dashboardChannels"), exports);
 __exportStar(require("./DashBoard/dashboardMessages"), exports);
 __exportStar(require("./Survey"), exports);
+__exportStar(require("./Queue"), exports);
+__exportStar(require("./Routing"), exports);
+__exportStar(require("./Sla"), exports);
+__exportStar(require("./Transfer"), exports);