@absolutejs/voice 0.0.22-beta.0 → 0.0.22-beta.2

package/dist/ops.d.ts

@@ -1,30 +1,79 @@
 import type { VoiceCallDisposition, VoiceSessionRecord, VoiceSessionSummary } from './types';
 import type { StoredVoiceCallReviewArtifact } from './testing/review';
 export type VoiceOpsTaskStatus = 'open' | 'in-progress' | 'done';
-export type VoiceOpsTaskKind = 'callback' | 'escalation' | 'transfer-check' | 'retry-review';
+export type VoiceOpsTaskKind = 'appointment-booking' | 'callback' | 'escalation' | 'lead-qualification' | 'transfer-check' | 'retry-review' | 'support-triage';
+export type VoiceOpsTaskPriority = 'low' | 'normal' | 'high' | 'urgent';
 export type VoiceOpsTaskHistoryEntry = {
     actor: string;
     at: number;
     detail?: string;
-    type: 'created' | 'assigned' | 'started' | 'completed' | 'reopened';
+    type: 'created' | 'assigned' | 'started' | 'claimed' | 'heartbeat' | 'failed' | 'dead-lettered' | 'policy-applied' | 'sla-breached' | 'completed' | 'reopened' | 'requeued';
 };
 export type VoiceOpsTask = {
     assignee?: string;
+    claimExpiresAt?: number;
+    claimedAt?: number;
+    claimedBy?: string;
     createdAt: number;
+    deadLetteredAt?: number;
     description: string;
+    dueAt?: number;
     history: VoiceOpsTaskHistoryEntry[];
     id: string;
     intakeId?: string;
     kind: VoiceOpsTaskKind;
+    lastProcessedAt?: number;
+    policyName?: string;
+    processingAttempts?: number;
+    processingError?: string;
     outcome?: VoiceCallDisposition;
+    priority?: VoiceOpsTaskPriority;
+    queue?: string;
     recommendedAction: string;
     reviewId?: string;
+    slaBreachedAt?: number;
     status: VoiceOpsTaskStatus;
     target?: string;
     title: string;
     updatedAt: number;
 };
 export type StoredVoiceOpsTask = VoiceOpsTask;
+export type VoiceExternalObjectMap = {
+    createdAt: number;
+    externalId: string;
+    id: string;
+    provider: string;
+    sinkId?: string;
+    sourceId: string;
+    sourceType: 'session' | 'review' | 'task' | 'event';
+    updatedAt: number;
+};
+export type StoredVoiceExternalObjectMap = VoiceExternalObjectMap;
+export declare const createVoiceExternalObjectMapId: (input: {
+    provider: string;
+    sinkId?: string;
+    sourceId: string;
+}) => string;
+export declare const createVoiceExternalObjectMap: (input: {
+    at?: number;
+    externalId: string;
+    provider: string;
+    sinkId?: string;
+    sourceId: string;
+    sourceType: VoiceExternalObjectMap["sourceType"];
+}) => StoredVoiceExternalObjectMap;
+export type VoiceExternalObjectMapStore<TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap> = {
+    find: (input: {
+        provider: string;
+        sinkId?: string;
+        sourceId: string;
+        sourceType?: VoiceExternalObjectMap['sourceType'];
+    }) => Promise<TMapping | undefined> | TMapping | undefined;
+    get: (id: string) => Promise<TMapping | undefined> | TMapping | undefined;
+    list: () => Promise<TMapping[]> | TMapping[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, mapping: TMapping) => Promise<void> | void;
+};
 export type VoiceOpsTaskStore<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = {
     get: (id: string) => Promise<TTask | undefined> | TTask | undefined;
     list: () => Promise<TTask[]> | TTask[];
@@ -32,32 +81,141 @@ export type VoiceOpsTaskStore<TTask extends StoredVoiceOpsTask = StoredVoiceOpsT
     set: (id: string, task: TTask) => Promise<void> | void;
 };
 export type VoiceOpsTaskSummary = {
+    byClaimedBy: Array<[string, number]>;
     byKind: Array<[VoiceOpsTaskKind, number]>;
     byOutcome: Array<[string, number]>;
+    byPriority: Array<[VoiceOpsTaskPriority, number]>;
+    byQueue: Array<[string, number]>;
+    claimed: number;
     done: number;
     inProgress: number;
     open: number;
+    overdue: number;
     topAssignees: Array<[string, number]>;
+    topQueues: Array<[string, number]>;
     topTargets: Array<[string, number]>;
     total: number;
 };
-export type VoiceIntegrationEventType = 'call.completed' | 'review.saved' | 'task.created' | 'task.updated';
+export type VoiceOpsTaskAgeBucket = 'fresh' | 'aging' | 'due-soon' | 'overdue' | 'stale';
+export type VoiceOpsTaskAssigneeAnalytics = {
+    assignee: string;
+    averageCompletionMs?: number;
+    claimed: number;
+    completed: number;
+    inProgress: number;
+    open: number;
+    overdue: number;
+    total: number;
+};
+export type VoiceOpsTaskWorkerAnalytics = {
+    activeClaims: number;
+    completed: number;
+    failed: number;
+    heartbeats: number;
+    requeued: number;
+    totalClaims: number;
+    workerId: string;
+};
+export type VoiceOpsTaskAnalyticsSummary = {
+    agingBuckets: Array<[VoiceOpsTaskAgeBucket, number]>;
+    assignees: VoiceOpsTaskAssigneeAnalytics[];
+    totalCompleted: number;
+    totalOverdue: number;
+    totalTasks: number;
+    workers: VoiceOpsTaskWorkerAnalytics[];
+};
+export type VoiceOpsTaskPolicy = {
+    assignee?: string;
+    dueInMs?: number;
+    name?: string;
+    priority?: VoiceOpsTaskPriority;
+    queue?: string;
+    recommendedAction?: string;
+    target?: string;
+    title?: string;
+};
+export type VoiceOpsTaskAssignmentRuleCondition = {
+    assignee?: string;
+    kind?: VoiceOpsTaskKind;
+    outcome?: VoiceCallDisposition;
+    policyName?: string;
+    priority?: VoiceOpsTaskPriority;
+    queue?: string;
+    status?: VoiceOpsTaskStatus;
+};
+export type VoiceOpsTaskAssignmentRule = {
+    assign?: string;
+    description?: string;
+    name?: string;
+    priority?: VoiceOpsTaskPriority;
+    queue?: string;
+    recommendedAction?: string;
+    title?: string;
+    when?: VoiceOpsTaskAssignmentRuleCondition;
+};
+export type VoiceOpsDispositionTaskPolicies = Partial<Record<VoiceCallDisposition, VoiceOpsTaskPolicy>>;
+export type VoiceOpsTaskAssignmentRules = VoiceOpsTaskAssignmentRule[];
+export type VoiceOpsTaskAnalyticsOptions = {
+    agingMs?: number;
+    at?: number;
+    dueSoonMs?: number;
+    staleMs?: number;
+};
+export type VoiceIntegrationEventType = 'call.completed' | 'review.saved' | 'task.created' | 'task.updated' | 'task.sla_breached';
+export type VoiceOpsSLABreachPolicy = {
+    action?: 'event' | 'event-and-task' | 'task';
+    assignee?: string;
+    description?: string;
+    dueInMs?: number;
+    name?: string;
+    priority?: VoiceOpsTaskPriority;
+    queue?: string;
+    recommendedAction?: string;
+    title?: string;
+};
+export type VoiceIntegrationDeliveryStatus = 'pending' | 'delivered' | 'failed' | 'skipped';
+export type VoiceIntegrationSinkDelivery = {
+    attempts: number;
+    deliveredAt?: number;
+    deliveredTo?: string;
+    error?: string;
+    sinkId: string;
+    sinkKind?: string;
+    status: VoiceIntegrationDeliveryStatus;
+};
 export type VoiceIntegrationEvent = {
     createdAt: number;
     deliveredAt?: number;
+    deliveryAttempts?: number;
     deliveredTo?: string;
     deliveryError?: string;
+    deliveryStatus?: VoiceIntegrationDeliveryStatus;
     id: string;
     payload: Record<string, unknown>;
+    sinkDeliveries?: Record<string, VoiceIntegrationSinkDelivery>;
     type: VoiceIntegrationEventType;
 };
 export type StoredVoiceIntegrationEvent = VoiceIntegrationEvent;
+export type VoiceIntegrationWebhookConfig = {
+    backoffMs?: number;
+    eventTypes?: VoiceIntegrationEventType[];
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    retries?: number;
+    signingSecret?: string;
+    timeoutMs?: number;
+    url: string;
+};
 export type VoiceIntegrationEventStore<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
     get: (id: string) => Promise<TEvent | undefined> | TEvent | undefined;
     list: () => Promise<TEvent[]> | TEvent[];
     remove: (id: string) => Promise<void> | void;
     set: (id: string, event: TEvent) => Promise<void> | void;
 };
+export declare const deliverVoiceIntegrationEvent: (input: {
+    event: StoredVoiceIntegrationEvent;
+    webhook: VoiceIntegrationWebhookConfig;
+}) => Promise<StoredVoiceIntegrationEvent>;
 export declare const withVoiceOpsTaskId: <TTask extends Omit<VoiceOpsTask, "id"> = Omit<VoiceOpsTask, "id">>(id: string, task: TTask) => TTask & {
     id: string;
 };
@@ -65,6 +223,39 @@ export declare const withVoiceIntegrationEventId: <TEvent extends Omit<VoiceInte
     id: string;
 };
 export declare const buildVoiceOpsTaskFromReview: (review: StoredVoiceCallReviewArtifact) => StoredVoiceOpsTask | null;
+export declare const resolveVoiceOpsTaskPolicy: (input: {
+    disposition?: VoiceCallDisposition;
+    policies?: VoiceOpsDispositionTaskPolicies;
+}) => {
+    assignee?: string;
+    dueInMs?: number;
+    name?: string;
+    priority?: VoiceOpsTaskPriority;
+    queue?: string;
+    recommendedAction?: string;
+    target?: string;
+    title?: string;
+} | undefined;
+export declare const isVoiceOpsTaskOverdue: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+}) => boolean;
+export declare const hasVoiceOpsTaskSLABreach: (task: StoredVoiceOpsTask) => boolean;
+export declare const resolveVoiceOpsTaskAgeBucket: (task: StoredVoiceOpsTask, input?: VoiceOpsTaskAnalyticsOptions) => VoiceOpsTaskAgeBucket;
+export declare const applyVoiceOpsTaskPolicy: (task: StoredVoiceOpsTask, policy: VoiceOpsTaskPolicy, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
+export declare const matchesVoiceOpsTaskAssignmentRule: (task: StoredVoiceOpsTask, rule: VoiceOpsTaskAssignmentRule) => boolean;
+export declare const resolveVoiceOpsTaskAssignment: (input: {
+    rules?: VoiceOpsTaskAssignmentRules;
+    task: StoredVoiceOpsTask;
+}) => VoiceOpsTaskAssignmentRule | undefined;
+export declare const applyVoiceOpsTaskAssignmentRule: (task: StoredVoiceOpsTask, rule: VoiceOpsTaskAssignmentRule, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
 export declare const assignVoiceOpsTask: (task: StoredVoiceOpsTask, owner: string, input?: {
     at?: number;
     actor?: string;
@@ -74,6 +265,34 @@ export declare const startVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
     actor?: string;
     detail?: string;
 }) => StoredVoiceOpsTask;
+export declare const claimVoiceOpsTask: (task: StoredVoiceOpsTask, workerId: string, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+    leaseMs: number;
+}) => StoredVoiceOpsTask;
+export declare const heartbeatVoiceOpsTask: (task: StoredVoiceOpsTask, workerId: string, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+    leaseMs: number;
+}) => StoredVoiceOpsTask;
+export declare const failVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+    error?: string;
+}) => StoredVoiceOpsTask;
+export declare const deadLetterVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
+export declare const markVoiceOpsTaskSLABreached: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
 export declare const completeVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
     at?: number;
     actor?: string;
@@ -84,8 +303,14 @@ export declare const reopenVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
     actor?: string;
     detail?: string;
 }) => StoredVoiceOpsTask;
+export declare const requeueVoiceOpsTask: (task: StoredVoiceOpsTask, input?: {
+    at?: number;
+    actor?: string;
+    detail?: string;
+}) => StoredVoiceOpsTask;
 export declare const listVoiceOpsTasks: (tasks: StoredVoiceOpsTask[]) => VoiceOpsTask[];
 export declare const summarizeVoiceOpsTasks: (tasks: StoredVoiceOpsTask[]) => VoiceOpsTaskSummary;
+export declare const summarizeVoiceOpsTaskAnalytics: (tasks: StoredVoiceOpsTask[], input?: VoiceOpsTaskAnalyticsOptions) => VoiceOpsTaskAnalyticsSummary;
 export declare const createVoiceIntegrationEvent: <TPayload extends Record<string, unknown> = Record<string, unknown>>(type: VoiceIntegrationEventType, payload: TPayload, input?: {
     createdAt?: number;
     id?: string;
@@ -98,3 +323,5 @@ export declare const createVoiceCallCompletedEvent: (input: {
 export declare const createVoiceReviewSavedEvent: (review: StoredVoiceCallReviewArtifact) => StoredVoiceIntegrationEvent;
 export declare const createVoiceTaskCreatedEvent: (task: StoredVoiceOpsTask) => StoredVoiceIntegrationEvent;
 export declare const createVoiceTaskUpdatedEvent: (task: StoredVoiceOpsTask) => StoredVoiceIntegrationEvent;
+export declare const createVoiceTaskSLABreachedEvent: (task: StoredVoiceOpsTask) => StoredVoiceIntegrationEvent;
+export declare const buildVoiceOpsTaskFromSLABreach: (task: StoredVoiceOpsTask, policy?: VoiceOpsSLABreachPolicy) => StoredVoiceOpsTask;

package/dist/opsPresets.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceOpsDispositionTaskPolicies, VoiceOpsTaskAssignmentRules, VoiceOpsSLABreachPolicy } from './ops';
+export type VoiceOpsPresetName = 'support-default' | 'sales-default' | 'collections-default';
+export type VoiceResolvedOpsPreset = {
+    assignmentRules: VoiceOpsTaskAssignmentRules;
+    description: string;
+    name: VoiceOpsPresetName;
+    sla: {
+        followUpTask?: VoiceOpsSLABreachPolicy;
+    };
+    taskPolicies: VoiceOpsDispositionTaskPolicies;
+};
+export type VoiceOpsPresetOverrides = {
+    assignmentRules?: VoiceOpsTaskAssignmentRules;
+    sla?: {
+        followUpTask?: VoiceOpsSLABreachPolicy;
+    };
+    taskPolicies?: VoiceOpsDispositionTaskPolicies;
+};
+export declare const resolveVoiceOpsPreset: (name: VoiceOpsPresetName, overrides?: VoiceOpsPresetOverrides) => VoiceResolvedOpsPreset;

package/dist/opsRuntime.d.ts

@@ -0,0 +1,66 @@
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationWebhookConfig, VoiceOpsSLABreachPolicy } from './ops';
+import type { VoiceIntegrationSinkWorkerOptions, VoiceIntegrationSinkWorkerResult, VoiceIntegrationEventQueueSummary, VoiceOpsTaskProcessorWorkerOptions, VoiceOpsTaskProcessorWorkerResult, VoiceOpsTaskQueueSummary, VoiceRedisTaskLeaseCoordinator, VoiceWebhookDeliveryWorkerOptions, VoiceWebhookDeliveryWorkerResult } from './queue';
+import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from './types';
+export type VoiceOpsRuntimeWebhookWorkerConfig<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = Omit<VoiceWebhookDeliveryWorkerOptions<StoredVoiceIntegrationEvent>, 'events' | 'webhook'> & VoiceIntegrationWebhookConfig & {
+    autoStart?: boolean;
+    pollIntervalMs?: number;
+};
+export type VoiceOpsRuntimeSinkWorkerConfig<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = Omit<VoiceIntegrationSinkWorkerOptions<StoredVoiceIntegrationEvent>, 'events' | 'sinks'> & {
+    autoStart?: boolean;
+    pollIntervalMs?: number;
+};
+export type VoiceOpsRuntimeTaskWorkerConfig<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = Omit<VoiceOpsTaskProcessorWorkerOptions<StoredVoiceOpsTask>, 'tasks' | 'worker'> & {
+    autoStart?: boolean;
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    pollIntervalMs?: number;
+    workerId: string;
+};
+export type VoiceOpsRuntimeConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    ops: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    sla?: {
+        followUpTask?: VoiceOpsSLABreachPolicy;
+    };
+    sinks?: VoiceOpsRuntimeSinkWorkerConfig;
+    tasks?: VoiceOpsRuntimeTaskWorkerConfig;
+    webhooks?: VoiceOpsRuntimeWebhookWorkerConfig;
+};
+export type VoiceOpsRuntimeTickResult = {
+    sla?: {
+        breached: number;
+        events: number;
+        followUpTasks: number;
+    };
+    sinks?: VoiceIntegrationSinkWorkerResult;
+    tasks?: VoiceOpsTaskProcessorWorkerResult;
+    webhooks?: VoiceWebhookDeliveryWorkerResult;
+};
+export type VoiceOpsRuntimeSummary = {
+    sinks?: VoiceIntegrationEventQueueSummary;
+    tasks?: VoiceOpsTaskQueueSummary;
+    webhooks?: VoiceIntegrationEventQueueSummary;
+};
+export type VoiceOpsRuntime<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    isRunning: () => boolean;
+    checkSLA: (input?: {
+        at?: number;
+    }) => Promise<{
+        breached: number;
+        events: number;
+        followUpTasks: number;
+    }>;
+    record: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        disposition: VoiceCallDisposition;
+        metadata?: Record<string, unknown>;
+        reason?: string;
+        session: TSession;
+        target?: string;
+    }) => Promise<void>;
+    start: () => void;
+    stop: () => void;
+    summarize: () => Promise<VoiceOpsRuntimeSummary>;
+    tick: () => Promise<VoiceOpsRuntimeTickResult>;
+};
+export declare const createVoiceOpsRuntime: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(config: VoiceOpsRuntimeConfig<TContext, TSession, TResult>) => VoiceOpsRuntime<TContext, TSession, TResult>;

package/dist/opsSinks.d.ts

@@ -0,0 +1,149 @@
+import type { StoredVoiceIntegrationEvent, VoiceExternalObjectMapStore, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventType, VoiceIntegrationWebhookConfig } from './ops';
+export type VoiceIntegrationSinkDeliveryResult = {
+    attempts: number;
+    deliveredAt?: number;
+    deliveredTo?: string;
+    error?: string;
+    responseBody?: unknown;
+    status: VoiceIntegrationDeliveryStatus;
+};
+export type VoiceIntegrationSink = {
+    deliver: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Promise<VoiceIntegrationSinkDeliveryResult> | VoiceIntegrationSinkDeliveryResult;
+    eventTypes?: VoiceIntegrationEventType[];
+    id: string;
+    kind?: string;
+};
+export type VoiceIntegrationHTTPSinkOptions<TBody extends Record<string, unknown> = Record<string, unknown>> = VoiceIntegrationWebhookConfig & {
+    body?: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => TBody | Promise<TBody>;
+    id: string;
+    kind?: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+};
+export type VoiceHelpdeskTicketSinkOptions = VoiceIntegrationHTTPSinkOptions & {
+    project?: string;
+};
+export type VoiceCRMActivitySinkOptions = VoiceIntegrationHTTPSinkOptions & {
+    pipeline?: string;
+};
+export type VoiceZendeskTicketSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+    accessToken: string;
+    baseUrl?: string;
+    buildTicket?: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    externalObjects?: VoiceExternalObjectMapStore;
+    resolveExternalId?: (input: {
+        event: StoredVoiceIntegrationEvent;
+        responseBody: unknown;
+    }) => Promise<string | undefined> | string | undefined;
+    requester?: {
+        email?: string;
+        name?: string;
+    };
+    subdomain?: string;
+};
+export type VoiceZendeskTicketSyncSinkOptions = Omit<VoiceZendeskTicketSinkOptions, 'eventTypes'> & {
+    create?: Partial<VoiceZendeskTicketSinkOptions>;
+    createId?: string;
+    update?: Partial<VoiceZendeskTicketUpdateSinkOptions>;
+    updateId?: string;
+};
+type VoiceSinkValueResolver = string | ((input: {
+    event: StoredVoiceIntegrationEvent;
+}) => Promise<string | undefined> | string | undefined);
+export type VoiceZendeskTicketUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+    accessToken: string;
+    baseUrl?: string;
+    buildTicket?: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    externalObjects?: VoiceExternalObjectMapStore;
+    status?: string;
+    subdomain?: string;
+    ticketId?: VoiceSinkValueResolver;
+};
+export type VoiceHubSpotTaskSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+    accessToken: string;
+    associations?: Array<Record<string, unknown>> | ((input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Array<Record<string, unknown>> | Promise<Array<Record<string, unknown>>>);
+    baseUrl?: string;
+    buildProperties?: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Record<string, string | number> | Promise<Record<string, string | number>>;
+    externalObjects?: VoiceExternalObjectMapStore;
+    ownerId?: string;
+    resolveExternalId?: (input: {
+        event: StoredVoiceIntegrationEvent;
+        responseBody: unknown;
+    }) => Promise<string | undefined> | string | undefined;
+};
+export type VoiceHubSpotTaskSyncSinkOptions = Omit<VoiceHubSpotTaskSinkOptions, 'eventTypes'> & {
+    create?: Partial<VoiceHubSpotTaskSinkOptions>;
+    createId?: string;
+    update?: Partial<VoiceHubSpotTaskUpdateSinkOptions>;
+    updateId?: string;
+};
+export type VoiceHubSpotTaskUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+    accessToken: string;
+    baseUrl?: string;
+    buildProperties?: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Record<string, string | number> | Promise<Record<string, string | number>>;
+    externalObjects?: VoiceExternalObjectMapStore;
+    taskId?: VoiceSinkValueResolver;
+};
+export type VoiceLinearIssueSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+    apiKey?: string;
+    authMode?: 'api-key' | 'bearer';
+    accessToken?: string;
+    apiUrl?: string;
+    buildIssueInput?: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    externalObjects?: VoiceExternalObjectMapStore;
+    resolveExternalId?: (input: {
+        event: StoredVoiceIntegrationEvent;
+        responseBody: unknown;
+    }) => Promise<string | undefined> | string | undefined;
+    teamId: string;
+};
+export type VoiceLinearIssueSyncSinkOptions = Omit<VoiceLinearIssueSinkOptions, 'eventTypes'> & {
+    create?: Partial<VoiceLinearIssueSinkOptions>;
+    createId?: string;
+    update?: Partial<VoiceLinearIssueUpdateSinkOptions>;
+    updateId?: string;
+};
+export type VoiceLinearIssueUpdateSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions, 'body' | 'url'> & {
+    apiKey?: string;
+    authMode?: 'api-key' | 'bearer';
+    accessToken?: string;
+    apiUrl?: string;
+    buildIssueInput?: (input: {
+        event: StoredVoiceIntegrationEvent;
+    }) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    externalObjects?: VoiceExternalObjectMapStore;
+    issueId?: VoiceSinkValueResolver;
+    stateId?: string;
+};
+export declare const createVoiceIntegrationHTTPSink: <TBody extends Record<string, unknown> = Record<string, unknown>>(options: VoiceIntegrationHTTPSinkOptions<TBody>) => VoiceIntegrationSink;
+export declare const createVoiceHelpdeskTicketSink: (options: VoiceHelpdeskTicketSinkOptions) => VoiceIntegrationSink;
+export declare const createVoiceCRMActivitySink: (options: VoiceCRMActivitySinkOptions) => VoiceIntegrationSink;
+export declare const createVoiceZendeskTicketSink: (options: VoiceZendeskTicketSinkOptions) => VoiceIntegrationSink;
+export declare const createVoiceZendeskTicketUpdateSink: (options: VoiceZendeskTicketUpdateSinkOptions) => VoiceIntegrationSink;
+export declare const createVoiceZendeskTicketSyncSinks: (options: VoiceZendeskTicketSyncSinkOptions) => VoiceIntegrationSink[];
+export declare const createVoiceHubSpotTaskSink: (options: VoiceHubSpotTaskSinkOptions) => VoiceIntegrationSink;
+export declare const createVoiceHubSpotTaskUpdateSink: (options: VoiceHubSpotTaskUpdateSinkOptions) => VoiceIntegrationSink;
+export declare const createVoiceHubSpotTaskSyncSinks: (options: VoiceHubSpotTaskSyncSinkOptions) => VoiceIntegrationSink[];
+export declare const createVoiceLinearIssueSink: (options: VoiceLinearIssueSinkOptions) => VoiceIntegrationSink;
+export declare const createVoiceLinearIssueSyncSinks: (options: VoiceLinearIssueSyncSinkOptions) => VoiceIntegrationSink[];
+export declare const createVoiceLinearIssueUpdateSink: (options: VoiceLinearIssueUpdateSinkOptions) => VoiceIntegrationSink;
+export declare const deliverVoiceIntegrationEventToSinks: (input: {
+    event: StoredVoiceIntegrationEvent;
+    sinks: VoiceIntegrationSink[];
+}) => Promise<StoredVoiceIntegrationEvent>;
+export {};

package/dist/outcomeRecipes.d.ts

@@ -0,0 +1,18 @@
+import type { VoiceOpsTaskPriority } from './ops';
+import type { VoiceRuntimeOpsConfig, VoiceSessionRecord } from './types';
+export type VoiceOutcomeRecipeName = 'appointment-booking' | 'lead-qualification' | 'support-triage' | 'voicemail-callback' | 'warm-transfer';
+export type VoiceOutcomeRecipeOptions = {
+    assignee?: string;
+    completedCreatesTask?: boolean;
+    dueInMs?: number;
+    escalationAssignee?: string;
+    escalationQueue?: string;
+    priority?: VoiceOpsTaskPriority;
+    queue?: string;
+    target?: string;
+};
+export type VoiceOutcomeRecipe<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Pick<VoiceRuntimeOpsConfig<TContext, TSession, TResult>, 'createTaskFromReview' | 'resolveTaskPolicy' | 'taskAssignmentRules' | 'taskPolicies'> & {
+    description: string;
+    name: VoiceOutcomeRecipeName;
+};
+export declare const resolveVoiceOutcomeRecipe: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(name: VoiceOutcomeRecipeName, options?: VoiceOutcomeRecipeOptions) => VoiceOutcomeRecipe<TContext, TSession, TResult>;

package/dist/postgresStore.d.ts

@@ -0,0 +1,31 @@
+import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
+import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMapStore, VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+export type VoicePostgresClient = {
+    unsafe: <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, parameters?: unknown[]) => Promise<TRow[]>;
+};
+export type VoicePostgresStoreOptions = {
+    connectionString?: string;
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoicePostgresRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+    events: VoiceIntegrationEventStore<TEvent>;
+    externalObjects: VoiceExternalObjectMapStore<TMapping>;
+    reviews: VoiceCallReviewStore<TReview>;
+    session: VoiceSessionStore<TSession>;
+    tasks: VoiceOpsTaskStore<TTask>;
+    traceDeliveries: VoiceTraceSinkDeliveryStore<TTraceDelivery>;
+    traces: VoiceTraceEventStore<TTrace>;
+};
+export declare const createVoicePostgresSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoicePostgresStoreOptions) => VoiceSessionStore<TSession>;
+export declare const createVoicePostgresReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoicePostgresStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export declare const createVoicePostgresTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoicePostgresStoreOptions) => VoiceOpsTaskStore<TTask>;
+export declare const createVoicePostgresIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoicePostgresStoreOptions) => VoiceIntegrationEventStore<TEvent>;
+export declare const createVoicePostgresExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoicePostgresStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
+export declare const createVoicePostgresTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoicePostgresStoreOptions) => VoiceTraceEventStore<TEvent>;
+export declare const createVoicePostgresTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
+export declare const createVoicePostgresRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoicePostgresStoreOptions) => VoicePostgresRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery>;