@domu-ai/kiban-sdk 1.72.0

package/internal/client.d.ts

@@ -0,0 +1,3055 @@
+export type InternalActionsGetParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+};
+export type InternalActionsGet200Item = {
+    id: string;
+    campaignId: string;
+    actionType: string;
+    provider: string;
+    /** @nullable */
+    configId: string | null;
+    isEnabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalActionsGet400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsGet401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsGet500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsPostParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+};
+/**
+ * Action type to register
+ */
+export type InternalActionsPostBodyActionType = typeof InternalActionsPostBodyActionType[keyof typeof InternalActionsPostBodyActionType];
+export declare const InternalActionsPostBodyActionType: {
+    readonly interactionstart: "interaction.start";
+    readonly interactionend: "interaction.end";
+    readonly contactget: "contact.get";
+    readonly contactupdate: "contact.update";
+    readonly paymentnotify: "payment.notify";
+    readonly paymentdelegate: "payment.delegate";
+};
+export type InternalActionsPostBody = {
+    /** Action type to register */
+    actionType: InternalActionsPostBodyActionType;
+    /**
+     * Provider name (e.g. 'sst', 'livevox', 'nubank')
+     * @minLength 1
+     * @maxLength 50
+     */
+    provider: string;
+    /** Whether the action is enabled */
+    isEnabled?: boolean;
+};
+export type InternalActionsPost201 = {
+    id: string;
+    campaignId: string;
+    actionType: string;
+    provider: string;
+    /** @nullable */
+    configId: string | null;
+    isEnabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalActionsPost400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsPost401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsPost409 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsPost500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsDeleteParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+    /**
+     * @minLength 1
+     */
+    actionId: string;
+};
+export type InternalActionsDeleteBody = {
+    [key: string]: unknown;
+};
+export type InternalActionsDelete400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsDelete401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsDelete404 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalActionsDelete500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalCallsIdPut400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalCallsIdPut401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalCallsIdPut404 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalCallsIdPut500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsGetParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+};
+export type InternalIntegrationsConfigsGet200ItemEnvironment = typeof InternalIntegrationsConfigsGet200ItemEnvironment[keyof typeof InternalIntegrationsConfigsGet200ItemEnvironment];
+export declare const InternalIntegrationsConfigsGet200ItemEnvironment: {
+    readonly staging: "staging";
+    readonly production: "production";
+};
+export type InternalIntegrationsConfigsGet200Item = {
+    id: string;
+    provider: string;
+    name: string;
+    campaignId: string;
+    environment: InternalIntegrationsConfigsGet200ItemEnvironment;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalIntegrationsConfigsGet400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsGet401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsGet500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPostParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+};
+export type InternalIntegrationsConfigsPostBodyEnvironment = typeof InternalIntegrationsConfigsPostBodyEnvironment[keyof typeof InternalIntegrationsConfigsPostBodyEnvironment];
+export declare const InternalIntegrationsConfigsPostBodyEnvironment: {
+    readonly staging: "staging";
+    readonly production: "production";
+};
+export type InternalIntegrationsConfigsPostBodyConfig = {
+    [key: string]: unknown;
+};
+export type InternalIntegrationsConfigsPostBody = {
+    /**
+     * @minLength 1
+     * @maxLength 50
+     */
+    provider: string;
+    /**
+     * @minLength 1
+     * @maxLength 100
+     */
+    name: string;
+    environment: InternalIntegrationsConfigsPostBodyEnvironment;
+    config: InternalIntegrationsConfigsPostBodyConfig;
+};
+export type InternalIntegrationsConfigsPost201Environment = typeof InternalIntegrationsConfigsPost201Environment[keyof typeof InternalIntegrationsConfigsPost201Environment];
+export declare const InternalIntegrationsConfigsPost201Environment: {
+    readonly staging: "staging";
+    readonly production: "production";
+};
+export type InternalIntegrationsConfigsPost201 = {
+    id: string;
+    provider: string;
+    name: string;
+    campaignId: string;
+    environment: InternalIntegrationsConfigsPost201Environment;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalIntegrationsConfigsPost400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPost401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPost409 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPost500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPutParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+    /**
+     * @minLength 1
+     * @maxLength 50
+     */
+    provider: string;
+};
+export type InternalIntegrationsConfigsPutBodyConfig = {
+    [key: string]: unknown;
+};
+export type InternalIntegrationsConfigsPutBody = {
+    /**
+     * @minLength 1
+     * @maxLength 100
+     */
+    name?: string;
+    config?: InternalIntegrationsConfigsPutBodyConfig;
+    isActive?: boolean;
+};
+export type InternalIntegrationsConfigsPut200Environment = typeof InternalIntegrationsConfigsPut200Environment[keyof typeof InternalIntegrationsConfigsPut200Environment];
+export declare const InternalIntegrationsConfigsPut200Environment: {
+    readonly staging: "staging";
+    readonly production: "production";
+};
+export type InternalIntegrationsConfigsPut200 = {
+    id: string;
+    provider: string;
+    name: string;
+    campaignId: string;
+    environment: InternalIntegrationsConfigsPut200Environment;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalIntegrationsConfigsPut400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPut401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPut404 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsPut500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsProviderGetParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+};
+export type InternalIntegrationsConfigsProviderGet200Config = {
+    [key: string]: unknown;
+};
+export type InternalIntegrationsConfigsProviderGet200 = {
+    name: string;
+    config: InternalIntegrationsConfigsProviderGet200Config;
+};
+export type InternalIntegrationsConfigsProviderGet400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsProviderGet401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsProviderGet404 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsProviderGet500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsCacheDeleteParams = {
+    /**
+     * @minLength 1
+     */
+    campaignId: string;
+    /**
+     * @minLength 1
+     * @maxLength 50
+     */
+    provider: string;
+};
+export type InternalIntegrationsConfigsCacheDelete200 = {
+    message: string;
+};
+export type InternalIntegrationsConfigsCacheDelete400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsCacheDelete401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalIntegrationsConfigsCacheDelete500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+/**
+ * Overall system health: healthy (all checks pass), degraded (non-critical issues), unhealthy (critical failures)
+ */
+export type InternalHealthSystemGet200Status = typeof InternalHealthSystemGet200Status[keyof typeof InternalHealthSystemGet200Status];
+export declare const InternalHealthSystemGet200Status: {
+    readonly healthy: "healthy";
+    readonly degraded: "degraded";
+    readonly unhealthy: "unhealthy";
+};
+/**
+ * Deployment environment
+ */
+export type InternalHealthSystemGet200Environment = typeof InternalHealthSystemGet200Environment[keyof typeof InternalHealthSystemGet200Environment];
+export declare const InternalHealthSystemGet200Environment: {
+    readonly development: "development";
+    readonly staging: "staging";
+    readonly production: "production";
+    readonly test: "test";
+};
+export type InternalHealthSystemGet200ChecksMemory = {
+    /** Memory availability - false when utilization exceeds 90% */
+    status: boolean;
+    /** Current heap memory usage in megabytes */
+    usedMb: number;
+    /** Total allocated heap memory in megabytes */
+    totalMb: number;
+    /** Memory utilization percentage (0-100) */
+    percentageUsed: number;
+};
+export type InternalHealthSystemGet200ChecksDisk = {
+    /** Disk space availability - false when free space below 10% */
+    status: boolean;
+    /** Available disk space in megabytes */
+    freeMb: number;
+    /** Free disk space percentage (0-100) */
+    percentageFree: number;
+};
+export type InternalHealthSystemGet200Checks = {
+    memory: InternalHealthSystemGet200ChecksMemory;
+    disk: InternalHealthSystemGet200ChecksDisk;
+};
+export type InternalHealthSystemGet200 = {
+    /** Overall system health: healthy (all checks pass), degraded (non-critical issues), unhealthy (critical failures) */
+    status: InternalHealthSystemGet200Status;
+    /** Server uptime in seconds since last restart */
+    uptime: number;
+    /** ISO 8601 UTC timestamp of health check execution */
+    timestamp: string;
+    /** Current API version */
+    version: string;
+    /** Deployment environment */
+    environment: InternalHealthSystemGet200Environment;
+    checks: InternalHealthSystemGet200Checks;
+};
+export type InternalInboundVapiPostParams = {
+    source_call_id?: string;
+};
+export type InternalInboundVapiPostBodyMessage = {
+    type: string;
+    [key: string]: unknown;
+};
+export type InternalInboundVapiPostBody = {
+    message: InternalInboundVapiPostBodyMessage;
+    [key: string]: unknown;
+};
+export type InternalInboundVapiPost200AssistantModelMessagesItemRole = typeof InternalInboundVapiPost200AssistantModelMessagesItemRole[keyof typeof InternalInboundVapiPost200AssistantModelMessagesItemRole];
+export declare const InternalInboundVapiPost200AssistantModelMessagesItemRole: {
+    readonly system: "system";
+    readonly user: "user";
+    readonly assistant: "assistant";
+};
+export type InternalInboundVapiPost200AssistantModelMessagesItem = {
+    role: InternalInboundVapiPost200AssistantModelMessagesItemRole;
+    content: string;
+};
+export type InternalInboundVapiPost200AssistantModel = {
+    provider: string;
+    model: string;
+    messages: InternalInboundVapiPost200AssistantModelMessagesItem[];
+};
+export type InternalInboundVapiPost200AssistantVoice = {
+    provider: string;
+    voiceId: string;
+    [key: string]: unknown;
+};
+export type InternalInboundVapiPost200AssistantMetadata = {
+    targetId: string;
+    campaignId: string;
+    agentId: string;
+};
+export type InternalInboundVapiPost200Assistant = {
+    name?: string;
+    firstMessage?: string;
+    model: InternalInboundVapiPost200AssistantModel;
+    voice?: InternalInboundVapiPost200AssistantVoice;
+    tools?: (unknown | null)[];
+    endCallFunctionEnabled?: boolean;
+    endCallMessage?: string;
+    metadata?: InternalInboundVapiPost200AssistantMetadata;
+    [key: string]: unknown;
+};
+export type InternalInboundVapiPost200 = {
+    assistant?: InternalInboundVapiPost200Assistant;
+    [key: string]: unknown;
+};
+export type InternalInboundVapiPost400 = {
+    error: string;
+};
+export type InternalInboundVapiPost401 = {
+    error: string;
+};
+export type InternalInboundVapiPost500 = {
+    error: string;
+};
+export type InternalLimitsAgentProviderGet200Item = {
+    id: string;
+    key: string;
+    /** @minimum 0 */
+    limit: number;
+    /**
+     * @minimum 0
+     * @maximum 100
+     */
+    safetyMarginPercent: number;
+    /** @nullable */
+    effectiveLimit: number | null;
+    /**
+     * Current number of active calls for this provider
+     * @minimum 0
+     */
+    currentUsage: number;
+    /**
+     * Available slots (effectiveLimit - currentUsage)
+     * @minimum 0
+     */
+    available: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalLimitsAgentProviderGet401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalLimitsAgentProviderGet500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalLimitsAgentProviderGet503 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalLimitsAgentProviderPostBody = {
+    /**
+     * Unique identifier for the agent provider (e.g., 'vapi', 'livekit'). Must be Redis key compliant (no whitespace).
+     * @minLength 1
+     * @pattern ^[^\s]*$
+     */
+    key: string;
+    /**
+     * Maximum concurrent calls allowed
+     * @minimum 0
+     */
+    limit: number;
+    /**
+     * Safety margin percentage (0-100)
+     * @minimum 0
+     * @maximum 100
+     */
+    safetyMarginPercent?: number;
+};
+export type InternalLimitsAgentProviderPost200 = {
+    id: string;
+    key: string;
+    /** @minimum 0 */
+    limit: number;
+    /**
+     * @minimum 0
+     * @maximum 100
+     */
+    safetyMarginPercent: number;
+    /** @nullable */
+    effectiveLimit: number | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalLimitsAgentProviderPost201 = {
+    id: string;
+    key: string;
+    /** @minimum 0 */
+    limit: number;
+    /**
+     * @minimum 0
+     * @maximum 100
+     */
+    safetyMarginPercent: number;
+    /** @nullable */
+    effectiveLimit: number | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type InternalLimitsAgentProviderPost400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalLimitsAgentProviderPost401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalLimitsAgentProviderPost503 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalPaymentsTwimlGetParams = {
+    /**
+     * Campaign ID for callback correlation
+     */
+    campaignId: string;
+    /**
+     * Call ID for callback correlation
+     */
+    callId: string;
+    /**
+     * Call provider (e.g., "vapi")
+     */
+    callProvider?: string;
+    /**
+     * Payment amount (e.g., "208.51")
+     * @pattern ^\d+(\.\d{1,2})?$
+     */
+    amount: string;
+    /**
+     * Payment date in YYYY-MM-DD format
+     */
+    paymentDate: string;
+    /**
+     * Whether payment is for today ("true" or "false")
+     */
+    isToday: InternalPaymentsTwimlGetIsToday;
+};
+export type InternalPaymentsTwimlGetIsToday = typeof InternalPaymentsTwimlGetIsToday[keyof typeof InternalPaymentsTwimlGetIsToday];
+export declare const InternalPaymentsTwimlGetIsToday: {
+    readonly true: "true";
+    readonly false: "false";
+};
+export type InternalPaymentsTwimlGet400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalPaymentsTransferPostBodyPaymentMethod = typeof InternalPaymentsTransferPostBodyPaymentMethod[keyof typeof InternalPaymentsTransferPostBodyPaymentMethod];
+export declare const InternalPaymentsTransferPostBodyPaymentMethod: {
+    readonly 'credit-card': "credit-card";
+    readonly ach: "ach";
+    readonly 'saved-payment-method': "saved-payment-method";
+};
+export type InternalPaymentsTransferPostBodyPaymentPlanFrequency = typeof InternalPaymentsTransferPostBodyPaymentPlanFrequency[keyof typeof InternalPaymentsTransferPostBodyPaymentPlanFrequency];
+export declare const InternalPaymentsTransferPostBodyPaymentPlanFrequency: {
+    readonly daily: "daily";
+    readonly weekly: "weekly";
+    readonly biweekly: "biweekly";
+    readonly monthly: "monthly";
+};
+export type InternalPaymentsTransferPostBodyPaymentPlanType = typeof InternalPaymentsTransferPostBodyPaymentPlanType[keyof typeof InternalPaymentsTransferPostBodyPaymentPlanType];
+export declare const InternalPaymentsTransferPostBodyPaymentPlanType: {
+    readonly recurring: "recurring";
+    readonly promiseToPay: "promiseToPay";
+};
+export type InternalPaymentsTransferPostBody = {
+    campaignId: string;
+    amount: number;
+    callId: string;
+    callerPhone: string;
+    callerName?: string;
+    paymentMethod?: InternalPaymentsTransferPostBodyPaymentMethod;
+    paymentMethodId?: string;
+    paymentDate?: string;
+    paymentPlanFrequency?: InternalPaymentsTransferPostBodyPaymentPlanFrequency;
+    paymentPlanType?: InternalPaymentsTransferPostBodyPaymentPlanType;
+    /** @minimum 1 */
+    numberOfPayments?: number;
+};
+export type InternalPaymentsTransferPost200 = {
+    twiml: string;
+    redisSessionId: string;
+    paymentProvider: string;
+    paymentConnector: string;
+};
+export type InternalPaymentsTransferPost400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalPaymentsTransferPost500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalPaymentsCallbackPostParams = {
+    sessionId: string;
+};
+export type InternalPaymentsCallbackPostBodyResult = typeof InternalPaymentsCallbackPostBodyResult[keyof typeof InternalPaymentsCallbackPostBodyResult];
+export declare const InternalPaymentsCallbackPostBodyResult: {
+    readonly success: "success";
+    readonly 'payment-connector-error': "payment-connector-error";
+    readonly 'caller-interrupted-before-completion': "caller-interrupted-before-completion";
+    readonly 'caller-hung-up-before-completion': "caller-hung-up-before-completion";
+    readonly 'caller-interrupted-with-star': "caller-interrupted-with-star";
+    readonly 'validation-error': "validation-error";
+    readonly 'too-many-failed-attempts': "too-many-failed-attempts";
+    readonly 'too-many-attempts': "too-many-attempts";
+    readonly 'too-many-attempts-exceeded': "too-many-attempts-exceeded";
+    readonly 'card-declined': "card-declined";
+    readonly 'input-validation-failed': "input-validation-failed";
+    readonly 'expired-card': "expired-card";
+    readonly 'input-timeout': "input-timeout";
+    readonly 'internal-error': "internal-error";
+};
+export type InternalPaymentsCallbackPostBody = {
+    CallSid: string;
+    AccountSid: string;
+    Result?: InternalPaymentsCallbackPostBodyResult;
+    PaymentMethod?: string;
+    PaymentConfirmationCode?: string;
+    PaymentToken?: string;
+    ProfileId?: string;
+    PaymentError?: string;
+    PayErrorCode?: string;
+    ErrorCode?: string;
+    ErrorMessage?: string;
+    Digits?: string;
+    PaymentCardNumber?: string;
+    PaymentCardType?: string;
+    PaymentCardExpirationDate?: string;
+    SecurityCode?: string;
+    PaymentCardPostalCode?: string;
+    BankAccountNumber?: string;
+    BankRoutingNumber?: string;
+    BankAccountType?: string;
+};
+export type InternalQueuesCallJobPostBodyPriority = typeof InternalQueuesCallJobPostBodyPriority[keyof typeof InternalQueuesCallJobPostBodyPriority];
+export declare const InternalQueuesCallJobPostBodyPriority: {
+    readonly standard: "standard";
+};
+export type InternalQueuesCallJobPostBody = {
+    /**
+     * ID of the target to call
+     * @minLength 1
+     */
+    targetId: string;
+    /**
+     * Attempt number for calling the target
+     * @minimum 1
+     */
+    attempt: number;
+    /**
+     * Slug for the agent
+     * @minLength 1
+     */
+    slug: string;
+    /**
+     * ID of the campaign
+     * @minLength 1
+     */
+    campaignId: string;
+    /**
+     * Label for the call
+     * @minLength 1
+     */
+    label: string;
+    priority?: InternalQueuesCallJobPostBodyPriority;
+};
+/**
+ * Job status - always 'queued' when successfully enqueued
+ */
+export type InternalQueuesCallJobPost201Status = typeof InternalQueuesCallJobPost201Status[keyof typeof InternalQueuesCallJobPost201Status];
+export declare const InternalQueuesCallJobPost201Status: {
+    readonly queued: "queued";
+};
+export type InternalQueuesCallJobPost201 = {
+    /** Unique identifier for the queued job */
+    jobId: string;
+    /** Job status - always 'queued' when successfully enqueued */
+    status: InternalQueuesCallJobPost201Status;
+    /** Human-readable confirmation message */
+    message: string;
+};
+export type InternalQueuesCallJobPost400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalQueuesCallJobPost500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalSipCallsJambonzPostBodyCallStatus = typeof InternalSipCallsJambonzPostBodyCallStatus[keyof typeof InternalSipCallsJambonzPostBodyCallStatus];
+export declare const InternalSipCallsJambonzPostBodyCallStatus: {
+    readonly trying: "trying";
+    readonly ringing: "ringing";
+    readonly 'early-media': "early-media";
+    readonly 'in-progress': "in-progress";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly 'no-answer': "no-answer";
+    readonly busy: "busy";
+};
+export type InternalSipCallsJambonzPostBodyDirection = typeof InternalSipCallsJambonzPostBodyDirection[keyof typeof InternalSipCallsJambonzPostBodyDirection];
+export declare const InternalSipCallsJambonzPostBodyDirection: {
+    readonly inbound: "inbound";
+    readonly outbound: "outbound";
+};
+/**
+ * SIP headers
+ */
+export type InternalSipCallsJambonzPostBodySipHeaders = {
+    [key: string]: string;
+};
+export type InternalSipCallsJambonzPostBodySip = {
+    /** SIP headers */
+    headers: InternalSipCallsJambonzPostBodySipHeaders;
+    body?: string;
+    method?: string;
+    version?: string;
+    uri?: string;
+    raw?: string;
+};
+export type InternalSipCallsJambonzPostBody = {
+    call_sid: string;
+    call_status: InternalSipCallsJambonzPostBodyCallStatus;
+    direction?: InternalSipCallsJambonzPostBodyDirection;
+    call_id?: string;
+    account_sid?: string;
+    from?: string;
+    to?: string;
+    caller_name?: string;
+    sip_status?: number;
+    sip_reason?: string;
+    originating_sip_trunk_name?: string;
+    originating_sip_ip?: string;
+    application_sid?: string;
+    local_sip_address?: string;
+    service_provider_sid?: string;
+    sbc_callid?: string;
+    trace_id?: string;
+    sip?: InternalSipCallsJambonzPostBodySip;
+};
+export type InternalSipCallsJambonzPost200 = ({
+    verb: 'dial';
+    callerId?: string;
+    answerOnBridge?: boolean;
+    target: ({
+        type: 'sip' | 'phone';
+        sipUri?: string;
+        number?: string;
+        trunk?: string;
+    })[];
+    headers?: {
+        [key: string]: string;
+    };
+} | {
+    verb: 'sip:decline';
+    status: number;
+    reason?: string;
+})[] | {
+    [key: string]: unknown;
+};
+export type InternalSipCallsJambonzPost400 = {
+    error: string;
+    code?: string;
+};
+export type InternalSipCallsJambonzPost401 = {
+    error: string;
+    code?: string;
+};
+export type InternalSipCallsJambonzPost404 = {
+    error: string;
+    code?: string;
+};
+export type InternalSipCallsJambonzPost500 = {
+    error: string;
+    code?: string;
+};
+export type InternalSipCallsJambonzHealthGet200Status = typeof InternalSipCallsJambonzHealthGet200Status[keyof typeof InternalSipCallsJambonzHealthGet200Status];
+export declare const InternalSipCallsJambonzHealthGet200Status: {
+    readonly ok: "ok";
+};
+export type InternalSipCallsJambonzHealthGet200 = {
+    status: InternalSipCallsJambonzHealthGet200Status;
+    active_routes: boolean;
+};
+export type InternalSipCallsJambonzHealthGet503Status = typeof InternalSipCallsJambonzHealthGet503Status[keyof typeof InternalSipCallsJambonzHealthGet503Status];
+export declare const InternalSipCallsJambonzHealthGet503Status: {
+    readonly unhealthy: "unhealthy";
+};
+export type InternalSipCallsJambonzHealthGet503 = {
+    status: InternalSipCallsJambonzHealthGet503Status;
+    reason: string;
+};
+export type InternalTargetsUploadPostBody = {
+    /**
+     * ID of the campaign
+     * @minLength 1
+     */
+    campaignId: string;
+    /**
+     * S3 key of the uploaded CSV file
+     * @minLength 1
+     */
+    fileKey: string;
+    /**
+     * S3 bucket name (defaults to configured bucket)
+     * @minLength 1
+     */
+    bucket?: string;
+};
+export type InternalTargetsUploadPost202 = {
+    /** Unique identifier for the queued upload job */
+    jobId: string;
+    /** Human-readable confirmation message */
+    message: string;
+};
+export type InternalTargetsUploadPost400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalTargetsUploadPost404 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalTargetsUploadPost500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalTargetsIdentifierGetParams = {
+    /**
+     * Type of identifier: 'phone' for phone number, 'external_id' for account number
+     */
+    identifierType?: InternalTargetsIdentifierGetIdentifierType;
+    /**
+     * Comma-separated column names to retrieve from targets table
+     */
+    fields: string;
+    /**
+     * Campaign ID to filter target lookup
+     */
+    campaignId: string;
+};
+export type InternalTargetsIdentifierGetIdentifierType = typeof InternalTargetsIdentifierGetIdentifierType[keyof typeof InternalTargetsIdentifierGetIdentifierType];
+export declare const InternalTargetsIdentifierGetIdentifierType: {
+    readonly phone: "phone";
+    readonly external_id: "external_id";
+};
+export type InternalTargetsIdentifierGet200Item = {
+    [key: string]: unknown | null;
+};
+export type InternalTargetsIdentifierGet400 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalTargetsIdentifierGet404 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalTargetsIdentifierGet500 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+export type InternalVapiWebhookPostBodyMessage = {
+    type: 'status-update';
+    status: 'queued' | 'ringing' | 'in-progress' | 'forwarding' | 'ended';
+    endedReason?: string;
+    call?: {
+        /** @minLength 1 */
+        id: string;
+        /** @minLength 1 */
+        orgId?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        type?: 'inboundPhoneCall' | 'outboundPhoneCall' | 'webCall';
+        status?: 'queued' | 'ringing' | 'in-progress' | 'forwarding' | 'ended';
+        phoneCallProvider?: string;
+        phoneCallProviderId?: string;
+        /** @minLength 1 */
+        phoneNumberId?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        assistant?: unknown | null;
+        /** @nullable */
+        squadId?: string | null;
+        squad?: unknown | null;
+        phoneCallTransport?: string;
+        startedAt?: string;
+        endedAt?: string;
+        endedReason?: string;
+        cost?: number;
+        costBreakdown?: {
+            vapi?: number;
+            transport?: number;
+            stt?: number;
+            llm?: number;
+            tts?: number;
+            total?: number;
+            llmPromptTokens?: number;
+            llmCompletionTokens?: number;
+            ttsCharacters?: number;
+        };
+        messages?: ({
+            role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+            message?: string;
+            name?: string;
+            function_call?: unknown | null;
+            tool_calls?: {
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name: string;
+                    arguments?: string;
+                };
+                result?: string;
+            }[];
+            time?: number;
+            endTime?: number;
+            secondsFromStart?: number;
+        })[];
+        transcript?: string;
+        recordingUrl?: string;
+        stereoRecordingUrl?: string;
+        artifact?: {
+            recording?: {
+                recordingUrl?: string;
+                stereoRecordingUrl?: string;
+            };
+            transcript?: string;
+            messages?: ({
+                role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+                message?: string;
+                name?: string;
+                function_call?: unknown | null;
+                tool_calls?: {
+                    id?: string;
+                    type?: 'function';
+                    function?: {
+                        name: string;
+                        arguments?: string;
+                    };
+                    result?: string;
+                }[];
+                time?: number;
+                endTime?: number;
+                secondsFromStart?: number;
+            })[];
+            messagesOpenAIFormatted?: (unknown | null)[];
+            recordingUrl?: string;
+            stereoRecordingUrl?: string;
+            videoRecordingUrl?: string;
+            videoRecordingStartDelaySeconds?: number;
+            performanceMetrics?: {
+                modelLatencyP50?: number;
+                modelLatencyP90?: number;
+                modelLatencyP95?: number;
+                modelLatencyP99?: number;
+                modelLatencyAverage?: number;
+                voiceLatencyP50?: number;
+                voiceLatencyP90?: number;
+                voiceLatencyP95?: number;
+                voiceLatencyP99?: number;
+                voiceLatencyAverage?: number;
+                transcriberLatencyP50?: number;
+                transcriberLatencyP90?: number;
+                transcriberLatencyP95?: number;
+                transcriberLatencyP99?: number;
+                transcriberLatencyAverage?: number;
+                endpointingLatencyP50?: number;
+                endpointingLatencyP90?: number;
+                endpointingLatencyP95?: number;
+                endpointingLatencyP99?: number;
+                endpointingLatencyAverage?: number;
+                turnLatencyP50?: number;
+                turnLatencyP90?: number;
+                turnLatencyP95?: number;
+                turnLatencyP99?: number;
+                turnLatencyAverage?: number;
+            };
+        };
+        analysis?: {
+            summary?: string;
+            structuredData?: {
+                [key: string]: unknown;
+            };
+            successEvaluation?: string;
+        };
+    };
+    phoneNumber?: {
+        /** @minLength 1 */
+        id?: string;
+        /** @minLength 1 */
+        orgId?: string;
+        number?: string;
+        name?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        /** @nullable */
+        squadId?: string | null;
+        createdAt?: string;
+        updatedAt?: string;
+    };
+    customer?: {
+        number?: string;
+        name?: string;
+        extension?: string;
+    };
+    timestamp?: string;
+} | {
+    type: 'end-of-call-report';
+    call: {
+        /** @minLength 1 */
+        id: string;
+        /** @minLength 1 */
+        orgId?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        type?: 'inboundPhoneCall' | 'outboundPhoneCall' | 'webCall';
+        status?: 'queued' | 'ringing' | 'in-progress' | 'forwarding' | 'ended';
+        phoneCallProvider?: string;
+        phoneCallProviderId?: string;
+        /** @minLength 1 */
+        phoneNumberId?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        assistant?: unknown | null;
+        /** @nullable */
+        squadId?: string | null;
+        squad?: unknown | null;
+        phoneCallTransport?: string;
+        startedAt?: string;
+        endedAt?: string;
+        endedReason?: string;
+        cost?: number;
+        costBreakdown?: {
+            vapi?: number;
+            transport?: number;
+            stt?: number;
+            llm?: number;
+            tts?: number;
+            total?: number;
+            llmPromptTokens?: number;
+            llmCompletionTokens?: number;
+            ttsCharacters?: number;
+        };
+        messages?: ({
+            role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+            message?: string;
+            name?: string;
+            function_call?: unknown | null;
+            tool_calls?: {
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name: string;
+                    arguments?: string;
+                };
+                result?: string;
+            }[];
+            time?: number;
+            endTime?: number;
+            secondsFromStart?: number;
+        })[];
+        transcript?: string;
+        recordingUrl?: string;
+        stereoRecordingUrl?: string;
+        artifact?: {
+            recording?: {
+                recordingUrl?: string;
+                stereoRecordingUrl?: string;
+            };
+            transcript?: string;
+            messages?: ({
+                role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+                message?: string;
+                name?: string;
+                function_call?: unknown | null;
+                tool_calls?: {
+                    id?: string;
+                    type?: 'function';
+                    function?: {
+                        name: string;
+                        arguments?: string;
+                    };
+                    result?: string;
+                }[];
+                time?: number;
+                endTime?: number;
+                secondsFromStart?: number;
+            })[];
+            messagesOpenAIFormatted?: (unknown | null)[];
+            recordingUrl?: string;
+            stereoRecordingUrl?: string;
+            videoRecordingUrl?: string;
+            videoRecordingStartDelaySeconds?: number;
+            performanceMetrics?: {
+                modelLatencyP50?: number;
+                modelLatencyP90?: number;
+                modelLatencyP95?: number;
+                modelLatencyP99?: number;
+                modelLatencyAverage?: number;
+                voiceLatencyP50?: number;
+                voiceLatencyP90?: number;
+                voiceLatencyP95?: number;
+                voiceLatencyP99?: number;
+                voiceLatencyAverage?: number;
+                transcriberLatencyP50?: number;
+                transcriberLatencyP90?: number;
+                transcriberLatencyP95?: number;
+                transcriberLatencyP99?: number;
+                transcriberLatencyAverage?: number;
+                endpointingLatencyP50?: number;
+                endpointingLatencyP90?: number;
+                endpointingLatencyP95?: number;
+                endpointingLatencyP99?: number;
+                endpointingLatencyAverage?: number;
+                turnLatencyP50?: number;
+                turnLatencyP90?: number;
+                turnLatencyP95?: number;
+                turnLatencyP99?: number;
+                turnLatencyAverage?: number;
+            };
+        };
+        analysis?: {
+            summary?: string;
+            structuredData?: {
+                [key: string]: unknown;
+            };
+            successEvaluation?: string;
+        };
+    };
+    endedReason?: string;
+    artifact?: {
+        recording?: {
+            recordingUrl?: string;
+            stereoRecordingUrl?: string;
+        };
+        transcript?: string;
+        messages?: ({
+            role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+            message?: string;
+            name?: string;
+            function_call?: unknown | null;
+            tool_calls?: {
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name: string;
+                    arguments?: string;
+                };
+                result?: string;
+            }[];
+            time?: number;
+            endTime?: number;
+            secondsFromStart?: number;
+        })[];
+        messagesOpenAIFormatted?: (unknown | null)[];
+        recordingUrl?: string;
+        stereoRecordingUrl?: string;
+        videoRecordingUrl?: string;
+        videoRecordingStartDelaySeconds?: number;
+        performanceMetrics?: {
+            modelLatencyP50?: number;
+            modelLatencyP90?: number;
+            modelLatencyP95?: number;
+            modelLatencyP99?: number;
+            modelLatencyAverage?: number;
+            voiceLatencyP50?: number;
+            voiceLatencyP90?: number;
+            voiceLatencyP95?: number;
+            voiceLatencyP99?: number;
+            voiceLatencyAverage?: number;
+            transcriberLatencyP50?: number;
+            transcriberLatencyP90?: number;
+            transcriberLatencyP95?: number;
+            transcriberLatencyP99?: number;
+            transcriberLatencyAverage?: number;
+            endpointingLatencyP50?: number;
+            endpointingLatencyP90?: number;
+            endpointingLatencyP95?: number;
+            endpointingLatencyP99?: number;
+            endpointingLatencyAverage?: number;
+            turnLatencyP50?: number;
+            turnLatencyP90?: number;
+            turnLatencyP95?: number;
+            turnLatencyP99?: number;
+            turnLatencyAverage?: number;
+        };
+    };
+    timestamp?: string;
+    analysis?: {
+        summary?: string;
+        structuredData?: {
+            [key: string]: unknown;
+        };
+        successEvaluation?: string;
+    };
+    messages?: ({
+        role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+        message?: string;
+        name?: string;
+        function_call?: unknown | null;
+        tool_calls?: {
+            id?: string;
+            type?: 'function';
+            function?: {
+                name: string;
+                arguments?: string;
+            };
+            result?: string;
+        }[];
+        time?: number;
+        endTime?: number;
+        secondsFromStart?: number;
+    })[];
+    phoneNumber?: {
+        /** @minLength 1 */
+        id?: string;
+        /** @minLength 1 */
+        orgId?: string;
+        number?: string;
+        name?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        /** @nullable */
+        squadId?: string | null;
+        createdAt?: string;
+        updatedAt?: string;
+    };
+    customer?: {
+        number?: string;
+        name?: string;
+        extension?: string;
+    };
+    stereoRecordingUrl?: string;
+    recordingUrl?: string;
+    transcript?: string;
+    summary?: string;
+} | {
+    type: 'transcript';
+    transcriptType: 'partial' | 'final';
+    transcript: string;
+    role: 'assistant' | 'user';
+    timestamp?: string;
+    call?: {
+        /** @minLength 1 */
+        id: string;
+        /** @minLength 1 */
+        orgId?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        type?: 'inboundPhoneCall' | 'outboundPhoneCall' | 'webCall';
+        status?: 'queued' | 'ringing' | 'in-progress' | 'forwarding' | 'ended';
+        phoneCallProvider?: string;
+        phoneCallProviderId?: string;
+        /** @minLength 1 */
+        phoneNumberId?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        assistant?: unknown | null;
+        /** @nullable */
+        squadId?: string | null;
+        squad?: unknown | null;
+        phoneCallTransport?: string;
+        startedAt?: string;
+        endedAt?: string;
+        endedReason?: string;
+        cost?: number;
+        costBreakdown?: {
+            vapi?: number;
+            transport?: number;
+            stt?: number;
+            llm?: number;
+            tts?: number;
+            total?: number;
+            llmPromptTokens?: number;
+            llmCompletionTokens?: number;
+            ttsCharacters?: number;
+        };
+        messages?: ({
+            role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+            message?: string;
+            name?: string;
+            function_call?: unknown | null;
+            tool_calls?: {
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name: string;
+                    arguments?: string;
+                };
+                result?: string;
+            }[];
+            time?: number;
+            endTime?: number;
+            secondsFromStart?: number;
+        })[];
+        transcript?: string;
+        recordingUrl?: string;
+        stereoRecordingUrl?: string;
+        artifact?: {
+            recording?: {
+                recordingUrl?: string;
+                stereoRecordingUrl?: string;
+            };
+            transcript?: string;
+            messages?: ({
+                role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+                message?: string;
+                name?: string;
+                function_call?: unknown | null;
+                tool_calls?: {
+                    id?: string;
+                    type?: 'function';
+                    function?: {
+                        name: string;
+                        arguments?: string;
+                    };
+                    result?: string;
+                }[];
+                time?: number;
+                endTime?: number;
+                secondsFromStart?: number;
+            })[];
+            messagesOpenAIFormatted?: (unknown | null)[];
+            recordingUrl?: string;
+            stereoRecordingUrl?: string;
+            videoRecordingUrl?: string;
+            videoRecordingStartDelaySeconds?: number;
+            performanceMetrics?: {
+                modelLatencyP50?: number;
+                modelLatencyP90?: number;
+                modelLatencyP95?: number;
+                modelLatencyP99?: number;
+                modelLatencyAverage?: number;
+                voiceLatencyP50?: number;
+                voiceLatencyP90?: number;
+                voiceLatencyP95?: number;
+                voiceLatencyP99?: number;
+                voiceLatencyAverage?: number;
+                transcriberLatencyP50?: number;
+                transcriberLatencyP90?: number;
+                transcriberLatencyP95?: number;
+                transcriberLatencyP99?: number;
+                transcriberLatencyAverage?: number;
+                endpointingLatencyP50?: number;
+                endpointingLatencyP90?: number;
+                endpointingLatencyP95?: number;
+                endpointingLatencyP99?: number;
+                endpointingLatencyAverage?: number;
+                turnLatencyP50?: number;
+                turnLatencyP90?: number;
+                turnLatencyP95?: number;
+                turnLatencyP99?: number;
+                turnLatencyAverage?: number;
+            };
+        };
+        analysis?: {
+            summary?: string;
+            structuredData?: {
+                [key: string]: unknown;
+            };
+            successEvaluation?: string;
+        };
+    };
+} | {
+    type: 'conversation-update';
+    conversation: ({
+        role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+        message?: string;
+        name?: string;
+        function_call?: unknown | null;
+        tool_calls?: {
+            id?: string;
+            type?: 'function';
+            function?: {
+                name: string;
+                arguments?: string;
+            };
+            result?: string;
+        }[];
+        time?: number;
+        endTime?: number;
+        secondsFromStart?: number;
+    })[];
+    timestamp?: string;
+} | {
+    type: 'assistant-request';
+    call?: {
+        /** @minLength 1 */
+        id: string;
+        /** @minLength 1 */
+        orgId?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        type?: 'inboundPhoneCall' | 'outboundPhoneCall' | 'webCall';
+        status?: 'queued' | 'ringing' | 'in-progress' | 'forwarding' | 'ended';
+        phoneCallProvider?: string;
+        phoneCallProviderId?: string;
+        /** @minLength 1 */
+        phoneNumberId?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        assistant?: unknown | null;
+        /** @nullable */
+        squadId?: string | null;
+        squad?: unknown | null;
+        phoneCallTransport?: string;
+        startedAt?: string;
+        endedAt?: string;
+        endedReason?: string;
+        cost?: number;
+        costBreakdown?: {
+            vapi?: number;
+            transport?: number;
+            stt?: number;
+            llm?: number;
+            tts?: number;
+            total?: number;
+            llmPromptTokens?: number;
+            llmCompletionTokens?: number;
+            ttsCharacters?: number;
+        };
+        messages?: ({
+            role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+            message?: string;
+            name?: string;
+            function_call?: unknown | null;
+            tool_calls?: {
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name: string;
+                    arguments?: string;
+                };
+                result?: string;
+            }[];
+            time?: number;
+            endTime?: number;
+            secondsFromStart?: number;
+        })[];
+        transcript?: string;
+        recordingUrl?: string;
+        stereoRecordingUrl?: string;
+        artifact?: {
+            recording?: {
+                recordingUrl?: string;
+                stereoRecordingUrl?: string;
+            };
+            transcript?: string;
+            messages?: ({
+                role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+                message?: string;
+                name?: string;
+                function_call?: unknown | null;
+                tool_calls?: {
+                    id?: string;
+                    type?: 'function';
+                    function?: {
+                        name: string;
+                        arguments?: string;
+                    };
+                    result?: string;
+                }[];
+                time?: number;
+                endTime?: number;
+                secondsFromStart?: number;
+            })[];
+            messagesOpenAIFormatted?: (unknown | null)[];
+            recordingUrl?: string;
+            stereoRecordingUrl?: string;
+            videoRecordingUrl?: string;
+            videoRecordingStartDelaySeconds?: number;
+            performanceMetrics?: {
+                modelLatencyP50?: number;
+                modelLatencyP90?: number;
+                modelLatencyP95?: number;
+                modelLatencyP99?: number;
+                modelLatencyAverage?: number;
+                voiceLatencyP50?: number;
+                voiceLatencyP90?: number;
+                voiceLatencyP95?: number;
+                voiceLatencyP99?: number;
+                voiceLatencyAverage?: number;
+                transcriberLatencyP50?: number;
+                transcriberLatencyP90?: number;
+                transcriberLatencyP95?: number;
+                transcriberLatencyP99?: number;
+                transcriberLatencyAverage?: number;
+                endpointingLatencyP50?: number;
+                endpointingLatencyP90?: number;
+                endpointingLatencyP95?: number;
+                endpointingLatencyP99?: number;
+                endpointingLatencyAverage?: number;
+                turnLatencyP50?: number;
+                turnLatencyP90?: number;
+                turnLatencyP95?: number;
+                turnLatencyP99?: number;
+                turnLatencyAverage?: number;
+            };
+        };
+        analysis?: {
+            summary?: string;
+            structuredData?: {
+                [key: string]: unknown;
+            };
+            successEvaluation?: string;
+        };
+    };
+    phoneNumber?: {
+        /** @minLength 1 */
+        id?: string;
+        /** @minLength 1 */
+        orgId?: string;
+        number?: string;
+        name?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        /** @nullable */
+        squadId?: string | null;
+        createdAt?: string;
+        updatedAt?: string;
+    };
+    customer?: {
+        number?: string;
+        name?: string;
+        extension?: string;
+    };
+    timestamp?: string;
+} | {
+    type: 'tool-calls';
+    toolCalls: {
+        id?: string;
+        type?: 'function';
+        function?: {
+            name: string;
+            arguments?: string;
+        };
+        result?: string;
+    }[];
+    timestamp?: string;
+} | {
+    type: 'transfer-destination-request';
+    call?: {
+        /** @minLength 1 */
+        id: string;
+        /** @minLength 1 */
+        orgId?: string;
+        createdAt?: string;
+        updatedAt?: string;
+        type?: 'inboundPhoneCall' | 'outboundPhoneCall' | 'webCall';
+        status?: 'queued' | 'ringing' | 'in-progress' | 'forwarding' | 'ended';
+        phoneCallProvider?: string;
+        phoneCallProviderId?: string;
+        /** @minLength 1 */
+        phoneNumberId?: string;
+        /** @nullable */
+        assistantId?: string | null;
+        assistant?: unknown | null;
+        /** @nullable */
+        squadId?: string | null;
+        squad?: unknown | null;
+        phoneCallTransport?: string;
+        startedAt?: string;
+        endedAt?: string;
+        endedReason?: string;
+        cost?: number;
+        costBreakdown?: {
+            vapi?: number;
+            transport?: number;
+            stt?: number;
+            llm?: number;
+            tts?: number;
+            total?: number;
+            llmPromptTokens?: number;
+            llmCompletionTokens?: number;
+            ttsCharacters?: number;
+        };
+        messages?: ({
+            role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+            message?: string;
+            name?: string;
+            function_call?: unknown | null;
+            tool_calls?: {
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name: string;
+                    arguments?: string;
+                };
+                result?: string;
+            }[];
+            time?: number;
+            endTime?: number;
+            secondsFromStart?: number;
+        })[];
+        transcript?: string;
+        recordingUrl?: string;
+        stereoRecordingUrl?: string;
+        artifact?: {
+            recording?: {
+                recordingUrl?: string;
+                stereoRecordingUrl?: string;
+            };
+            transcript?: string;
+            messages?: ({
+                role: 'assistant' | 'user' | 'system' | 'function' | 'tool';
+                message?: string;
+                name?: string;
+                function_call?: unknown | null;
+                tool_calls?: {
+                    id?: string;
+                    type?: 'function';
+                    function?: {
+                        name: string;
+                        arguments?: string;
+                    };
+                    result?: string;
+                }[];
+                time?: number;
+                endTime?: number;
+                secondsFromStart?: number;
+            })[];
+            messagesOpenAIFormatted?: (unknown | null)[];
+            recordingUrl?: string;
+            stereoRecordingUrl?: string;
+            videoRecordingUrl?: string;
+            videoRecordingStartDelaySeconds?: number;
+            performanceMetrics?: {
+                modelLatencyP50?: number;
+                modelLatencyP90?: number;
+                modelLatencyP95?: number;
+                modelLatencyP99?: number;
+                modelLatencyAverage?: number;
+                voiceLatencyP50?: number;
+                voiceLatencyP90?: number;
+                voiceLatencyP95?: number;
+                voiceLatencyP99?: number;
+                voiceLatencyAverage?: number;
+                transcriberLatencyP50?: number;
+                transcriberLatencyP90?: number;
+                transcriberLatencyP95?: number;
+                transcriberLatencyP99?: number;
+                transcriberLatencyAverage?: number;
+                endpointingLatencyP50?: number;
+                endpointingLatencyP90?: number;
+                endpointingLatencyP95?: number;
+                endpointingLatencyP99?: number;
+                endpointingLatencyAverage?: number;
+                turnLatencyP50?: number;
+                turnLatencyP90?: number;
+                turnLatencyP95?: number;
+                turnLatencyP99?: number;
+                turnLatencyAverage?: number;
+            };
+        };
+        analysis?: {
+            summary?: string;
+            structuredData?: {
+                [key: string]: unknown;
+            };
+            successEvaluation?: string;
+        };
+    };
+    timestamp?: string;
+} | {
+    type: 'transfer-update';
+    destination: {
+        type: string;
+        number?: string;
+        message?: string;
+    };
+    timestamp?: string;
+} | {
+    type: 'language-change-detected';
+    language: string;
+    timestamp?: string;
+} | {
+    type: 'phone-call-control';
+    request: {
+        type: string;
+    };
+    timestamp?: string;
+};
+export type InternalVapiWebhookPostBody = {
+    message: InternalVapiWebhookPostBodyMessage;
+};
+export type InternalVapiWebhookPost200 = {
+    /** Whether the webhook was received */
+    received: boolean;
+};
+export type InternalVapiWebhookPost400 = {
+    /** Error message */
+    error: string;
+};
+export type InternalVapiWebhookPost401 = {
+    /** Error message */
+    error: string;
+};
+export type InternalVapiWebhookPost500 = {
+    /** Error message */
+    error: string;
+};
+export type InternalKanbanWebhookPostBody = {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'room_created';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'call_agent_dispatched';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'call_sip_initiated';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'call_failed';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+    error: {
+        stage: string;
+        code: string;
+        message: string;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'transcription';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+    transcription: {
+        transcript: string;
+        role: string;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'agent_room_close';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'room_finished';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'participant_joined';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+    participant: {
+        sid: string;
+        identity: string;
+        state?: string;
+        name?: string;
+        kind?: 'STANDARD' | 'INGRESS' | 'EGRESS' | 'SIP' | 'AGENT';
+        joinedAt?: string | number;
+        joinedAtMs?: string | number;
+    };
+} | {
+    /** @minLength 1 */
+    id: string;
+    /** @nullable */
+    createdAt: number | null;
+    numDropped?: number;
+    event: 'participant_left';
+    room: {
+        sid?: string;
+        /** @minLength 1 */
+        name: string;
+        metadata: {
+            call_id: string;
+            campaign_id: string;
+            target_id: string;
+            /** @nullable */
+            closing_reason?: string | null;
+            /** @nullable */
+            closed_at?: number | null;
+            usage_metrics?: {
+                usage: {
+                    llm_prompt_tokens?: number;
+                    llm_completion_tokens?: number;
+                    llm_prompt_cached_tokens?: number;
+                    llm_input_audio_tokens?: number;
+                    llm_output_audio_tokens?: number;
+                    tts_characters_count?: number;
+                    tts_audio_duration?: number;
+                    stt_audio_duration?: number;
+                };
+                models: {
+                    llm?: {
+                        provider: string;
+                        model: string;
+                    };
+                    tts?: {
+                        provider: string;
+                        model: string;
+                    };
+                    stt?: {
+                        provider: string;
+                        model: string;
+                    };
+                };
+                latency: {
+                    turn_index: number;
+                    llm_node_ttft?: number;
+                    tts_node_ttfb?: number;
+                    e2e_latency?: number;
+                    transcription_delay?: number;
+                    end_of_turn_delay?: number;
+                }[];
+            };
+        };
+        emptyTimeout?: number;
+        departureTimeout?: number;
+        maxParticipants?: number;
+        creationTime?: string;
+        numParticipants?: number;
+        numPublishers?: number;
+        activeRecording?: boolean;
+    };
+    participant: {
+        sid: string;
+        identity: string;
+        state?: string;
+        name?: string;
+        kind?: 'STANDARD' | 'INGRESS' | 'EGRESS' | 'SIP' | 'AGENT';
+        joinedAt?: string | number;
+        joinedAtMs?: string | number;
+    };
+};
+export type InternalKanbanWebhookPost200 = {
+    received: boolean;
+};
+export type InternalKanbanWebhookPost400 = {
+    error: string;
+};
+export type InternalKanbanWebhookPost500 = {
+    error: string;
+};
+export type InternalAuthMeGet200 = {
+    /** M2M token subject (machine identifier) */
+    subject: string;
+    /** Unique M2M token identifier */
+    tokenId: string;
+    /** Scopes granted to the M2M token */
+    scopes?: string[];
+};
+export type InternalAuthMeGet401 = {
+    message: string;
+    code?: string;
+    details?: unknown | null;
+};
+/**
+ * Returns all configured actions for a campaign, including disabled ones.
+ * @summary List campaign actions
+ */
+export type internalActionsGetResponse200 = {
+    data: InternalActionsGet200Item[];
+    status: 200;
+};
+export type internalActionsGetResponse400 = {
+    data: InternalActionsGet400;
+    status: 400;
+};
+export type internalActionsGetResponse401 = {
+    data: InternalActionsGet401;
+    status: 401;
+};
+export type internalActionsGetResponse500 = {
+    data: InternalActionsGet500;
+    status: 500;
+};
+export type internalActionsGetResponseSuccess = (internalActionsGetResponse200) & {
+    headers: Headers;
+};
+export type internalActionsGetResponseError = (internalActionsGetResponse400 | internalActionsGetResponse401 | internalActionsGetResponse500) & {
+    headers: Headers;
+};
+export type internalActionsGetResponse = (internalActionsGetResponseSuccess | internalActionsGetResponseError);
+export declare const getInternalActionsGetUrl: (params: InternalActionsGetParams) => string;
+export declare const internalActionsGet: (params: InternalActionsGetParams, options?: RequestInit) => Promise<internalActionsGetResponse>;
+/**
+ * Registers a new action-provider mapping for a campaign. Validates the provider supports the action type and has a vendor config for the campaign. Auto-resolves configId. Returns 409 if the combination already exists.
+ * @summary Add action to campaign
+ */
+export type internalActionsPostResponse201 = {
+    data: InternalActionsPost201;
+    status: 201;
+};
+export type internalActionsPostResponse400 = {
+    data: InternalActionsPost400;
+    status: 400;
+};
+export type internalActionsPostResponse401 = {
+    data: InternalActionsPost401;
+    status: 401;
+};
+export type internalActionsPostResponse409 = {
+    data: InternalActionsPost409;
+    status: 409;
+};
+export type internalActionsPostResponse500 = {
+    data: InternalActionsPost500;
+    status: 500;
+};
+export type internalActionsPostResponseSuccess = (internalActionsPostResponse201) & {
+    headers: Headers;
+};
+export type internalActionsPostResponseError = (internalActionsPostResponse400 | internalActionsPostResponse401 | internalActionsPostResponse409 | internalActionsPostResponse500) & {
+    headers: Headers;
+};
+export type internalActionsPostResponse = (internalActionsPostResponseSuccess | internalActionsPostResponseError);
+export declare const getInternalActionsPostUrl: (params: InternalActionsPostParams) => string;
+export declare const internalActionsPost: (internalActionsPostBody: InternalActionsPostBody, params: InternalActionsPostParams, options?: RequestInit) => Promise<internalActionsPostResponse>;
+/**
+ * Deletes a campaign action by ID. Returns 404 if not found.
+ * @summary Remove action from campaign
+ */
+export type internalActionsDeleteResponse204 = {
+    data: unknown;
+    status: 204;
+};
+export type internalActionsDeleteResponse400 = {
+    data: InternalActionsDelete400;
+    status: 400;
+};
+export type internalActionsDeleteResponse401 = {
+    data: InternalActionsDelete401;
+    status: 401;
+};
+export type internalActionsDeleteResponse404 = {
+    data: InternalActionsDelete404;
+    status: 404;
+};
+export type internalActionsDeleteResponse500 = {
+    data: InternalActionsDelete500;
+    status: 500;
+};
+export type internalActionsDeleteResponseSuccess = (internalActionsDeleteResponse204) & {
+    headers: Headers;
+};
+export type internalActionsDeleteResponseError = (internalActionsDeleteResponse400 | internalActionsDeleteResponse401 | internalActionsDeleteResponse404 | internalActionsDeleteResponse500) & {
+    headers: Headers;
+};
+export type internalActionsDeleteResponse = (internalActionsDeleteResponseSuccess | internalActionsDeleteResponseError);
+export declare const getInternalActionsDeleteUrl: (params: InternalActionsDeleteParams) => string;
+export declare const internalActionsDelete: (internalActionsDeleteBody: InternalActionsDeleteBody, params: InternalActionsDeleteParams, options?: RequestInit) => Promise<internalActionsDeleteResponse>;
+/**
+ * Updates a call record with the provided data. If provider is specified, fetches external contact data first.
+ * @summary Update a call record
+ */
+export type internalCallsIdPutResponse200 = {
+    data: unknown | null;
+    status: 200;
+};
+export type internalCallsIdPutResponse400 = {
+    data: InternalCallsIdPut400;
+    status: 400;
+};
+export type internalCallsIdPutResponse401 = {
+    data: InternalCallsIdPut401;
+    status: 401;
+};
+export type internalCallsIdPutResponse404 = {
+    data: InternalCallsIdPut404;
+    status: 404;
+};
+export type internalCallsIdPutResponse500 = {
+    data: InternalCallsIdPut500;
+    status: 500;
+};
+export type internalCallsIdPutResponseSuccess = (internalCallsIdPutResponse200) & {
+    headers: Headers;
+};
+export type internalCallsIdPutResponseError = (internalCallsIdPutResponse400 | internalCallsIdPutResponse401 | internalCallsIdPutResponse404 | internalCallsIdPutResponse500) & {
+    headers: Headers;
+};
+export type internalCallsIdPutResponse = (internalCallsIdPutResponseSuccess | internalCallsIdPutResponseError);
+export declare const getInternalCallsIdPutUrl: (id: string) => string;
+export declare const internalCallsIdPut: (id: string, unknownNull: unknown | null, options?: RequestInit) => Promise<internalCallsIdPutResponse>;
+/**
+ * Returns all active integration vendor configs for a campaign in the current environment.
+ * @summary List vendor configs for a campaign
+ */
+export type internalIntegrationsConfigsGetResponse200 = {
+    data: InternalIntegrationsConfigsGet200Item[];
+    status: 200;
+};
+export type internalIntegrationsConfigsGetResponse400 = {
+    data: InternalIntegrationsConfigsGet400;
+    status: 400;
+};
+export type internalIntegrationsConfigsGetResponse401 = {
+    data: InternalIntegrationsConfigsGet401;
+    status: 401;
+};
+export type internalIntegrationsConfigsGetResponse500 = {
+    data: InternalIntegrationsConfigsGet500;
+    status: 500;
+};
+export type internalIntegrationsConfigsGetResponseSuccess = (internalIntegrationsConfigsGetResponse200) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsGetResponseError = (internalIntegrationsConfigsGetResponse400 | internalIntegrationsConfigsGetResponse401 | internalIntegrationsConfigsGetResponse500) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsGetResponse = (internalIntegrationsConfigsGetResponseSuccess | internalIntegrationsConfigsGetResponseError);
+export declare const getInternalIntegrationsConfigsGetUrl: (params: InternalIntegrationsConfigsGetParams) => string;
+export declare const internalIntegrationsConfigsGet: (params: InternalIntegrationsConfigsGetParams, options?: RequestInit) => Promise<internalIntegrationsConfigsGetResponse>;
+/**
+ * Creates a new integration vendor config. The config object is encrypted before storage. Requires valid M2M Bearer token in Authorization header.
+ * @summary Create integration config
+ */
+export type internalIntegrationsConfigsPostResponse201 = {
+    data: InternalIntegrationsConfigsPost201;
+    status: 201;
+};
+export type internalIntegrationsConfigsPostResponse400 = {
+    data: InternalIntegrationsConfigsPost400;
+    status: 400;
+};
+export type internalIntegrationsConfigsPostResponse401 = {
+    data: InternalIntegrationsConfigsPost401;
+    status: 401;
+};
+export type internalIntegrationsConfigsPostResponse409 = {
+    data: InternalIntegrationsConfigsPost409;
+    status: 409;
+};
+export type internalIntegrationsConfigsPostResponse500 = {
+    data: InternalIntegrationsConfigsPost500;
+    status: 500;
+};
+export type internalIntegrationsConfigsPostResponseSuccess = (internalIntegrationsConfigsPostResponse201) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsPostResponseError = (internalIntegrationsConfigsPostResponse400 | internalIntegrationsConfigsPostResponse401 | internalIntegrationsConfigsPostResponse409 | internalIntegrationsConfigsPostResponse500) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsPostResponse = (internalIntegrationsConfigsPostResponseSuccess | internalIntegrationsConfigsPostResponseError);
+export declare const getInternalIntegrationsConfigsPostUrl: (params: InternalIntegrationsConfigsPostParams) => string;
+export declare const internalIntegrationsConfigsPost: (internalIntegrationsConfigsPostBody: InternalIntegrationsConfigsPostBody, params: InternalIntegrationsConfigsPostParams, options?: RequestInit) => Promise<internalIntegrationsConfigsPostResponse>;
+/**
+ * Updates an existing integration config by campaignId and provider. Supports partial updates for name, config, and isActive. Config is re-encrypted on update. Automatically invalidates Redis cache.
+ * @summary Update integration config
+ */
+export type internalIntegrationsConfigsPutResponse200 = {
+    data: InternalIntegrationsConfigsPut200;
+    status: 200;
+};
+export type internalIntegrationsConfigsPutResponse400 = {
+    data: InternalIntegrationsConfigsPut400;
+    status: 400;
+};
+export type internalIntegrationsConfigsPutResponse401 = {
+    data: InternalIntegrationsConfigsPut401;
+    status: 401;
+};
+export type internalIntegrationsConfigsPutResponse404 = {
+    data: InternalIntegrationsConfigsPut404;
+    status: 404;
+};
+export type internalIntegrationsConfigsPutResponse500 = {
+    data: InternalIntegrationsConfigsPut500;
+    status: 500;
+};
+export type internalIntegrationsConfigsPutResponseSuccess = (internalIntegrationsConfigsPutResponse200) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsPutResponseError = (internalIntegrationsConfigsPutResponse400 | internalIntegrationsConfigsPutResponse401 | internalIntegrationsConfigsPutResponse404 | internalIntegrationsConfigsPutResponse500) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsPutResponse = (internalIntegrationsConfigsPutResponseSuccess | internalIntegrationsConfigsPutResponseError);
+export declare const getInternalIntegrationsConfigsPutUrl: (params: InternalIntegrationsConfigsPutParams) => string;
+export declare const internalIntegrationsConfigsPut: (internalIntegrationsConfigsPutBody: InternalIntegrationsConfigsPutBody, params: InternalIntegrationsConfigsPutParams, options?: RequestInit) => Promise<internalIntegrationsConfigsPutResponse>;
+/**
+ * Retrieves decrypted integration config for a campaign and provider. Requires valid M2M Bearer token in Authorization header.
+ * @summary Get integration config
+ */
+export type internalIntegrationsConfigsProviderGetResponse200 = {
+    data: InternalIntegrationsConfigsProviderGet200;
+    status: 200;
+};
+export type internalIntegrationsConfigsProviderGetResponse400 = {
+    data: InternalIntegrationsConfigsProviderGet400;
+    status: 400;
+};
+export type internalIntegrationsConfigsProviderGetResponse401 = {
+    data: InternalIntegrationsConfigsProviderGet401;
+    status: 401;
+};
+export type internalIntegrationsConfigsProviderGetResponse404 = {
+    data: InternalIntegrationsConfigsProviderGet404;
+    status: 404;
+};
+export type internalIntegrationsConfigsProviderGetResponse500 = {
+    data: InternalIntegrationsConfigsProviderGet500;
+    status: 500;
+};
+export type internalIntegrationsConfigsProviderGetResponseSuccess = (internalIntegrationsConfigsProviderGetResponse200) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsProviderGetResponseError = (internalIntegrationsConfigsProviderGetResponse400 | internalIntegrationsConfigsProviderGetResponse401 | internalIntegrationsConfigsProviderGetResponse404 | internalIntegrationsConfigsProviderGetResponse500) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsProviderGetResponse = (internalIntegrationsConfigsProviderGetResponseSuccess | internalIntegrationsConfigsProviderGetResponseError);
+export declare const getInternalIntegrationsConfigsProviderGetUrl: (provider: string, params: InternalIntegrationsConfigsProviderGetParams) => string;
+export declare const internalIntegrationsConfigsProviderGet: (provider: string, params: InternalIntegrationsConfigsProviderGetParams, options?: RequestInit) => Promise<internalIntegrationsConfigsProviderGetResponse>;
+/**
+ * Clears the Redis cache for a specific campaign/provider config. Requires valid M2M Bearer token.
+ * @summary Invalidate config cache
+ */
+export type internalIntegrationsConfigsCacheDeleteResponse200 = {
+    data: InternalIntegrationsConfigsCacheDelete200;
+    status: 200;
+};
+export type internalIntegrationsConfigsCacheDeleteResponse400 = {
+    data: InternalIntegrationsConfigsCacheDelete400;
+    status: 400;
+};
+export type internalIntegrationsConfigsCacheDeleteResponse401 = {
+    data: InternalIntegrationsConfigsCacheDelete401;
+    status: 401;
+};
+export type internalIntegrationsConfigsCacheDeleteResponse500 = {
+    data: InternalIntegrationsConfigsCacheDelete500;
+    status: 500;
+};
+export type internalIntegrationsConfigsCacheDeleteResponseSuccess = (internalIntegrationsConfigsCacheDeleteResponse200) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsCacheDeleteResponseError = (internalIntegrationsConfigsCacheDeleteResponse400 | internalIntegrationsConfigsCacheDeleteResponse401 | internalIntegrationsConfigsCacheDeleteResponse500) & {
+    headers: Headers;
+};
+export type internalIntegrationsConfigsCacheDeleteResponse = (internalIntegrationsConfigsCacheDeleteResponseSuccess | internalIntegrationsConfigsCacheDeleteResponseError);
+export declare const getInternalIntegrationsConfigsCacheDeleteUrl: (params: InternalIntegrationsConfigsCacheDeleteParams) => string;
+export declare const internalIntegrationsConfigsCacheDelete: (params: InternalIntegrationsConfigsCacheDeleteParams, options?: RequestInit) => Promise<internalIntegrationsConfigsCacheDeleteResponse>;
+/**
+ * Performs active health checks on critical system dependencies including memory utilization and disk space. Returns detailed metrics for monitoring dashboards, alerting systems, and operational troubleshooting. Intended for internal use only.
+ * @summary Comprehensive system health and diagnostics
+ */
+export type internalHealthSystemGetResponse200 = {
+    data: InternalHealthSystemGet200;
+    status: 200;
+};
+export type internalHealthSystemGetResponseSuccess = (internalHealthSystemGetResponse200) & {
+    headers: Headers;
+};
+export type internalHealthSystemGetResponse = (internalHealthSystemGetResponseSuccess);
+export declare const getInternalHealthSystemGetUrl: () => string;
+export declare const internalHealthSystemGet: (options?: RequestInit) => Promise<internalHealthSystemGetResponse>;
+/**
+ * Receives assistant-request webhooks from VAPI for inbound calls. Returns the assistant configuration to use for the call based on the phone number configuration, campaign, and agent settings.
+ * @summary Handle VAPI inbound call webhook
+ */
+export type internalInboundVapiPostResponse200 = {
+    data: InternalInboundVapiPost200;
+    status: 200;
+};
+export type internalInboundVapiPostResponse400 = {
+    data: InternalInboundVapiPost400;
+    status: 400;
+};
+export type internalInboundVapiPostResponse401 = {
+    data: InternalInboundVapiPost401;
+    status: 401;
+};
+export type internalInboundVapiPostResponse500 = {
+    data: InternalInboundVapiPost500;
+    status: 500;
+};
+export type internalInboundVapiPostResponseSuccess = (internalInboundVapiPostResponse200) & {
+    headers: Headers;
+};
+export type internalInboundVapiPostResponseError = (internalInboundVapiPostResponse400 | internalInboundVapiPostResponse401 | internalInboundVapiPostResponse500) & {
+    headers: Headers;
+};
+export type internalInboundVapiPostResponse = (internalInboundVapiPostResponseSuccess | internalInboundVapiPostResponseError);
+export declare const getInternalInboundVapiPostUrl: (params?: InternalInboundVapiPostParams) => string;
+export declare const internalInboundVapiPost: (internalInboundVapiPostBody: InternalInboundVapiPostBody, params?: InternalInboundVapiPostParams, options?: RequestInit) => Promise<internalInboundVapiPostResponse>;
+/**
+ * Returns all configured agent provider limits with their current usage from Redis. Shows how many concurrent calls are active for each provider and how many slots are available. Returns 503 if Redis or database is unavailable, 500 for unexpected errors.
+ * @summary List all agent provider limits with current usage
+ */
+export type internalLimitsAgentProviderGetResponse200 = {
+    data: InternalLimitsAgentProviderGet200Item[];
+    status: 200;
+};
+export type internalLimitsAgentProviderGetResponse401 = {
+    data: InternalLimitsAgentProviderGet401;
+    status: 401;
+};
+export type internalLimitsAgentProviderGetResponse500 = {
+    data: InternalLimitsAgentProviderGet500;
+    status: 500;
+};
+export type internalLimitsAgentProviderGetResponse503 = {
+    data: InternalLimitsAgentProviderGet503;
+    status: 503;
+};
+export type internalLimitsAgentProviderGetResponseSuccess = (internalLimitsAgentProviderGetResponse200) & {
+    headers: Headers;
+};
+export type internalLimitsAgentProviderGetResponseError = (internalLimitsAgentProviderGetResponse401 | internalLimitsAgentProviderGetResponse500 | internalLimitsAgentProviderGetResponse503) & {
+    headers: Headers;
+};
+export type internalLimitsAgentProviderGetResponse = (internalLimitsAgentProviderGetResponseSuccess | internalLimitsAgentProviderGetResponseError);
+export declare const getInternalLimitsAgentProviderGetUrl: () => string;
+export declare const internalLimitsAgentProviderGet: (options?: RequestInit) => Promise<internalLimitsAgentProviderGetResponse>;
+/**
+ * Creates a new agent provider limit or updates an existing one if the key already exists. Returns 201 Created for new resources, 200 OK for updates. The effective limit is automatically calculated based on the limit and safety margin percentage.
+ * @summary Create or update agent provider limit
+ */
+export type internalLimitsAgentProviderPostResponse200 = {
+    data: InternalLimitsAgentProviderPost200;
+    status: 200;
+};
+export type internalLimitsAgentProviderPostResponse201 = {
+    data: InternalLimitsAgentProviderPost201;
+    status: 201;
+};
+export type internalLimitsAgentProviderPostResponse400 = {
+    data: InternalLimitsAgentProviderPost400;
+    status: 400;
+};
+export type internalLimitsAgentProviderPostResponse401 = {
+    data: InternalLimitsAgentProviderPost401;
+    status: 401;
+};
+export type internalLimitsAgentProviderPostResponse503 = {
+    data: InternalLimitsAgentProviderPost503;
+    status: 503;
+};
+export type internalLimitsAgentProviderPostResponseSuccess = (internalLimitsAgentProviderPostResponse200 | internalLimitsAgentProviderPostResponse201) & {
+    headers: Headers;
+};
+export type internalLimitsAgentProviderPostResponseError = (internalLimitsAgentProviderPostResponse400 | internalLimitsAgentProviderPostResponse401 | internalLimitsAgentProviderPostResponse503) & {
+    headers: Headers;
+};
+export type internalLimitsAgentProviderPostResponse = (internalLimitsAgentProviderPostResponseSuccess | internalLimitsAgentProviderPostResponseError);
+export declare const getInternalLimitsAgentProviderPostUrl: () => string;
+export declare const internalLimitsAgentProviderPost: (internalLimitsAgentProviderPostBody: InternalLimitsAgentProviderPostBody, options?: RequestInit) => Promise<internalLimitsAgentProviderPostResponse>;
+/**
+ * Returns TwiML for Twilio Pay. Called by Twilio when redirected from VAPI payment flow. Response Content-Type is text/xml.
+ * @summary Generate payment TwiML
+ */
+export type internalPaymentsTwimlGetResponse200 = {
+    data: void;
+    status: 200;
+};
+export type internalPaymentsTwimlGetResponse400 = {
+    data: InternalPaymentsTwimlGet400;
+    status: 400;
+};
+export type internalPaymentsTwimlGetResponseSuccess = (internalPaymentsTwimlGetResponse200) & {
+    headers: Headers;
+};
+export type internalPaymentsTwimlGetResponseError = (internalPaymentsTwimlGetResponse400) & {
+    headers: Headers;
+};
+export type internalPaymentsTwimlGetResponse = (internalPaymentsTwimlGetResponseSuccess | internalPaymentsTwimlGetResponseError);
+export declare const getInternalPaymentsTwimlGetUrl: (params: InternalPaymentsTwimlGetParams) => string;
+export declare const internalPaymentsTwimlGet: (params: InternalPaymentsTwimlGetParams, options?: RequestInit) => Promise<internalPaymentsTwimlGetResponse>;
+/**
+ * Generates TwiML for IVR payment capture and updates the active Twilio call to begin the payment flow.
+ * @summary Initiate payment transfer on active call
+ */
+export type internalPaymentsTransferPostResponse200 = {
+    data: InternalPaymentsTransferPost200;
+    status: 200;
+};
+export type internalPaymentsTransferPostResponse400 = {
+    data: InternalPaymentsTransferPost400;
+    status: 400;
+};
+export type internalPaymentsTransferPostResponse500 = {
+    data: InternalPaymentsTransferPost500;
+    status: 500;
+};
+export type internalPaymentsTransferPostResponseSuccess = (internalPaymentsTransferPostResponse200) & {
+    headers: Headers;
+};
+export type internalPaymentsTransferPostResponseError = (internalPaymentsTransferPostResponse400 | internalPaymentsTransferPostResponse500) & {
+    headers: Headers;
+};
+export type internalPaymentsTransferPostResponse = (internalPaymentsTransferPostResponseSuccess | internalPaymentsTransferPostResponseError);
+export declare const getInternalPaymentsTransferPostUrl: () => string;
+export declare const internalPaymentsTransferPost: (internalPaymentsTransferPostBody: InternalPaymentsTransferPostBody, options?: RequestInit) => Promise<internalPaymentsTransferPostResponse>;
+/**
+ * Receives callback from Twilio Pay after payment attempt. Returns TwiML response with voice prompts based on payment result.
+ * @summary Process Twilio Pay callback
+ */
+export type internalPaymentsCallbackPostResponse200 = {
+    data: string;
+    status: 200;
+};
+export type internalPaymentsCallbackPostResponseSuccess = (internalPaymentsCallbackPostResponse200) & {
+    headers: Headers;
+};
+export type internalPaymentsCallbackPostResponse = (internalPaymentsCallbackPostResponseSuccess);
+export declare const getInternalPaymentsCallbackPostUrl: (params: InternalPaymentsCallbackPostParams) => string;
+export declare const internalPaymentsCallbackPost: (internalPaymentsCallbackPostBody: InternalPaymentsCallbackPostBody, params: InternalPaymentsCallbackPostParams, options?: RequestInit) => Promise<internalPaymentsCallbackPostResponse>;
+/**
+ * Adds a new call job to the queue for processing. The call will be initiated asynchronously by the worker. Returns immediately with job ID for tracking.
+ * @summary Queue a new outbound call job
+ */
+export type internalQueuesCallJobPostResponse201 = {
+    data: InternalQueuesCallJobPost201;
+    status: 201;
+};
+export type internalQueuesCallJobPostResponse400 = {
+    data: InternalQueuesCallJobPost400;
+    status: 400;
+};
+export type internalQueuesCallJobPostResponse500 = {
+    data: InternalQueuesCallJobPost500;
+    status: 500;
+};
+export type internalQueuesCallJobPostResponseSuccess = (internalQueuesCallJobPostResponse201) & {
+    headers: Headers;
+};
+export type internalQueuesCallJobPostResponseError = (internalQueuesCallJobPostResponse400 | internalQueuesCallJobPostResponse500) & {
+    headers: Headers;
+};
+export type internalQueuesCallJobPostResponse = (internalQueuesCallJobPostResponseSuccess | internalQueuesCallJobPostResponseError);
+export declare const getInternalQueuesCallJobPostUrl: () => string;
+export declare const internalQueuesCallJobPost: (internalQueuesCallJobPostBody: InternalQueuesCallJobPostBody, options?: RequestInit) => Promise<internalQueuesCallJobPostResponse>;
+/**
+ * Unified webhook for Jambonz calling and call status events. Handles both inbound and outbound calls (differentiated by direction field). When callStatus is 'trying', performs header normalization and returns dial verbs. For other statuses (in-progress, completed, failed), logs the event and returns 200 OK.
+ * @summary Handle Jambonz call webhook
+ */
+export type internalSipCallsJambonzPostResponse200 = {
+    data: InternalSipCallsJambonzPost200;
+    status: 200;
+};
+export type internalSipCallsJambonzPostResponse400 = {
+    data: InternalSipCallsJambonzPost400;
+    status: 400;
+};
+export type internalSipCallsJambonzPostResponse401 = {
+    data: InternalSipCallsJambonzPost401;
+    status: 401;
+};
+export type internalSipCallsJambonzPostResponse404 = {
+    data: InternalSipCallsJambonzPost404;
+    status: 404;
+};
+export type internalSipCallsJambonzPostResponse500 = {
+    data: InternalSipCallsJambonzPost500;
+    status: 500;
+};
+export type internalSipCallsJambonzPostResponseSuccess = (internalSipCallsJambonzPostResponse200) & {
+    headers: Headers;
+};
+export type internalSipCallsJambonzPostResponseError = (internalSipCallsJambonzPostResponse400 | internalSipCallsJambonzPostResponse401 | internalSipCallsJambonzPostResponse404 | internalSipCallsJambonzPostResponse500) & {
+    headers: Headers;
+};
+export type internalSipCallsJambonzPostResponse = (internalSipCallsJambonzPostResponseSuccess | internalSipCallsJambonzPostResponseError);
+export declare const getInternalSipCallsJambonzPostUrl: () => string;
+export declare const internalSipCallsJambonzPost: (internalSipCallsJambonzPostBody: InternalSipCallsJambonzPostBody, options?: RequestInit) => Promise<internalSipCallsJambonzPostResponse>;
+/**
+ * Verifies active SIP routes exist in the database for call routing.
+ * @summary SIP webhook health check
+ */
+export type internalSipCallsJambonzHealthGetResponse200 = {
+    data: InternalSipCallsJambonzHealthGet200;
+    status: 200;
+};
+export type internalSipCallsJambonzHealthGetResponse503 = {
+    data: InternalSipCallsJambonzHealthGet503;
+    status: 503;
+};
+export type internalSipCallsJambonzHealthGetResponseSuccess = (internalSipCallsJambonzHealthGetResponse200) & {
+    headers: Headers;
+};
+export type internalSipCallsJambonzHealthGetResponseError = (internalSipCallsJambonzHealthGetResponse503) & {
+    headers: Headers;
+};
+export type internalSipCallsJambonzHealthGetResponse = (internalSipCallsJambonzHealthGetResponseSuccess | internalSipCallsJambonzHealthGetResponseError);
+export declare const getInternalSipCallsJambonzHealthGetUrl: () => string;
+export declare const internalSipCallsJambonzHealthGet: (options?: RequestInit) => Promise<internalSipCallsJambonzHealthGetResponse>;
+/**
+ * Queues a background job to process a CSV file containing targets. The job will fetch the file from S3, parse each row, and upsert targets into the database. Returns a job ID.
+ * @summary Queue a target upload job
+ */
+export type internalTargetsUploadPostResponse202 = {
+    data: InternalTargetsUploadPost202;
+    status: 202;
+};
+export type internalTargetsUploadPostResponse400 = {
+    data: InternalTargetsUploadPost400;
+    status: 400;
+};
+export type internalTargetsUploadPostResponse404 = {
+    data: InternalTargetsUploadPost404;
+    status: 404;
+};
+export type internalTargetsUploadPostResponse500 = {
+    data: InternalTargetsUploadPost500;
+    status: 500;
+};
+export type internalTargetsUploadPostResponseSuccess = (internalTargetsUploadPostResponse202) & {
+    headers: Headers;
+};
+export type internalTargetsUploadPostResponseError = (internalTargetsUploadPostResponse400 | internalTargetsUploadPostResponse404 | internalTargetsUploadPostResponse500) & {
+    headers: Headers;
+};
+export type internalTargetsUploadPostResponse = (internalTargetsUploadPostResponseSuccess | internalTargetsUploadPostResponseError);
+export declare const getInternalTargetsUploadPostUrl: () => string;
+export declare const internalTargetsUploadPost: (internalTargetsUploadPostBody: InternalTargetsUploadPostBody, options?: RequestInit) => Promise<internalTargetsUploadPostResponse>;
+/**
+ * Looks up a target by phone number or external ID (account number). Defaults to phone lookup for backward compatibility.
+ * @summary Get target by identifier
+ */
+export type internalTargetsIdentifierGetResponse200 = {
+    data: InternalTargetsIdentifierGet200Item[];
+    status: 200;
+};
+export type internalTargetsIdentifierGetResponse400 = {
+    data: InternalTargetsIdentifierGet400;
+    status: 400;
+};
+export type internalTargetsIdentifierGetResponse404 = {
+    data: InternalTargetsIdentifierGet404;
+    status: 404;
+};
+export type internalTargetsIdentifierGetResponse500 = {
+    data: InternalTargetsIdentifierGet500;
+    status: 500;
+};
+export type internalTargetsIdentifierGetResponseSuccess = (internalTargetsIdentifierGetResponse200) & {
+    headers: Headers;
+};
+export type internalTargetsIdentifierGetResponseError = (internalTargetsIdentifierGetResponse400 | internalTargetsIdentifierGetResponse404 | internalTargetsIdentifierGetResponse500) & {
+    headers: Headers;
+};
+export type internalTargetsIdentifierGetResponse = (internalTargetsIdentifierGetResponseSuccess | internalTargetsIdentifierGetResponseError);
+export declare const getInternalTargetsIdentifierGetUrl: (identifier: string, params: InternalTargetsIdentifierGetParams) => string;
+export declare const internalTargetsIdentifierGet: (identifier: string, params: InternalTargetsIdentifierGetParams, options?: RequestInit) => Promise<internalTargetsIdentifierGetResponse>;
+/**
+ * Endpoint for receiving webhook events from Vapi. Handles status-update and end-of-call-report events. Other event types are acknowledged but not processed. Protected by HMAC-SHA256 signature verification.
+ * @summary Receive Vapi webhook events
+ */
+export type internalVapiWebhookPostResponse200 = {
+    data: InternalVapiWebhookPost200;
+    status: 200;
+};
+export type internalVapiWebhookPostResponse400 = {
+    data: InternalVapiWebhookPost400;
+    status: 400;
+};
+export type internalVapiWebhookPostResponse401 = {
+    data: InternalVapiWebhookPost401;
+    status: 401;
+};
+export type internalVapiWebhookPostResponse500 = {
+    data: InternalVapiWebhookPost500;
+    status: 500;
+};
+export type internalVapiWebhookPostResponseSuccess = (internalVapiWebhookPostResponse200) & {
+    headers: Headers;
+};
+export type internalVapiWebhookPostResponseError = (internalVapiWebhookPostResponse400 | internalVapiWebhookPostResponse401 | internalVapiWebhookPostResponse500) & {
+    headers: Headers;
+};
+export type internalVapiWebhookPostResponse = (internalVapiWebhookPostResponseSuccess | internalVapiWebhookPostResponseError);
+export declare const getInternalVapiWebhookPostUrl: () => string;
+export declare const internalVapiWebhookPost: (internalVapiWebhookPostBody: InternalVapiWebhookPostBody, options?: RequestInit) => Promise<internalVapiWebhookPostResponse>;
+/**
+ * Endpoint for receiving webhook events from the Kanban service. Handles room lifecycle events, call status updates, and transcriptions.
+ * @summary Receive Kanban webhook events
+ */
+export type internalKanbanWebhookPostResponse200 = {
+    data: InternalKanbanWebhookPost200;
+    status: 200;
+};
+export type internalKanbanWebhookPostResponse400 = {
+    data: InternalKanbanWebhookPost400;
+    status: 400;
+};
+export type internalKanbanWebhookPostResponse500 = {
+    data: InternalKanbanWebhookPost500;
+    status: 500;
+};
+export type internalKanbanWebhookPostResponseSuccess = (internalKanbanWebhookPostResponse200) & {
+    headers: Headers;
+};
+export type internalKanbanWebhookPostResponseError = (internalKanbanWebhookPostResponse400 | internalKanbanWebhookPostResponse500) & {
+    headers: Headers;
+};
+export type internalKanbanWebhookPostResponse = (internalKanbanWebhookPostResponseSuccess | internalKanbanWebhookPostResponseError);
+export declare const getInternalKanbanWebhookPostUrl: () => string;
+export declare const internalKanbanWebhookPost: (internalKanbanWebhookPostBody: InternalKanbanWebhookPostBody, options?: RequestInit) => Promise<internalKanbanWebhookPostResponse>;
+/**
+ * Returns the authenticated M2M token information including subject, scopes, and token metadata. Requires valid M2M Bearer token in Authorization header.
+ * @summary Get authenticated M2M token information
+ */
+export type internalAuthMeGetResponse200 = {
+    data: InternalAuthMeGet200;
+    status: 200;
+};
+export type internalAuthMeGetResponse401 = {
+    data: InternalAuthMeGet401;
+    status: 401;
+};
+export type internalAuthMeGetResponseSuccess = (internalAuthMeGetResponse200) & {
+    headers: Headers;
+};
+export type internalAuthMeGetResponseError = (internalAuthMeGetResponse401) & {
+    headers: Headers;
+};
+export type internalAuthMeGetResponse = (internalAuthMeGetResponseSuccess | internalAuthMeGetResponseError);
+export declare const getInternalAuthMeGetUrl: () => string;
+export declare const internalAuthMeGet: (options?: RequestInit) => Promise<internalAuthMeGetResponse>;