@docmana/sdk 0.28.1 → 0.36.0-hitl.2

package/README.md

@@ -1,7 +1,77 @@
 # @docmana/sdk
 
+The HITL pilot uses the explicit prerelease `0.36.0-hitl.2` and the npm `hitl`
+distribution tag. Install the exact version for reproducible pilot builds:
+
+```sh
+npm install --save-exact @docmana/sdk@0.36.0-hitl.2
+```
+
+The stable default remains on `latest`; the prerelease does not select a native
+API. Configure the SDK's Consumer base URL on the application server.
+
+## Real formula node progress (local HITL pilot)
+
+`sdk.executionEvents.list(executionId, { organization, after: 0, limit: 100, signal })`
+reads a non-consuming metadata journal, including formulas without human review.
+Follow `nextAfter` while non-null; order by `sequence`, deduplicate `eventId`, and
+honor `truncated` when the cursor predates retained history. The native journal
+keeps at most 2,000 events with the execution. No PDF or final-result retention
+is added. Older APIs can return 404; show confirmed status without inventing
+progress. Never turn a journal failure into a call to another backend.
+
+The four new names are `execution.node.started`, `execution.node.completed`,
+`execution.node.failed`, and `execution.node.reused`. Events identify a node,
+document keys, revision and attempt. A reused output does not imply a new LLM
+call. Completion of a node is technical completion, not a positive business
+verdict or final execution completion. `occurredAt` is the real action time;
+`publishedAt` is optional broker time, present on signed callbacks.
+
+`verifyExecutionEventCallback` and `parseExecutionEventCallback` accept both the
+new node metadata and the four existing review events. Existing review-only
+verification helpers remain strict and unchanged. Final execution callbacks and
+result ownership keep their existing contract; there are no pipeline events.
+
+## Review event callbacks
+
+SDK 0.33.0 adds server-side `verifyReviewEventCallback`, `parseReviewEventCallback`
+and the `ReviewEventCallback` type for Consumer's opt-in review event relay.
+This is independent from `runFlowAsync({ callbackUrl })`, which still receives only
+the final result. No Service Bus connection is required in your application.
+
+```ts
+import { verifyReviewEventCallback } from "@docmana/sdk";
+const event = verifyReviewEventCallback({
+  body: rawUtf8Body,
+  signature: request.headers.get("x-docmana-event-signature"),
+  timestamp: request.headers.get("x-docmana-event-timestamp"),
+  secret: serverConfiguredSecret, // at least 32 characters; never sent to a browser
+  organization: expectedOrganization,
+});
+await persistOnce(event.organization, event.eventId, event);
+// Only now return 2xx. Never finalize an execution from a review notification.
+```
+
+Supported types are `execution.awaiting_review`, `execution.review_done`,
+`execution.review_closed` and `execution.review_expired`. `review_done` means the
+decision is recorded, not that the execution is finished. `review_closed` also
+describes the review rather than the execution. `publishedAt` is the broker's
+publication time. The metadata excludes document names, values, notes and results.
+Signatures use HMAC-SHA256 over `timestamp + "." + rawBody` with header `v1=<hex>`;
+verification accepts a five-minute clock difference. Broker retries are re-signed
+but retain the event ID; store it durably for deduplication. An event notification
+never consumes the final result. Source publication is best-effort: reconcile
+current review state separately after a missed notification.
+
 Official Docmana SDK for calling `docmana-consumer-edge-api`.
 
+SDK 0.32.0 adds native formula authoring, assisted conversations and revision-pinned
+document-trial preparation. Deploy Consumer authoring support before publishing
+and adopting this version. DocMana API main supports the ordinary Mongo path;
+assisted document trials run in DocMana Flows. A local development tarball is not
+an npm release. Optional Git/projection types remain POC contracts, not proof of
+support by API main.
+
 The SDK sends documents to Consumer, starts an async flow, polls Consumer for
 status, and returns the mapped Consumer execution DTO.
 
@@ -11,6 +81,17 @@ status, and returns the mapped Consumer execution DTO.
 npm install @docmana/sdk
 ```
 
+### GitHub release recovery
+
+The Release workflow publishes an existing `v<version>` tag. GitHub Actions are
+pinned to full commit SHAs to satisfy the enterprise policy. If a tag-triggered
+run fails before starting, merge the workflow correction first, then manually
+run **Release** from `main` with that existing tag. The workflow checks out the
+tag and verifies its package version before publishing; do not move a release
+tag to repair a pipeline. Publication requires the existing npm publisher
+credential or trusted-publishing configuration. Verify the version is available
+in npm before updating a consumer's lockfile.
+
 Requires Node.js 20+.
 
 ## Quickstart
@@ -345,6 +426,9 @@ from the Bearer token.
 Every SDK error extends `DocmanaError`, which carries `.status`, `.code`, and an
 optional `.requestId` when available.
 
+The optional `.apiCode` preserves the public API business code (for example,
+`RULE_INTEGRITY_VIOLATION`). `.code` keeps its existing SDK error category.
+
 | Error                            | Thrown when                                                                                     |
 | -------------------------------- | ----------------------------------------------------------------------------------------------- |
 | `DocmanaRequestError`            | `400` bad request.                                                                              |
@@ -379,6 +463,186 @@ For a one-shot publish to the local yalc store:
 npm run yalc:publish
 ```
 
+## Native formula authoring
+
+SDK 0.30.0 adds the existing DocMana stateful assistant through
+`authoring.openConversation({ flow_id, language, scope?, node_id?, messages? }, options)`,
+`sendConversationMessage(conversationId, content, options)` and
+`confirmConversation(conversationId, { rule_id?, document_type_rename? }, options)`.
+All three require organization scope and accept an abort signal. Opening does
+not call the LLM. Replies contain native context, suggestions and proposals;
+the client must explicitly apply and save approved rules. Confirmation only
+acknowledges acceptance; it does not save or publish. HTTP 410 means the session
+expired: reopen with the prior transcript and resolved context, then send the
+new message. Do not replay an uncertain network failure automatically.
+
+`docmana.authoring` manages native formulas through Consumer Edge's
+`/v1/authoring` endpoints. It requires the DOC-2385 Consumer deployment and the
+DocMana API authoring endpoints. These methods do not manage Git or YAML.
+
+```ts
+const options = { organization: "my-organization" };
+const formulas = await docmana.authoring.list({ ...options, limit: 50, offset: 0 });
+const snapshot = await docmana.authoring.get(formulas[0].id, options);
+const command = {
+  operationId: crypto.randomUUID(),
+  expectedRevisions: snapshot.revisions,
+  flowPatch: { name: "Updated formula" },
+};
+const receipt = await docmana.authoring.save(snapshot.flow.id, command, options);
+await docmana.authoring.validate(snapshot.flow.id, receipt.revisions, options);
+// Publication is an explicit separate operation.
+await docmana.authoring.publish(
+  snapshot.flow.id,
+  {
+    operationId: crypto.randomUUID(),
+    expectedRevisions: receipt.revisions,
+  },
+  options,
+);
+```
+
+Also available: `create`, `history(id, "snapshots" | "published", options)` and
+`flags(options)`. Every call requires an organization and accepts an AbortSignal.
+Lists return arrays; list limits are 1–200 and history limits are 1–100. List sorting is applied before pagination using `sort`: `id` (default), `name`, `newest`, `oldest`, `recentlyModified`, or `leastRecentlyModified`. Summaries include creation/modification dates and execution/document totals when available.
+`get` returns the editable graph, assisted rules, revisions and history counts.
+Create/save/publish return a receipt, not a reloaded graph. Reload with `get`
+after a successful mutation when server-generated prompt/rule identities matter.
+
+Retain the same operation ID **and identical body** when retrying an uncertain
+mutation outcome. A 409 has `error.status === 409`: keep the user's draft and
+resolve the conflict explicitly. The SDK never silently rebases or retries a
+conflict. Native metadata remains opaque and must be preserved by editors;
+server-owned identities, history and revisions are not patchable. Assisted
+editing requires the organization's `assisted-flows` flag and backend roles.
+
+Archive transfers use the existing DocMana `.docmana`/ZIP format, including
+assisted rules. `exportArchive(id, options)` returns `Uint8Array` bytes.
+`importArchive(blob, filename, options)` accepts one archive up to 10 MiB and
+returns `imported` or `confirmation_required`. On a duplicate, obtain explicit
+user confirmation before submitting the same file with `confirmOverwrite: true`.
+`remove(id, options)` permanently deletes the formula and its authoring data;
+confirm that action with the user. Import and deletion do not use operation IDs.
+
+## Human review of formula executions
+
+Read calculation metadata repeatedly with
+`client.reviews.calculation(executionId, { organization })`. It returns
+`executionResultId`, normalized `executionStatus` and `calculation` (null for
+legacy/unmarked runs). Calculation includes `status`, coherent `revision`
+(0 before the first calculation), optional `targetRevision`, `provisional`,
+review counts and computed/reused node counts for that revision. Node counts
+are not individual model-call counts. Calculation revision is distinct from
+`ReviewTask.version`, which remains required for decisions. A completed
+calculation stays provisional until the persisted execution is terminal.
+This read is available before the first review and after final callback delivery;
+it never consumes the single-use final result or triggers pipelines/callbacks.
+
+Requires Consumer's review routes and the compatible HITL Document API branch.
+No pipelines are required. Start published manual formulas with `runFlowAsync`;
+`AWAITING_REVIEW` is non-terminal. `runFlow` still waits for final completion and
+retains its configured timeout, so do not hold an HTTP request open for human work.
+
+```ts
+const scope = { organization: "your-organization", signal: controller.signal };
+const { reviews, nextCursor } = await docmana.reviews.list({
+  ...scope,
+  status: "pending",
+  limit: 50,
+});
+const task = await docmana.reviews.get(reviews[0].executionResultId, scope);
+await docmana.reviews.decide(
+  task.executionResultId,
+  {
+    decision: "continue",
+    version: task.version,
+    reviewer: authenticatedServerActor, // Never trust an identity from the browser.
+    corrections: [{ itemId: task.documents[0].items![0].itemId, value: false }],
+  },
+  scope,
+);
+// Preparation starts at import. Poll queued/processing; other states are terminal.
+const preparation = await docmana.reviews.document(
+  task.executionResultId,
+  task.documents[0].docKey,
+  "preview",
+  {
+    ...scope,
+    version: task.reviewId,
+  },
+);
+const manifest = await preparation.json(); // DocumentPreviewManifest
+// Only fetch numbers present in manifest.pages; page 1 precedes later batches.
+// Original content remains available as the PDF fallback.
+const page = await docmana.reviews.document(
+  task.executionResultId,
+  "doc01",
+  { page: 1 },
+  {
+    ...scope,
+    version: task.reviewId,
+    size: "thumb",
+  },
+);
+// page is a streaming Fetch Response. Consume or cancel its body; do not buffer a large PDF.
+```
+
+`list` accepts `pending`, `submitted`, `resuming` and an opaque `cursor`. It lists
+open tasks only. The `"*"` dossier entry is not a file. Use the returned item IDs
+unchanged; JSON values preserve `null`, `false`, `0`, objects and arrays.
+`document` also accepts `"content"` or `"locations"`, Range/If-Range and ETag
+options. It returns 200/206/304/416 without consuming the body.
+
+A decision receipt means **recorded and resume queued**, never final completion.
+On 409 inspect `DocmanaError.reviewConflict` and `apiCode`, then re-read the task.
+On 503 re-read first: the decision may already be recorded. The SDK does not retry
+a decision after a conflict, 503 or uncertain transport outcome. The standard one-time
+401 token-refresh retry still applies. Keep the existing final callback/polling result owner;
+opening a review must not consume the single-use execution result.
+
+Release order: compatible Document API, Consumer, published SDK, then Arcana's
+exact pinned dependency. This local 0.33.0 candidate is not published by these steps.
+
 ## License
 
 MIT
+
+`authoring.editorCatalog(options)` retrieves organization-scoped models, tools, external-system field definitions, default prompts and feature flags for native node editors. External-system credentials are excluded. `authoring.generateMapping({ workflow_fields, expected_fields, current_mapping, user_instructions }, options)` returns `{ jsonataExpression }` from the native mapper; it does not save or publish the proposal.
+
+### Git publication provenance (local authoring POC)
+
+The types preserve optional `authoringSource`, Git commit/artifact hashes and
+projection fields for the POC contract. DocMana API main rejects these fields on
+native create/save/publish, including an explicit `{kind: "mongo"}` discriminator;
+omit them for ordinary Mongo authoring. The current Git POC uses the explicitly
+local Mongo release adapter in DocMana Flows instead.
+
+Optional response provenance remains lossless when a compatible backend provides
+it. Consumer and the SDK do not synchronize repositories, verify a checkout,
+compute a publication baseline or automatically publish newer commits. The
+presence of a TypeScript field does not enable an unsupported backend capability.
+
+### Document trials
+
+Use `authoring.trialDocument(fileBlob, filename, spec, { organization, signal })` for manual document-node trials. `spec` selects a saved native `flowId`, `expectedRevisions`, and either `node` or `allNodes`; alternatively it contains compiled YAML `nodes` with native prompts. Consumer calls the existing DocMana API test-fields/test-metadata endpoints. Temporary YAML prompts are removed in finally; abrupt process failure can leave one for administrator cleanup.
+
+For assisted Mongo nodes, call `authoring.documentTrialDefinitions({ flowId, expectedRevisions, node | allNodes }, { organization, signal })`. This read-only preparation pins active node-owned rules and settings to the coherent native snapshot, checking revisions again after resolution. Pass the returned definition and uploaded file to the server-side `runAssistedDocumentTrial` library in `@docmana/docmana-flows`. Git callers use Flows' `prepareDocumentTrial` directly. Neither path requires `/extract/test-assisted` or a modified DocMana API. Calling the old native trial method with assisted nodes now fails before upload with HTTP 422.
+
+Flows owns assisted IDP/model calls and requires its server-side provider configuration. It analyzes the file once and tries up to 100 compatible classification/extraction nodes independently, retaining evidence envelopes. Files are nonempty PDF/images up to 20 MiB. Definitions and uploads use disposable local storage, cleaned after completion; no formula, rule, reference expectation or publication is saved. These trials do not execute production routing, translate results, compare expectations or produce release approval evidence. Missing upstream context is rejected. Native API accounting and PromptShield are not implied by the Flows executor. No new CLI command is introduced.
+
+### Formula steps during human review
+
+Task detail also preserves optional native `createdAt`, `submittedAt`, `resumingAt` and `closedAt` timestamps. Human waiting is bounded by task creation and native decision acceptance; review closure does not prove final execution completion. Older backends can omit these fields; clients must show an unavailable duration rather than infer it from callback delivery time.
+
+Use client.reviews.outline(flowId, { organization }) to read the published nodes, edges, ordering and human-review marks through Consumer. Compare outline.version with the review flowVersion before displaying progress. This read never consumes an execution result and does not introduce pipelines.
+
+### Frozen review evidence (local HITL pilot)
+
+`reviews.get()` optionally returns `documents[].assessments`: the stored node score (0–100), `scoreDescription`, `feedback`, `explanation` and `reasoning` from the same frozen snapshot as the items. These are read-only node-level evidence, not uncertain-field findings. Older backends may omit assessments or scores; do not infer missing scores. Decisions still send only editable item corrections through Consumer.
+
+`ReviewTask.findings?: ReviewFinding[]` separately carries explicit field signals:
+stable review-scoped `id`, `code`, `message`, resolved `itemIds`, and optional
+`source` (`model` or `rule`). Consumers must not infer fields from node scores or
+explanation text. Missing or empty findings preserve the existing presentation.
+These are frozen evidence, not per-field decisions; editing a value does not
+erase its finding. Continue using the same global, versioned decision call.

package/dist/authoring.d.ts

@@ -0,0 +1,317 @@
+import type { HttpClient } from "./http/http-client.js";
+/** Native editor data is lossless: unknown metadata is retained during edits. */
+export type AuthoringData = Record<string, unknown>;
+export interface AuthoringNode extends AuthoringData {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    data: AuthoringData & {
+        label: string;
+        type: string;
+        enabled?: boolean;
+    };
+    parentId?: string;
+}
+export interface AuthoringEdge extends AuthoringData {
+    id: string;
+    source: string;
+    target: string;
+}
+export interface AuthoringRevisions {
+    flow: number;
+    nodes: Record<string, number>;
+    edges: Record<string, number>;
+    rules: Record<string, number>;
+}
+export type AuthoringSource = {
+    kind: "mongo";
+} | {
+    kind: "git";
+    formulaId: string;
+    repository: string;
+    path: string;
+    ref: string;
+};
+export interface AuthoringGitPublication {
+    source: Extract<AuthoringSource, {
+        kind: "git";
+    }>;
+    commitSha: string;
+    publishedVersion: number;
+    mongoRevisions: AuthoringRevisions;
+    contentHash: string;
+    publishedAt: string;
+    artifactHash?: string | null;
+    toolingHash?: string | null;
+}
+export interface AuthoringGitProjection {
+    source: Extract<AuthoringSource, {
+        kind: "git";
+    }>;
+    commitSha: string;
+    artifactHash: string;
+    toolingHash: string;
+    operationId: string;
+    mongoRevisions: AuthoringRevisions;
+    contentHash: string;
+    projectedAt: string;
+}
+export interface AuthoringPublication {
+    operationId: string;
+    expectedRevisions: AuthoringRevisions;
+    gitCommitSha?: string;
+    gitArtifactHash?: string;
+    gitToolingHash?: string;
+}
+export interface AuthoringFlowSummary extends AuthoringData {
+    authoringSource?: AuthoringSource | null;
+    lastGitPublication?: AuthoringGitPublication | null;
+    lastGitProjection?: AuthoringGitProjection | null;
+    createdAt?: string;
+    updatedAt?: string;
+    executionStats?: {
+        totalExecutions: number;
+        totalDocuments: number;
+    };
+    id: string;
+    name: string;
+    type?: "manual" | "assisted";
+    state?: string;
+    isDirty?: boolean;
+}
+export interface AuthoringSnapshot {
+    gitPublicationState?: {
+        status: "not_published" | "unchanged" | "diverged" | "staged";
+        currentContentHash: string;
+    } | null;
+    flow: AuthoringFlowSummary & {
+        configs?: AuthoringData;
+        nodes: AuthoringNode[];
+        edges: AuthoringEdge[];
+    };
+    rules: AuthoringData[];
+    revisions: AuthoringRevisions;
+    historyCounts: {
+        snapshots: number;
+        published: number;
+    };
+}
+export interface AuthoringChanges {
+    create?: AuthoringData[];
+    update?: {
+        id: string;
+        patch: AuthoringData;
+    }[];
+    delete?: string[];
+}
+export interface AuthoringDraft {
+    gitProjection?: {
+        commitSha: string;
+        artifactHash: string;
+        toolingHash: string;
+    };
+    authoringSource?: AuthoringSource;
+    operationId: string;
+    expectedRevisions: AuthoringRevisions;
+    flowPatch?: AuthoringData;
+    nodes?: AuthoringChanges;
+    edges?: AuthoringChanges;
+    prompts?: {
+        create?: AuthoringData[];
+        updateForNode?: string[];
+        delete?: string[];
+        upsertForNode?: {
+            id: string;
+            prompt: AuthoringData;
+        }[];
+    };
+    rules?: AuthoringData[];
+}
+export interface AuthoringCreate {
+    authoringSource?: AuthoringSource;
+    operationId: string;
+    id: string;
+    name: string;
+    type: "manual" | "assisted";
+    configs?: AuthoringData;
+    nodes: AuthoringNode[];
+    edges: AuthoringEdge[];
+}
+export interface AuthoringReceipt {
+    success: boolean;
+    id?: string;
+    version?: number;
+    flowUpdatedAt: string;
+    revisions: AuthoringRevisions;
+    committedRuleIds?: Record<string, string>;
+}
+export interface AuthoringOptions {
+    organization: string;
+    signal?: AbortSignal;
+}
+export interface AuthoringDocumentTrialNode {
+    id: string;
+    name: string;
+    type: "classification" | "extraction" | "metadata-extraction";
+    prompt?: {
+        metadata: AuthoringData;
+        messages: AuthoringData[];
+        schemaDatas: AuthoringData;
+    };
+    /** Native assisted definition; mutually exclusive with a manual prompt. */
+    assisted?: {
+        metadata: AuthoringData;
+        rules: AuthoringData[];
+        configs: AuthoringData;
+    };
+}
+export type AuthoringDocumentTrialSpec = {
+    flowId: string;
+    expectedRevisions: AuthoringRevisions;
+    node?: string;
+    allNodes?: boolean;
+} | {
+    nodes: AuthoringDocumentTrialNode[];
+};
+export interface AuthoringDocumentTrialReport {
+    executor?: "flows" | "docmana-api";
+    mode: "document-trial";
+    execution_scope: "isolated";
+    status: "completed" | "error";
+    rows: {
+        node: string;
+        name: string;
+        type: string;
+        status: "completed" | "error";
+        seconds: number;
+        output?: AuthoringData;
+        error?: string;
+    }[];
+}
+export interface AuthoringEditorCatalog {
+    capabilities?: {
+        canonicalProjection?: number;
+        runtimeEnvironment?: string;
+    };
+    models: {
+        default_model: string;
+        assisted_model?: string;
+        ai_provider: string;
+        models: {
+            model_name: string;
+            reasoning_effort_values?: string[] | null;
+            default_reasoning_effort?: string | null;
+        }[];
+    };
+    tools: (AuthoringData & {
+        tool_id: string;
+        tool_name?: string;
+        type?: string;
+        short_description_fr?: string;
+        short_description_en?: string;
+    })[];
+    systems: {
+        id: string;
+        name: string;
+        expectedFields?: AuthoringData[];
+    }[];
+    defaults: {
+        aggregator: string;
+    };
+    flags: {
+        flags: Record<string, boolean>;
+    };
+}
+export interface AuthoringConversationContext {
+    flow_id: string;
+    scope?: string | null;
+    node_id?: string | null;
+    node_label?: string | null;
+}
+export interface AuthoringConversation {
+    conversation_id: string;
+    expires_at: string;
+    context: AuthoringConversationContext;
+}
+export interface AuthoringConversationInput {
+    flow_id: string;
+    language: "fr" | "en";
+    scope?: string;
+    node_id?: string;
+    messages?: {
+        role: "user" | "assistant";
+        content: string;
+    }[];
+}
+export interface AuthoringConversationTurn {
+    assistant_message: string;
+    options?: unknown[] | null;
+    proposed_rule?: AuthoringData | null;
+    proposed_document_type_rename?: AuthoringData | null;
+    context: AuthoringConversationContext;
+    target_resolved: boolean;
+    expires_at: string;
+}
+export type AuthoringSort = "id" | "newest" | "oldest" | "recentlyModified" | "leastRecentlyModified" | "name";
+export interface AuthoringPageOptions extends AuthoringOptions {
+    sort?: AuthoringSort;
+    offset?: number;
+    limit?: number;
+}
+/** Aggregate authoring only. Caller retains operation IDs when retrying mutations. */
+export declare class FormulaAuthoring {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Read-only, revision-pinned definitions. Assisted execution belongs to the server-side Flows POC. */
+    documentTrialDefinitions(spec: {
+        flowId: string;
+        expectedRevisions: AuthoringRevisions;
+        node?: string;
+        allNodes?: boolean;
+    }, options: AuthoringOptions): Promise<{
+        nodes: AuthoringDocumentTrialNode[];
+    }>;
+    /** Native manual execution through Consumer Edge; assisted trials use definitions plus server-side Flows. */
+    trialDocument(file: Blob, filename: string, spec: AuthoringDocumentTrialSpec, options: AuthoringOptions): Promise<AuthoringDocumentTrialReport>;
+    editorCatalog(options: AuthoringOptions): Promise<AuthoringEditorCatalog>;
+    generateMapping(body: {
+        workflow_fields: AuthoringData[];
+        expected_fields: AuthoringData[];
+        current_mapping: string;
+        user_instructions: string;
+    }, options: AuthoringOptions): Promise<{
+        jsonataExpression: string;
+    }>;
+    openConversation(body: AuthoringConversationInput, options: AuthoringOptions): Promise<AuthoringConversation>;
+    sendConversationMessage(id: string, content: string, options: AuthoringOptions): Promise<AuthoringConversationTurn>;
+    confirmConversation(id: string, body: {
+        rule_id?: string;
+        document_type_rename?: boolean;
+    }, options: AuthoringOptions): Promise<{
+        expires_at: string;
+    }>;
+    private request;
+    list(options: AuthoringPageOptions): Promise<AuthoringFlowSummary[]>;
+    remove(id: string, options: AuthoringOptions): Promise<{
+        success: boolean;
+    }>;
+    exportArchive(id: string, options: AuthoringOptions): Promise<Uint8Array>;
+    importArchive(file: Blob, filename: string, options: AuthoringOptions & {
+        confirmOverwrite?: boolean;
+    }): Promise<{
+        status: "imported" | "confirmation_required";
+        flowName?: string;
+    }>;
+    get(id: string, options: AuthoringOptions): Promise<AuthoringSnapshot>;
+    create(body: AuthoringCreate, options: AuthoringOptions): Promise<AuthoringReceipt>;
+    save(id: string, body: AuthoringDraft, options: AuthoringOptions): Promise<AuthoringReceipt>;
+    validate(id: string, revisions: AuthoringRevisions, options: AuthoringOptions): Promise<AuthoringData>;
+    publish(id: string, body: AuthoringPublication, options: AuthoringOptions): Promise<AuthoringReceipt>;
+    history(id: string, kind: "snapshots" | "published", options: AuthoringPageOptions): Promise<AuthoringData[]>;
+    flags(options: AuthoringOptions): Promise<{
+        flags: Record<string, boolean>;
+    }>;
+}