@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.0

package/lib/types/formation/prepare.d.ts

@@ -0,0 +1,16 @@
+import type { Claim } from '../protocol/claim.js';
+import type { Dispute } from '../protocol/dispute.js';
+import type { AgentId, ClaimId } from '../protocol/ids.js';
+export interface PreparedFormation {
+    claims: Claim[];
+    disputes: Dispute[];
+    usedClaimIds: ClaimId[];
+    warnings: string[];
+    syncClaims?: Claim[];
+}
+export interface PreparationVisibility {
+    directClaims?: readonly Claim[];
+    editableDeprecatedIds?: ReadonlySet<ClaimId>;
+}
+export declare function recapClaimIds(texts: readonly string[]): ClaimId[];
+export declare function prepareFormation(raw: unknown, agentId: AgentId, local: readonly Claim[], seenSourceIds: readonly string[], now?: string, visibility?: PreparationVisibility): PreparedFormation;

package/lib/types/formation/schema.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const RecapOutputSchema: z.ZodObject<{
+    new_claims: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        evidence_summary: z.ZodString;
+        source_claim_ids: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    updated_claims: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        id: z.ZodString;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        evidence_summary: z.ZodString;
+        source_claim_ids: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    used_claim_ids: z.ZodArray<z.ZodString>;
+    new_disputes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        claims: z.ZodArray<z.ZodString>;
+        summary: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RecapOutput = z.infer<typeof RecapOutputSchema>;
+export declare class FormationValidationError extends Error {
+    readonly kind = "formation_validation";
+}

package/lib/types/formation/service.d.ts

@@ -0,0 +1,58 @@
+import type { AcnKnowledge } from '../knowledge/service.js';
+import type { StructuredBackend } from '../llm/structured.js';
+import { DurableWorker } from '../worker/worker.js';
+import type { Job } from '../worker/types.js';
+import { TranscriptStore } from './transcript.js';
+import type { Projection, Route } from './transcript.js';
+import type { ProjectionReplay } from './capture.js';
+export declare class AcnFormation {
+    readonly knowledge: AcnKnowledge;
+    private readonly backend;
+    private readonly render;
+    private readonly routeReady?;
+    readonly worker: DurableWorker;
+    readonly transcript: TranscriptStore;
+    private pending;
+    private readonly captures;
+    private readonly compactions;
+    private readonly archiveChecks;
+    private archiveView;
+    private readonly timers;
+    private readonly attached;
+    private readonly activeSessions;
+    private scanner;
+    private started;
+    private closing;
+    private closeTask;
+    private readonly unregister;
+    private readonly ownsWorker;
+    constructor(knowledge: AcnKnowledge, backend: StructuredBackend, render: (name: string, context: object) => string, workerOptions?: ConstructorParameters<typeof DurableWorker>[1], worker?: DurableWorker, routeReady?: ((route: Route) => Promise<boolean>) | undefined, replay?: ProjectionReplay);
+    start(): Promise<void>;
+    attach(id: string): void;
+    capture(id: string, projection: Projection, compactedUntil?: number): void;
+    private report;
+    private schedule;
+    private flushCompaction;
+    flush(id?: string): Promise<void>;
+    private rememberRoute;
+    running(id: string): void;
+    idle(id: string): void;
+    disposed(id: string): void;
+    finalize(id: string): Promise<Job>;
+    recap(id: string): Promise<Job | null>;
+    scan(now?: number): Promise<void>;
+    private scanPending;
+    private checkIdle;
+    beginArchive(id: string, upper?: number): Promise<number | null>;
+    cancelArchive(id: string): Promise<void>;
+    archived(id: string, upper: number): Promise<void>;
+    private recordArchive;
+    reconcileArchives(archived: ReadonlySet<string>): Promise<void>;
+    private reconcilePendingArchives;
+    private finishArchive;
+    private enqueueNew;
+    private enqueue;
+    private run;
+    close(): Promise<void>;
+    private finishClose;
+}

package/lib/types/formation/transcript.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import type { StoreContext } from '../store/context.js';
+import { SessionStateStore } from '../store/session-state.js';
+export declare const RouteSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+}, z.core.$strict>;
+export type Route = z.infer<typeof RouteSchema>;
+export declare const FormationStateSchema: z.ZodObject<{
+    lastSeenSeq: z.ZodDefault<z.ZodNumber>;
+    recappedThroughSeq: z.ZodDefault<z.ZodNumber>;
+    finalizedThroughSeq: z.ZodDefault<z.ZodNumber>;
+    lastRoute: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    seenSourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    privateToolCalls: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    activityAt: z.ZodDefault<z.ZodNumber>;
+    activitySeq: z.ZodDefault<z.ZodNumber>;
+    humanTurn: z.ZodDefault<z.ZodBoolean>;
+    completedTurns: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    autoPaused: z.ZodDefault<z.ZodBoolean>;
+    archivedThroughSeq: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    archiveIntent: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    archivePending: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FormationState = z.infer<typeof FormationStateSchema>;
+export declare const TranscriptEntrySchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    type: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+        tool_call: "tool_call";
+        tool_result: "tool_result";
+    }>;
+    text: z.ZodString;
+    projection: z.ZodOptional<z.ZodObject<{
+        truncated: z.ZodBoolean;
+        original_chars: z.ZodNumber;
+        retained_chars: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TranscriptEntry = z.infer<typeof TranscriptEntrySchema>;
+export interface Projection {
+    entry?: TranscriptEntry;
+    route?: Route;
+    seenSourceIds?: string[];
+    privateCallId?: string;
+    resultCallId?: string;
+    sourceSeq?: number;
+    sourceArchived?: boolean;
+    activity?: {
+        seq: number;
+        at: number;
+        human?: boolean;
+        turn?: 'start' | 'completed' | 'ended';
+    };
+}
+export declare const processedThrough: (state: FormationState) => number;
+export declare class TranscriptStore {
+    readonly context: StoreContext;
+    private readonly maxBytes;
+    readonly states: SessionStateStore;
+    constructor(context: StoreContext, maxBytes?: number);
+    state(id: string): Promise<FormationState>;
+    read(id: string, repair?: boolean): Promise<TranscriptEntry[]>;
+    private pendingFiles;
+    private materialize;
+    record(id: string, projection: Projection): Promise<void>;
+    replay(id: string, projections: readonly Projection[]): Promise<void>;
+    advance(id: string, kind: 'recap' | 'finalize', untilSeq: number): Promise<void>;
+    lifecycle(id: string, change: (state: FormationState) => void): Promise<FormationState>;
+    sessions(formationOnly?: boolean): Promise<string[]>;
+}

package/lib/types/formation/triggers.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedConfig } from '../config.js';
+import type { FormationState, TranscriptEntry } from './transcript.js';
+export declare function idleTrigger(config: ResolvedConfig['formation'], state: FormationState, entries: readonly TranscriptEntry[], now: number): 'batch-idle' | 'tail-idle' | undefined;

package/lib/types/inbox/cascade.d.ts

@@ -0,0 +1,3 @@
+import type { Claim } from '../protocol/claim.js';
+import type { PolicyId } from '../protocol/ids.js';
+export declare function deprecatePolicyClaims(policyId: PolicyId, local: readonly Claim[], now?: string): Claim[];

package/lib/types/inbox/effects.d.ts

@@ -0,0 +1,275 @@
+import { z } from 'zod';
+import type { StoreContext } from '../store/context.js';
+import { type Claim } from '../protocol/claim.js';
+import { type InboxMessage } from '../protocol/inbox.js';
+import type { PreparedFormation } from '../formation/prepare.js';
+import type { JobControl } from '../worker/worker.js';
+export declare const InboxEffectSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"effect">;
+    canonicalId: z.core.$ZodBranded<z.ZodString, "InboxId", "out">;
+    batchHash: z.ZodString;
+    members: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "InboxId", "out">;
+        hash: z.ZodString;
+        message: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "InboxId", "out">;
+            message_type: z.ZodLiteral<"policy_update">;
+            policy: z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+                message_type: z.ZodDefault<z.ZodEnum<{
+                    policy_update: "policy_update";
+                    claim_attribute_update: "claim_attribute_update";
+                }>>;
+                name: z.ZodString;
+                statement: z.ZodString;
+                scope: z.ZodString;
+                status: z.ZodEnum<{
+                    active: "active";
+                    deprecated: "deprecated";
+                }>;
+                created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+                target_agents: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>>>;
+            }, z.core.$strip>;
+            handled_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "InboxId", "out">;
+            message_type: z.ZodLiteral<"claim_attribute_update">;
+            policy: z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+                message_type: z.ZodDefault<z.ZodEnum<{
+                    policy_update: "policy_update";
+                    claim_attribute_update: "claim_attribute_update";
+                }>>;
+                name: z.ZodString;
+                statement: z.ZodString;
+                scope: z.ZodString;
+                status: z.ZodEnum<{
+                    active: "active";
+                    deprecated: "deprecated";
+                }>;
+                created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+                target_agents: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>>>;
+            }, z.core.$strip>;
+            arbitration_resolution: z.ZodPreprocess<z.ZodOptional<z.ZodPreprocess<z.ZodObject<{
+                context_snapshot_hash: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+                dispute_snapshot: z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+                    name: z.ZodString;
+                    reporter_agent_id: z.ZodDefault<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+                    claims: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+                    summary: z.ZodString;
+                    status: z.ZodEnum<{
+                        open: "open";
+                        resolved: "resolved";
+                    }>;
+                    created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                    resolved_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+                }, z.core.$strip>;
+                direct_claim_snapshots: z.ZodArray<z.ZodObject<{
+                    id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+                    name: z.ZodString;
+                    statement: z.ZodString;
+                    scope: z.ZodString;
+                    holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+                    confidence: z.ZodEnum<{
+                        high: "high";
+                        medium: "medium";
+                        low: "low";
+                    }>;
+                    status: z.ZodEnum<{
+                        active: "active";
+                        stale: "stale";
+                        deprecated: "deprecated";
+                    }>;
+                    created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                    updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+                    source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+                    evidence_summary: z.ZodString;
+                }, z.core.$strip>>;
+                snapshot_source_resolution_id: z.ZodPreprocess<z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ResolutionId", "out">>>;
+                resolution_id: z.core.$ZodBranded<z.ZodString, "ResolutionId", "out">;
+                resolved_by: z.ZodEnum<{
+                    human: "human";
+                    automatic: "automatic";
+                }>;
+                resolved_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+                resolution_type: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+                    coexist: "coexist";
+                    lifecycle_update: "lifecycle_update";
+                    conflict_resolved: "conflict_resolved";
+                    unresolved: "unresolved";
+                }>>>;
+                resolution_basis: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+                    evidence: "evidence";
+                    insufficient_evidence: "insufficient_evidence";
+                    direct_analysis: "direct_analysis";
+                    prior_resolution: "prior_resolution";
+                    policy: "policy";
+                }>>>;
+                conclusion: z.ZodString;
+                claim_assessments: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    claim_id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+                    recommended_status: z.ZodEnum<{
+                        active: "active";
+                        stale: "stale";
+                        deprecated: "deprecated";
+                    }>;
+                    assessment: z.ZodString;
+                    recommended_scope: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+                    recommended_statement: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>>, z.ZodTransform<{
+                    claim_id: string & z.core.$brand<"ClaimId">;
+                    recommended_status: "active" | "stale" | "deprecated";
+                    assessment: string;
+                    reason: string;
+                    recommended_scope?: string | undefined;
+                    recommended_statement?: string | undefined;
+                }[] | undefined, {
+                    claim_id: string & z.core.$brand<"ClaimId">;
+                    recommended_status: "active" | "stale" | "deprecated";
+                    assessment: string;
+                    reason: string;
+                    recommended_scope?: string | undefined;
+                    recommended_statement?: string | undefined;
+                }[]>>;
+                rejection_reason: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+                dispute_id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+            }, z.core.$loose>>>>;
+            handled_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        }, z.core.$strip>], "message_type">>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        prepared: "prepared";
+        applied: "applied";
+    }>;
+    analysisClaims: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+        evidence_summary: z.ZodString;
+    }, z.core.$strip>>>;
+    preparedClaims: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+        evidence_summary: z.ZodString;
+    }, z.core.$strip>>;
+    appliedClaims: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+        evidence_summary: z.ZodString;
+    }, z.core.$strip>>;
+    teamAuthorized: z.ZodOptional<z.ZodBoolean>;
+    syncClaims: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+        evidence_summary: z.ZodString;
+    }, z.core.$strip>>>;
+    disputes: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+        name: z.ZodString;
+        reporter_agent_id: z.ZodDefault<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+        claims: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+        summary: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            resolved: "resolved";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        resolved_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    }, z.core.$strip>>;
+    trace: z.ZodNullable<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "TraceId", "out">;
+        name: z.ZodString;
+        task: z.ZodString;
+        agent: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        input_claims: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+        output_claims: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodString>;
+    retiredPolicies: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PolicyId", "out">>;
+}, z.core.$strict>;
+export type InboxEffect = z.infer<typeof InboxEffectSchema>;
+export declare const inboxMessageHash: (message: InboxMessage) => string;
+export declare class InboxEffectStore {
+    readonly context: StoreContext;
+    constructor(context: StoreContext);
+    private journals;
+    private write;
+    private references;
+    recover(): Promise<void>;
+    recoverLocked(): Promise<void>;
+    commit(messages: readonly InboxMessage[], analysisClaims: Claim[], prepared: PreparedFormation, control: JobControl): Promise<{
+        applied: number;
+        warnings: string[];
+        entityIds?: string[];
+    }>;
+    private applyLocked;
+}

package/lib/types/inbox/index.d.ts

@@ -0,0 +1,5 @@
+export * from './prepare.js';
+export * from './cascade.js';
+export * from './effects.js';
+export * from './sync.js';
+export * from './service.js';