import { a as ChatInteraction, h as InteractionAnswerValue, l as InteractionRequestWire, j as InteractionCancelData, k as InteractionPersistedPart } from '../contract-B3h7peV3.js';
import { ChatPlan } from '../plans/index.js';
import { DurableInteractionRouteArgs, DurableInteractionRoutePersistence } from '../interactions/index.js';
import '@tangle-network/agent-interface';

/** Define error codes representing possible Durable Chat failure scenarios */
type DurableChatErrorCode = 'DURABLE_CHAT_BAD_REQUEST' | 'DURABLE_CHAT_UNAUTHORIZED' | 'DURABLE_CHAT_CONFLICT' | 'DURABLE_CHAT_UNAVAILABLE' | 'DURABLE_CHAT_GONE' | 'DURABLE_CHAT_NOT_FOUND';
/** Typed, fail-loud errors for adapters and route seams. */
declare class DurableChatError extends Error {
    readonly code: DurableChatErrorCode;
    readonly status: number;
    readonly details?: unknown;
    constructor(code: DurableChatErrorCode, message: string, status: number, details?: unknown);
}
/** Represent conflict errors occurring in durable chat state management */
declare class DurableChatConflictError extends DurableChatError {
    constructor(message?: string, details?: unknown);
}
/** Represent unavailable durable chat authority errors with status code 503 */
declare class DurableChatUnavailableError extends DurableChatError {
    constructor(message?: string, details?: unknown);
}
/** Represent durable chat errors indicating the chat plan is no longer available */
declare class DurableChatGoneError extends DurableChatError {
    constructor(message?: string, details?: unknown);
}

/** An authorization-derived tenant/thread scope.  Consumers should only
 * create this value after authenticating the request; the route never accepts
 * an identity or scope from the request body. */
type DurableChatScope = string & {
    readonly __durableChatScope: unique symbol;
};
/** Create a durable chat scope from a non-empty string value */
declare function createDurableChatScope(value: string): DurableChatScope;
/** Resolve a valid durable chat scope key from the given scope input */
declare function durableChatScopeKey(scope: DurableChatScope): string;
/** Represent durable plan outcomes as either approved or rejected */
type DurablePlanDecision = 'approved' | 'rejected';
/** Resolve durable plan authority decisions including approval, rejection, or predefined durable decisions */
type DurablePlanAuthorityDecision = DurablePlanDecision | 'approve' | 'reject';
/** Projection retained by a durable store.  It is intentionally compatible
 * with the browser `/plans` projection and adds no product-specific fields. */
type DurablePlanProjection = ChatPlan & {
    metadata?: Record<string, unknown>;
    decidedBy?: string;
};
/** Represent a unique identifier key for durable plan commands */
type DurablePlanCommandKey = string;
/** Define possible states for a durable plan command in its lifecycle */
type DurablePlanCommandState = 'claimed' | 'authority_committed' | 'finalized' | 'conflicted';
/** Define the structure for recording durable plan commands with associated metadata and state information */
interface DurablePlanCommandRecord {
    scope: DurableChatScope;
    planId: string;
    revision: number;
    decision: DurablePlanDecision;
    commandKey: DurablePlanCommandKey;
    authorityIdempotencyKey: string;
    state: DurablePlanCommandState;
    claimedAt: string;
    authorityResult?: DurablePlanAuthorityResult;
    receipt?: DurableFollowUpReceipt;
    conflict?: string;
}
/** Represent the current authoritative state and optional receipt of a durable plan authority */
interface DurablePlanAuthorityCurrentResult {
    /** Authoritative state. `null` means the authority has forgotten the plan. */
    plan: DurablePlanProjection | null;
    receipt?: DurableFollowUpReceipt;
}
/** Define a durable receipt capturing stable identifiers and state for follow-up decisions */
interface DurableFollowUpReceipt {
    /** Stable for a scope + plan + revision + decision. */
    receiptId: string;
    planId: string;
    revision: number;
    decision: DurablePlanDecision;
    turnId: string;
    state: string;
    /** Authority's stable idempotency key, useful when reconciling. */
    authorityIdempotencyKey: string;
}
/** Describe the outcome of an authority's durable plan decision including follow-up and metadata */
interface DurablePlanAuthorityResult {
    /** Authority's final plan projection. */
    plan: DurablePlanProjection;
    /** Sandbox-style follow-up result. */
    followUp: {
        turnId: string;
        state: string;
    };
    /** True when the authority served a previously committed decision. */
    idempotent?: boolean;
    /** Stable authority operation id, if the provider has one. */
    authorityId?: string;
    receipt?: DurableFollowUpReceipt;
}
/** Structural port to Sandbox (or another durable plan authority). */
interface DurablePlanAuthority {
    current(args: {
        scope: DurableChatScope;
        planId: string;
        revision?: number;
    }): Promise<DurablePlanAuthorityCurrentResult | DurablePlanProjection | null>;
    decide(args: {
        scope: DurableChatScope;
        planId: string;
        revision: number;
        decision: DurablePlanDecision;
        feedback?: string;
        idempotencyKey: string;
    }): Promise<DurablePlanAuthorityResult>;
}
/** Define the structure for recording the state and metadata of a durable plan effect */
interface DurablePlanEffectRecord {
    effectKey: string;
    scope: DurableChatScope;
    planId: string;
    revision: number;
    decision: DurablePlanDecision;
    state: 'claimed' | 'completed' | 'error';
    claimedAt: string;
    completedAt?: string;
    error?: string;
}
/** Manage durable storage and retrieval of plan projections, commands, and effects within a scoped context */
interface DurablePlanStore {
    getPlanProjection(scope: DurableChatScope, planId: string, revision?: number): Promise<DurablePlanProjection | null>;
    putPlanProjection(scope: DurableChatScope, projection: DurablePlanProjection): Promise<void>;
    listPlanProjections?(scope: DurableChatScope, planId?: string): Promise<DurablePlanProjection[]>;
    getPlanCommand(scope: DurableChatScope, commandKey: DurablePlanCommandKey): Promise<DurablePlanCommandRecord | null>;
    claimPlanCommand(scope: DurableChatScope, command: DurablePlanCommandRecord): Promise<{
        status: 'claimed';
        record: DurablePlanCommandRecord;
    } | {
        status: 'existing';
        record: DurablePlanCommandRecord;
    } | {
        status: 'conflict';
        record?: DurablePlanCommandRecord;
        reason: string;
    }>;
    recordPlanAuthorityResult(scope: DurableChatScope, commandKey: DurablePlanCommandKey, result: DurablePlanAuthorityResult, receipt: DurableFollowUpReceipt): Promise<void>;
    finalizePlanCommand(scope: DurableChatScope, commandKey: DurablePlanCommandKey): Promise<void>;
    getPlanEffect(scope: DurableChatScope, effectKey: string): Promise<DurablePlanEffectRecord | null>;
    claimPlanEffect(scope: DurableChatScope, effect: DurablePlanEffectRecord): Promise<{
        status: 'claimed';
        record: DurablePlanEffectRecord;
    } | {
        status: 'existing';
        record: DurablePlanEffectRecord;
    }>;
    completePlanEffect(scope: DurableChatScope, effectKey: string): Promise<void>;
    failPlanEffect(scope: DurableChatScope, effectKey: string, error: string): Promise<void>;
    getInteractionProjection(scope: DurableChatScope, interactionId: string): Promise<DurableInteractionProjection | null>;
    upsertInteractionProjection(scope: DurableChatScope, projection: DurableInteractionProjection): Promise<DurableInteractionProjection>;
    listInteractionProjections?(scope: DurableChatScope): Promise<DurableInteractionProjection[]>;
    getAnswerIntent(scope: DurableChatScope, intentKey: string): Promise<DurableAnswerIntentRecord | null>;
    claimAnswerIntent(scope: DurableChatScope, intent: DurableAnswerIntentRecord): Promise<{
        status: 'claimed';
        record: DurableAnswerIntentRecord;
    } | {
        status: 'existing';
        record: DurableAnswerIntentRecord;
    } | {
        status: 'conflict';
        record?: DurableAnswerIntentRecord;
        reason: string;
    }>;
    acknowledgeAnswerIntent(scope: DurableChatScope, intentKey: string, acknowledgement: DurableInteractionAcknowledgement): Promise<void>;
    /** Atomically settle the interaction projection (including semantic aliases)
     * from the acknowledged intent and mark the intent finalized. */
    finalizeAnswerIntent(scope: DurableChatScope, intentKey: string, guarantee?: DurableInteractionGuarantee): Promise<void>;
    abortAnswerIntent(scope: DurableChatScope, intentKey: string, error: string): Promise<void>;
}
/** Alias used by adapters that store all durable chat state in one port. */
type DurableChatStateStore = DurablePlanStore;
/** Represent durable storage for plan state management with persistence and reliability guarantees */
type DurablePlanStateStore = DurablePlanStore;
/** Pick essential methods to manage and record durable plan command operations */
type DurablePlanCommandJournal = Pick<DurablePlanStore, 'getPlanCommand' | 'claimPlanCommand' | 'recordPlanAuthorityResult' | 'finalizePlanCommand'>;
/** Provide durable methods to manage the lifecycle of answer intents in a plan store */
type DurableAnswerIntentJournal = Pick<DurablePlanStore, 'getAnswerIntent' | 'claimAnswerIntent' | 'acknowledgeAnswerIntent' | 'finalizeAnswerIntent' | 'abortAnswerIntent'>;
/** Define a durable chat interaction projection with idempotent event tracking and optional tombstone flag */
interface DurableInteractionProjection extends ChatInteraction {
    /** Sequence/event identity used to make ask replays idempotent. */
    eventId?: string;
    semanticKey?: string;
    /** A cancel-before-ask row is a terminal tombstone. */
    tombstone?: boolean;
    updatedAt?: string;
}
/** Define possible states for a durable answer intent lifecycle */
type DurableAnswerIntentState = 'prepared' | 'acknowledged' | 'finalized' | 'aborted';
/** Define the structure for recording durable answer intent details and their states */
interface DurableAnswerIntentRecord {
    scope: DurableChatScope;
    interactionId: string;
    attemptKey: string;
    intentKey: string;
    outcome: 'accepted' | 'declined';
    data?: Record<string, InteractionAnswerValue>;
    state: DurableAnswerIntentState;
    guarantee?: DurableInteractionGuarantee;
    acknowledgement?: DurableInteractionAcknowledgement;
    createdAt: string;
    finalizedAt?: string;
    error?: string;
}
/** Represent durable acknowledgement of an interaction with optional authority, status, and timestamp fields */
interface DurableInteractionAcknowledgement {
    acknowledged: true;
    authorityId?: string;
    status?: string;
    at?: string;
}
/** Define interaction durability levels to specify reconciliation or best-effort guarantees */
type DurableInteractionGuarantee = 'reconciled' | 'best-effort';
/** Define options for durable interaction settlement including attempt key, guarantee, and timestamp provider */
interface DurableInteractionSettlementOptions {
    /** Caller-created and stable across retries/reconnects. */
    attemptKey: string;
    guarantee?: DurableInteractionGuarantee;
    now?: () => string;
}
/** Manage durable interaction lifecycles by preparing, acknowledging, finalizing, aborting, and reconciling intents */
interface DurableInteractionSettlement {
    prepare(scope: DurableChatScope, interactionId: string, outcome: 'accepted' | 'declined', data?: Record<string, InteractionAnswerValue>): Promise<DurableAnswerIntentRecord>;
    acknowledge(scope: DurableChatScope, intentKey: string, acknowledgement?: Omit<DurableInteractionAcknowledgement, 'acknowledged'>): Promise<DurableAnswerIntentRecord>;
    finalize(scope: DurableChatScope, intentKey: string): Promise<DurableAnswerIntentRecord>;
    abort(scope: DurableChatScope, intentKey: string, error: string): Promise<DurableAnswerIntentRecord>;
    reconcile(scope: DurableChatScope, intentKey: string): Promise<DurableAnswerIntentRecord | null>;
}
/** Normalize input value to a standardized DurablePlanDecision or return null for invalid inputs */
declare function normalizePlanDecision(value: unknown): DurablePlanDecision | null;
/** Generate a unique key string for a plan command using plan ID, revision, and decision */
declare function planCommandKey(planId: string, revision: number, decision: DurablePlanDecision): string;
/** Generate a unique idempotency key for a plan authority based on scope, plan, revision, and decision */
declare function planAuthorityIdempotencyKey(scope: DurableChatScope, planId: string, revision: number, decision: DurablePlanDecision): string;
/** Generate a unique string key representing the effect of a plan decision within a given scope and revision */
declare function planEffectKey(scope: DurableChatScope, planId: string, revision: number, decision: DurablePlanDecision): string;
/** Resolve a durable follow-up receipt ensuring idempotency for a given plan decision and revision */
declare function stablePlanReceipt(scope: DurableChatScope, planId: string, revision: number, decision: DurablePlanDecision, result: Pick<DurablePlanAuthorityResult, 'followUp'>): DurableFollowUpReceipt;

/**
 * Reference adapter for tests and local development. It is intentionally
 * process-local and non-production: there is no locking across processes,
 * transaction, or crash recovery. Production adapters should implement the
 * same port with a database/Workflow primitive and CAS at every claim.
 */
declare class InMemoryDurableChatStateStore implements DurablePlanStore {
    private readonly plans;
    private readonly currentPlans;
    private readonly commands;
    private readonly effects;
    private readonly interactions;
    private readonly interactionSemantic;
    /** Duplicate event ids point at the canonical semantic interaction so all
     * duplicate asks settle through one terminal row/attempt. */
    private readonly interactionAliases;
    private readonly answerIntents;
    private scopePrefix;
    private scopedKey;
    private planKey;
    private currentKey;
    private commandKey;
    private interactionKey;
    private intentKey;
    private effectKey;
    getPlanProjection(scope: DurableChatScope, planId: string, revision?: number): Promise<DurablePlanProjection | null>;
    listPlanProjections(scope: DurableChatScope, planId?: string): Promise<DurablePlanProjection[]>;
    putPlanProjection(scope: DurableChatScope, projection: DurablePlanProjection): Promise<void>;
    getPlanCommand(scope: DurableChatScope, commandKey: DurablePlanCommandKey): Promise<DurablePlanCommandRecord | null>;
    claimPlanCommand(scope: DurableChatScope, command: DurablePlanCommandRecord): Promise<{
        status: "conflict";
        record: DurablePlanCommandRecord;
        reason: string;
    } | {
        status: "claimed";
        record: DurablePlanCommandRecord;
        reason?: undefined;
    } | {
        status: "existing";
        record: DurablePlanCommandRecord;
        reason?: undefined;
    }>;
    recordPlanAuthorityResult(scope: DurableChatScope, commandKey: string, result: DurablePlanAuthorityResult, receipt: DurablePlanCommandRecord['receipt']): Promise<void>;
    finalizePlanCommand(scope: DurableChatScope, commandKey: string): Promise<void>;
    getPlanEffect(scope: DurableChatScope, effectKey: string): Promise<DurablePlanEffectRecord | null>;
    claimPlanEffect(scope: DurableChatScope, effect: DurablePlanEffectRecord): Promise<{
        status: "existing";
        record: DurablePlanEffectRecord;
    } | {
        status: "claimed";
        record: DurablePlanEffectRecord;
    }>;
    completePlanEffect(scope: DurableChatScope, effectKey: string): Promise<void>;
    failPlanEffect(scope: DurableChatScope, effectKey: string, error: string): Promise<void>;
    getInteractionProjection(scope: DurableChatScope, interactionId: string): Promise<DurableInteractionProjection | null>;
    listInteractionProjections(scope: DurableChatScope): Promise<DurableInteractionProjection[]>;
    upsertInteractionProjection(scope: DurableChatScope, projection: DurableInteractionProjection): Promise<DurableInteractionProjection>;
    getAnswerIntent(scope: DurableChatScope, intentKey: string): Promise<DurableAnswerIntentRecord | null>;
    claimAnswerIntent(scope: DurableChatScope, intent: DurableAnswerIntentRecord): Promise<{
        status: "claimed";
        record: DurableAnswerIntentRecord;
        reason?: undefined;
    } | {
        status: "existing";
        record: DurableAnswerIntentRecord;
        reason?: undefined;
    } | {
        status: "conflict";
        record: DurableAnswerIntentRecord;
        reason: string;
    }>;
    acknowledgeAnswerIntent(scope: DurableChatScope, intentKey: string, acknowledgement: DurableAnswerIntentRecord['acknowledgement']): Promise<void>;
    finalizeAnswerIntent(scope: DurableChatScope, intentKey: string, guarantee?: DurableAnswerIntentRecord['guarantee']): Promise<void>;
    abortAnswerIntent(scope: DurableChatScope, intentKey: string, error: string): Promise<void>;
}
/** Short aliases retained for adapter authors who call this a durable chat
 * store rather than a state store. Both names refer to the same non-production
 * reference implementation. */
declare const InMemoryDurableChatStore: typeof InMemoryDurableChatStateStore;
/** Create an in-memory durable chat state store for managing chat session data efficiently */
declare function createInMemoryDurableChatStateStore(): InMemoryDurableChatStateStore;

/** Apply an ask event. Event ids and semantic signatures make replays safe;
 * a prior cancel creates a tombstone and cannot be resurrected by a late ask. */
declare function upsertDurableInteractionAsk(store: DurablePlanStore, scope: DurableChatScope, request: InteractionRequestWire, options?: {
    eventId?: string;
    semanticKey?: string;
    now?: () => string;
}): Promise<DurableInteractionProjection>;
/** Apply a cancel event. It is valid before the ask arrives and leaves a
 * terminal tombstone so a delayed ask cannot re-open the card. */
declare function recordDurableInteractionCancel(store: DurablePlanStore, scope: DurableChatScope, interactionId: string, reason?: string, options?: {
    eventId?: string;
    now?: () => string;
}): Promise<DurableInteractionProjection>;
/** Record an accepted/declined answer in the projection. The terminal
 * transition is intentionally separate from answer-intent acknowledgement so
 * callers can choose reconciled or best-effort delivery. */
declare function recordDurableInteractionAnswer(store: DurablePlanStore, scope: DurableChatScope, interactionId: string, outcome: 'accepted' | 'declined', answers?: Record<string, InteractionAnswerValue>, options?: {
    eventId?: string;
    now?: () => string;
}): Promise<DurableInteractionProjection>;
/** Define options for creating durable interaction settlement factories including store and optional reconcile authority */
interface DurableInteractionSettlementFactoryOptions extends DurableInteractionSettlementOptions {
    store: DurablePlanStore;
    /** Optional authority lookup used by `reconcile`; returning null leaves the
     * intent prepared for a later durable retry. */
    reconcileAuthority?: (args: {
        scope: DurableChatScope;
        intent: DurableAnswerIntentRecord;
    }) => Promise<DurableInteractionAcknowledgement | null>;
}
/** Additive answer settlement primitive for wiring into `/interactions`.
 * `attemptKey` belongs to the caller and is never generated from user data. */
declare function createDurableInteractionSettlement(options: DurableInteractionSettlementFactoryOptions): DurableInteractionSettlement;
/** Stable key helper exported for products implementing their own settlement
 * loop. */
declare function durableInteractionIntentKey(scope: DurableChatScope, interactionId: string, attemptKey: string): string;
/** Resolve and upsert a durable interaction ask in the store with optional event and timing parameters */
declare const applyDurableInteractionAsk: typeof upsertDurableInteractionAsk;
/** Resolve cancellation of a durable interaction with optional reason and event details */
declare const applyDurableInteractionCancel: typeof recordDurableInteractionCancel;
/** Resolve and record the outcome and answers of a durable interaction within the given store and scope */
declare const applyDurableInteractionAnswer: typeof recordDurableInteractionAnswer;

/** Define methods to manage durable interaction projections including upsert, cancel, and materialize operations */
interface DurableInteractionProjectionAdapter {
    upsertAsk(request: InteractionRequestWire): Promise<void>;
    cancel(cancel: InteractionCancelData): Promise<void>;
    materialize(): Promise<InteractionPersistedPart[]>;
}
/** Binds an authorized durable scope/store to interaction lifecycle events. */
declare function createDurableInteractionProjectionAdapter(options: {
    store: DurablePlanStore;
    scope: DurableChatScope;
    now?: () => string;
}): DurableInteractionProjectionAdapter;
/** Resolve chat events and materialize their state into durable records */
interface DurableChatEventProjection {
    observe(event: unknown): void | Promise<void>;
    materialize(): Array<Record<string, unknown>> | Promise<Array<Record<string, unknown>>>;
}
/** Event projector usable with any `ChatTurnRouteProducer` through
 * `withDurableChatProjection`. It tracks this turn's identities so older
 * thread state is not copied into every assistant message. */
declare function createDurableChatEventProjection(options: {
    store: DurablePlanStore;
    scope: DurableChatScope;
    now?: () => string;
}): DurableChatEventProjection;
/** Define a structured response containing scope, settlement, and intent for durable interactions */
interface PreparedDurableInteractionAnswer {
    scope: DurableChatScope;
    settlement: DurableInteractionSettlement;
    intent: DurableAnswerIntentRecord;
}
interface DurableInteractionRoutePersistenceBase {
    store: DurablePlanStore;
    scope(args: DurableInteractionRouteArgs): DurableChatScope | Promise<DurableChatScope>;
    now?: () => string;
}
/** Define options for durable interaction route persistence with reconciliation guarantees and authority functions */
type CreateDurableInteractionRoutePersistenceOptions = (DurableInteractionRoutePersistenceBase & {
    guarantee: 'reconciled';
    reconcileAuthority(args: {
        scope: DurableChatScope;
        intent: DurableAnswerIntentRecord;
        route: DurableInteractionRouteArgs;
    }): Promise<DurableInteractionAcknowledgement | null>;
}) | (DurableInteractionRoutePersistenceBase & {
    guarantee: 'best-effort';
    reconcileAuthority?: (args: {
        scope: DurableChatScope;
        intent: DurableAnswerIntentRecord;
        route: DurableInteractionRouteArgs;
    }) => Promise<DurableInteractionAcknowledgement | null>;
});
/** Ready-to-use bridge from `/interactions` to the durable state port. Only
 * the reconciled variant may claim crash-safe behavior; best-effort is
 * explicit in both its type and persisted intent. */
declare function createDurableInteractionRoutePersistence(options: CreateDurableInteractionRoutePersistenceOptions): DurableInteractionRoutePersistence<PreparedDurableInteractionAnswer>;

/** Resolve authorization status for durable plans using scopes, responses, or nullish values */
type DurablePlanAuthorization = DurableChatScope | {
    scope: DurableChatScope;
} | Response | null | undefined;
/** Define arguments for authorizing durable plan route requests with operation and optional plan ID */
interface DurablePlanRouteAuthorizeArgs {
    request: Request;
    operation: 'current' | 'decide';
    planId?: string;
}
/** Define options for durable plan routing including store, authority, authorization, and idempotent side effect handling */
interface DurablePlanRouteOptions {
    store: DurablePlanStore;
    authority: DurablePlanAuthority;
    /** Authentication and resource authorization. Scope must be derived by the
     * caller from trusted credentials, never from client JSON. */
    authorize: (args: DurablePlanRouteAuthorizeArgs) => Promise<DurablePlanAuthorization> | DurablePlanAuthorization;
    /** Required idempotent side effect seam. The route claims `effectKey` before
     * calling it; a product must make the callback safe to retry by that key. */
    afterDecision: (args: {
        scope: DurableChatScope;
        plan: DurablePlanProjection;
        receipt: DurableFollowUpReceipt;
        effectKey: string;
    }) => Promise<void> | void;
    now?: () => string;
    logger?: Pick<Console, 'warn' | 'error'>;
}
/** Define routes handling durable plan requests with current and decide methods */
interface DurablePlanRoutes {
    current(request: Request): Promise<Response>;
    decide(request: Request): Promise<Response>;
}
/** Build durable plan routes with authorization and effect handling based on provided options */
declare function createDurablePlanRoutes(options: DurablePlanRouteOptions): DurablePlanRoutes;

export { type CreateDurableInteractionRoutePersistenceOptions, type DurableAnswerIntentJournal, type DurableAnswerIntentRecord, type DurableAnswerIntentState, DurableChatConflictError, DurableChatError, type DurableChatErrorCode, type DurableChatEventProjection, DurableChatGoneError, type DurableChatScope, type DurableChatStateStore, DurableChatUnavailableError, type DurableFollowUpReceipt, type DurableInteractionAcknowledgement, type DurableInteractionGuarantee, type DurableInteractionProjection, type DurableInteractionProjectionAdapter, type DurableInteractionSettlement, type DurableInteractionSettlementFactoryOptions, type DurableInteractionSettlementOptions, type DurablePlanAuthority, type DurablePlanAuthorityCurrentResult, type DurablePlanAuthorityDecision, type DurablePlanAuthorityResult, type DurablePlanAuthorization, type DurablePlanCommandJournal, type DurablePlanCommandKey, type DurablePlanCommandRecord, type DurablePlanCommandState, type DurablePlanDecision, type DurablePlanEffectRecord, type DurablePlanProjection, type DurablePlanRouteAuthorizeArgs, type DurablePlanRouteOptions, type DurablePlanRoutes, type DurablePlanStateStore, type DurablePlanStore, InMemoryDurableChatStateStore, InMemoryDurableChatStore, type PreparedDurableInteractionAnswer, applyDurableInteractionAnswer, applyDurableInteractionAsk, applyDurableInteractionCancel, createDurableChatEventProjection, createDurableChatScope, createDurableInteractionProjectionAdapter, createDurableInteractionRoutePersistence, createDurableInteractionSettlement, createDurablePlanRoutes, createInMemoryDurableChatStateStore, durableChatScopeKey, durableInteractionIntentKey, normalizePlanDecision, planAuthorityIdempotencyKey, planCommandKey, planEffectKey, recordDurableInteractionAnswer, recordDurableInteractionCancel, stablePlanReceipt, upsertDurableInteractionAsk };
