monday-cli 0.4.0 → 0.6.0

package/dist/api/documents.d.ts

@@ -1,7 +1,11 @@
 /**
- * Workdocs read surface for the v0.4-M32 `monday doc list/get` verbs
- * (`cli-design.md` §2.7 + §4.3 + §13 v0.4 entry; `v0.4-plan.md` §3
- * M32).
+ * Workdocs read + mutation surface for the v0.4-M32 `monday doc
+ * list/get` verbs, the v0.5-M35 doc-level CRUD verbs, the v0.5-M36
+ * per-block CRUD verbs, and the v0.5-M37 doc-content import verbs
+ * (`cli-design.md` §2.7 + §4.3 + §13 v0.4/v0.5 entries;
+ * `v0.4-plan.md` §3 M32; `v0.5-plan.md` §3 M35 + §8 D7-D9;
+ * `v0.5-plan.md` §3 M36 + §8 D10-D11; `v0.5-plan.md` §3 M37 + §8
+ * D12-D13).
  *
  * **Wire surface (empirical probe 2026-05-14, API `2026-01`).** Two
  * Monday GraphQL operations land here, both against `Query.docs(...)`:
@@ -105,6 +109,158 @@
  * `details.issues`. The `doc get` empty-array case rewraps to
  * `not_found` with `details.doc_id` per D8 (Monday's wire collapses
  * "doesn't exist" + "not visible to token" into the same shape).
+ *
+ * **v0.5-M35 mutation surface (empirical probe 2026-05-15, API
+ * `2026-01`; v0.5 kickoff rounds 1-3).** Five CLI verbs land here
+ * at v0.5-M35, backed by four Monday GraphQL mutations —
+ * `create_doc` (2 CLI verbs because Monday's `CreateDocInput` is
+ * mutually-exclusive `board` vs `workspace` per D7) +
+ * `update_doc_name` + `delete_doc` + `duplicate_doc`. All four
+ * wire mutations are synchronous on Monday's wire — the v0.4-W1
+ * `dispatchPollingLoop` watch-item DOES NOT fire here.
+ *
+ *   - **Create-in-workspace variant** — `create_doc(location:
+ *     CreateDocInput!) → Document` with `location: { workspace:
+ *     CreateDocWorkspaceInput { workspace_id!, name!, kind?:
+ *     BoardKind, folder_id? } }`. CLI envelope OMITS the wire's
+ *     `blocks` slot entirely (the base 13-field
+ *     {@link documentSchema} M32 pin is the create projection).
+ *     Monday returns `blocks: null` on a fresh create — agents
+ *     needing block hydration (rare on a fresh create — usually
+ *     the next step is content authoring) call `monday doc get
+ *     <new-doc-id>` per the M32 read cadence.
+ *   - **Create-on-column variant** — `create_doc(location:
+ *     CreateDocInput!) → Document` with `location: { board:
+ *     CreateDocBoardInput { column_id!, item_id! } }`.
+ *   - **Rename variant** — `update_doc_name(docId: ID!,
+ *     name: String!) → JSON` (opaque scalar). Returns wire-side
+ *     opaque payload; the CLI projects to flat `{ doc_id: <input>,
+ *     success: true }` envelope at the fetcher boundary per D9.
+ *     The agent contract is the projected envelope shape, NOT the
+ *     opaque Monday return value.
+ *   - **Delete variant** — `delete_doc(docId: ID!) → JSON`
+ *     (opaque). Same `{ doc_id, success }` projection per D9.
+ *     Destructive gate per cli-design §3.1 (M35 verb requires
+ *     `--yes`).
+ *   - **Duplicate variant** — `duplicate_doc(docId: ID!,
+ *     duplicateType?: DuplicateType) → JSON` (opaque). Same
+ *     `{ doc_id, success }` projection per D9. `--with-updates`
+ *     argv flag flips wire `duplicateType` from
+ *     `duplicate_doc_with_content` (default) to
+ *     `duplicate_doc_with_content_and_updates`. **No `--name <n>`
+ *     rename slot per D8** — Monday's `duplicate_doc` mutation
+ *     carries no name-override arg on the wire, so the CLI defers
+ *     the rename-on-duplicate UX (an agent that needs a renamed
+ *     duplicate pairs the verb with a follow-up `monday doc
+ *     rename <new-id> --name <n>` call).
+ *
+ * **`CreateDocInput` is mutually-exclusive on Monday's wire.**
+ * Per Finding 6 + round-3 nested-inputs probe, supplying both
+ * `board` AND `workspace` slots fails server-side. The CLI's
+ * two-verb split (`monday doc create-in-workspace` vs `monday doc
+ * create-on-column`) flows the mutual-exclusion into the argv
+ * boundary — each verb's input schema declares the slot it
+ * supports, and there's no way to set both via the CLI surface.
+ * Single verb with `--workspace` / `--board` choosers was the
+ * D7 alternative; pre-flight ratified the two-verb shape per the
+ * agent-UX principle of "fewer ambiguous flags is clearer than
+ * one verb with mutually-exclusive choosers" (mirrors how the
+ * v0.4 cli-design ships separate `monday item upload` /
+ * `monday update upload` verbs for the same multipart wire path).
+ *
+ * **camelCase vs snake_case asymmetry across the doc-mutation
+ * surface (Finding 7).** Monday's `update_doc_name` /
+ * `delete_doc` / `duplicate_doc` mutations use **camelCase** arg
+ * names (`docId`, `duplicateType`) on the wire — distinct from
+ * the snake_case `doc_id` Monday uses for `Document` field names
+ * elsewhere on the schema. The fetcher boundary uses the wire's
+ * camelCase variable shape verbatim; the CLI argv stays kebab-case
+ * throughout (`--name <n>`, `--with-updates`); the error envelope
+ * `details.*` keys stay snake_case per cli-design §6.5 (e.g.
+ * `details.doc_id`). The asymmetry is wire-side and stays at the
+ * fetcher boundary; agents see camelCase nowhere. Cross-link to
+ * `docs/architecture.md` "Wire-vs-CLI semantics documentation
+ * conventions" — 4th supporting site for R-NEW-41 (camelCase vs
+ * snake_case arg-name asymmetry; R-v0.5-NEW-3 graduation candidate
+ * at v0.5-plan §22).
+ *
+ * **Opaque-JSON return shape (D9 closure).** 3 of 4 M35 mutations
+ * return Monday's `JSON` scalar — an untyped wire payload whose
+ * exact shape isn't pinned by introspection. The CLI projects to
+ * a flat `{ doc_id: string, success: true }` envelope at the
+ * fetcher boundary so agents read a uniform shape across rename /
+ * delete / duplicate; `success` is pinned literal-`true` because
+ * Monday surfaces failure via GraphQL `errors[]` (mapped to typed
+ * `ApiError`s upstream), not via a wire-side success flag.
+ *
+ * Per-fetcher null-payload semantics ARE asymmetric (round-1 P2-1
+ * closure):
+ *
+ *   - **`renameDoc` (`update_doc_name`)** — present-but-null
+ *     payload → success envelope. Monday's probe description
+ *     carries NO "returns X" prose, so null is plausibly an
+ *     empty-success indicator.
+ *   - **`deleteDoc` (`delete_doc`)** — present-but-null payload
+ *     → `not_found`. Probe description: "Returns success status
+ *     and the deleted document ID" — null indicates the source
+ *     doc was bogus or already-deleted.
+ *   - **`duplicateDoc` (`duplicate_doc`)** — present-but-null
+ *     payload → `not_found`. Probe description: "Returns the new
+ *     document's ID on success" — null indicates the source
+ *     wasn't duplicable.
+ *
+ * Missing-root-key cases for all three uniformly throw
+ * `internal_error` via `assertResponseFieldPresent` (schema
+ * drift). For `duplicate_doc`, the projected `doc_id` is the
+ * **NEWLY-CREATED doc's id** extracted from the opaque JSON via
+ * {@link extractDuplicateDocId} — defensive across multiple
+ * plausible wire shapes (bare string / number / record-with-`id`
+ * / `doc_id` / `new_doc_id`). Capturing a live duplicate-doc wire
+ * response would let a future revision narrow the helper's
+ * accepted shapes; today's helper is constructed against the
+ * read-only probe + Monday's wire description, not a live wire
+ * response.
+ *
+ * **No new ERROR_CODES at M35.** Existing codes route doc-mutation
+ * failures: `not_found` (rename/delete/duplicate against a
+ * non-existent or inaccessible doc), `usage_error` (argv-parse
+ * rejections — bad DocId, missing `--name`, unknown `--kind`),
+ * `validation_failed` (Monday-side rejection, e.g. workspace
+ * lacks doc-create permission), `forbidden`/`unauthorized` (token
+ * lacks workdoc write scope), `confirmation_required` (destructive
+ * gate on `doc delete` missing `--yes`).
+ *
+ * **Doc mutations are live-only at v0.5-M35.** Pure-mutation
+ * surfaces don't cache by definition (cli-design §8); `meta.source:
+ * "live"`. Dry-run paths emit `meta.source: "none"` per §6.4
+ * mutation-dry-run discipline.
+ *
+ * **Runtime bodies landed at v0.5-M35 IMPL.** All five fetchers
+ * issue a single `client.raw` round-trip with their pinned
+ * `operationName`; responses parse through the wrapping schemas
+ * via `unwrapOrThrow` + `assertResponseFieldPresent`, then either
+ * unwrap the per-Document payload (create variants) or project
+ * the opaque JSON return to the flat `{ doc_id, success: true }`
+ * envelope (rename / delete / duplicate per D9). The
+ * `duplicate_doc` projection extracts the new doc id from the
+ * opaque JSON via {@link extractDuplicateDocId} — defensive
+ * across common wire shapes (bare string, `{id}`, `{doc_id}`,
+ * `{new_doc_id}`); unrecognised shapes surface `internal_error`
+ * with a re-probe hint.
+ *
+ * **R-NEW-76 discipline preserved** across all 5 M35 command
+ * action bodies — `parseArgv` fires BEFORE `resolveClient` on
+ * every verb so invalid argv surfaces `usage_error` from the
+ * parse boundary, ahead of any `config_error` from a missing
+ * token. `doc delete` additionally calls `parseGlobalFlags` +
+ * `enforceDestructiveGate` BEFORE `resolveClient` (the gate
+ * needs the parsed global flags to check `--yes`; M10 round-1
+ * P2 invariant); the other four verbs let `resolveClient` parse
+ * global flags internally before `loadConfig` runs. M35 verbs
+ * do not consume comma-separated brand-list flags
+ * (`parseBrandedListArg` is an M34 team-writer / M32 `doc list
+ * --workspace` helper); the M35
+ * surface doesn't need it.
  */
 import { z } from 'zod';
 import type { MondayClient } from './client.js';
@@ -516,4 +672,981 @@ export interface GetDocumentResult {
  * loudly rather than silently dropping entries.
  */
 export declare const getDocument: (inputs: GetDocumentInputs) => Promise<GetDocumentResult>;
+/**
+ * Monday's `DuplicateType` enum vocabulary (empirical probe 2026-05-15,
+ * API `2026-01`; 2 values). Pinned at M35 pre-flight as a closed
+ * literal-union so unknown values reject at the parse boundary with
+ * `usage_error`.
+ *
+ * - `duplicate_doc_with_content` — clone the doc body only; comments
+ *   and update history are NOT copied. Wire-side default when
+ *   `duplicateType` is omitted.
+ * - `duplicate_doc_with_content_and_updates` — clone the doc body
+ *   AND every comment / update thread attached to the source doc.
+ *   Picks up Monday's "full backup" duplicate semantics.
+ *
+ * Maps to the CLI's boolean `--with-updates` flag at the M35
+ * `monday doc duplicate` argv boundary: absent → wire default
+ * (`duplicate_doc_with_content`, content-only); present → wire
+ * `duplicate_doc_with_content_and_updates`. The two-value enum
+ * stays internal to the fetcher — agents see a boolean opt-in, not
+ * the wire enum name.
+ *
+ * Adding a third value to Monday's enum is a minor (additive) bump
+ * for the CLI — extend this list + the fetcher mapping; the
+ * boolean argv stays.
+ */
+export declare const DUPLICATE_TYPE_VALUES: readonly ["duplicate_doc_with_content", "duplicate_doc_with_content_and_updates"];
+export type DuplicateType = (typeof DUPLICATE_TYPE_VALUES)[number];
+export declare const duplicateTypeSchema: z.ZodEnum<{
+    duplicate_doc_with_content: "duplicate_doc_with_content";
+    duplicate_doc_with_content_and_updates: "duplicate_doc_with_content_and_updates";
+}>;
+/**
+ * Projected envelope shape for the three opaque-JSON mutation
+ * results (`update_doc_name` / `delete_doc` / `duplicate_doc`).
+ * Per D9 closure, the CLI surfaces a flat `{ doc_id: string,
+ * success: true }` envelope so agents read a uniform shape across
+ * mutations — Monday's wire returns an opaque `JSON` scalar whose
+ * exact shape isn't pinned by introspection (the v0.5 doc-CRUD
+ * probe was read-only — no live mutation response was captured).
+ * The projection insulates agents from any wire-side shape drift;
+ * the runtime accepts plausible-defensive shapes today, and a
+ * future live wire response would narrow what the helper accepts.
+ *
+ * `success` is pinned to literal `true` because Monday surfaces
+ * failure via GraphQL `errors[]` (mapped to typed `ApiError`s at
+ * the transport layer); a JSON return that reaches this projection
+ * is by construction the success path. If Monday ever flips to a
+ * `success/error` result OBJECT shape for these mutations (mirroring
+ * `import_doc_from_html` / `add_content_to_doc_from_markdown` per
+ * Finding 6), the projection widens to a discriminated union — for
+ * today the literal-`true` form keeps the shape pinned.
+ *
+ * `doc_id` semantics differ per mutation:
+ *
+ *   - `rename` / `delete` — echoes the input id (the operation
+ *     targets that specific doc; success means it was renamed /
+ *     deleted).
+ *   - `duplicate` — emits the **NEWLY-CREATED** doc's id (Monday's
+ *     `duplicate_doc` description: "Returns the new document's ID
+ *     on success"; the fetcher extracts the new id from the
+ *     opaque JSON via {@link extractDuplicateDocId}, which is
+ *     defensive across plausible wire shapes today). The original
+ *     source-doc id stays available via the argv positional.
+ */
+export declare const docMutationResultSchema: z.ZodObject<{
+    doc_id: z.ZodString;
+    success: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type DocMutationResult = z.infer<typeof docMutationResultSchema>;
+/**
+ * Output shape for `monday doc create-in-workspace --workspace
+ * <wid> --name <n> [--folder <fid>] [--kind public|private|share]`.
+ * Direct unwrap of the created Document — `data: <Document>` per
+ * cli-design §6.1 single-record convention. The envelope OMITS
+ * the `blocks` slot entirely (the base {@link documentSchema} M32
+ * pin is the 13-field projection without `blocks`).
+ *
+ * **Rationale for the omit.** Monday's wire returns
+ * `blocks: null` on a fresh `create_doc` because a freshly-
+ * created doc has no rich-text body yet (Monday hasn't
+ * materialised it). Surfacing a constant-null `blocks` slot on
+ * every create envelope would add agent-noise — every caller
+ * has to ignore it. Agents that need block hydration (rare on a
+ * fresh create — usually the next step is content authoring)
+ * call `monday doc get <new-doc-id>` per the M32 read cadence.
+ * The omit is a contract decision, not a schema-flexibility
+ * artifact.
+ */
+export declare const docCreateInWorkspaceOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object_id: z.ZodString;
+    name: z.ZodString;
+    doc_kind: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        share: "share";
+    }>;
+    url: z.ZodNullable<z.ZodString>;
+    relative_url: z.ZodNullable<z.ZodString>;
+    workspace_id: z.ZodNullable<z.ZodString>;
+    workspace: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    doc_folder_id: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodNullable<z.ZodString>;
+    created_by: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    updated_at: z.ZodNullable<z.ZodString>;
+    settings: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+}, z.core.$strict>;
+export type DocCreateInWorkspaceOutput = Document;
+/**
+ * Output shape for `monday doc create-on-column --item <iid>
+ * --column <cid>`. Same shape as
+ * {@link docCreateInWorkspaceOutputSchema} — Monday's wire returns
+ * the full Document regardless of placement; the two-verb split
+ * (per D7) lives at the argv layer, not the response shape.
+ */
+export declare const docCreateOnColumnOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object_id: z.ZodString;
+    name: z.ZodString;
+    doc_kind: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        share: "share";
+    }>;
+    url: z.ZodNullable<z.ZodString>;
+    relative_url: z.ZodNullable<z.ZodString>;
+    workspace_id: z.ZodNullable<z.ZodString>;
+    workspace: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    doc_folder_id: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodNullable<z.ZodString>;
+    created_by: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    updated_at: z.ZodNullable<z.ZodString>;
+    settings: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+}, z.core.$strict>;
+export type DocCreateOnColumnOutput = Document;
+/**
+ * Output shape for `monday doc rename <doc-id> --name <n>`.
+ * Projected from Monday's opaque `JSON` scalar return per D9 — the
+ * fetcher emits `{ doc_id: <echoed>, success: true }`. Agents key
+ * off `ok: true` for retry/idempotency reasoning; the literal
+ * `success: true` slot exists for envelope-snapshot stability and
+ * future-proofing (if Monday ever surfaces a wire-side success
+ * flag, the schema widens to read the wire value rather than
+ * always emitting `true`).
+ */
+export declare const docRenameOutputSchema: z.ZodObject<{
+    doc_id: z.ZodString;
+    success: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type DocRenameOutput = DocMutationResult;
+/**
+ * Output shape for `monday doc delete <doc-id> --yes`. Same
+ * `{ doc_id: <echoed>, success: true }` projection as rename per
+ * D9. The destructive-gate envelope sits at the action body —
+ * `confirmation_required` fires BEFORE this output schema is
+ * referenced (cli-design §3.1 #6).
+ */
+export declare const docDeleteOutputSchema: z.ZodObject<{
+    doc_id: z.ZodString;
+    success: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type DocDeleteOutput = DocMutationResult;
+/**
+ * Output shape for `monday doc duplicate <doc-id> [--with-updates]`.
+ * Same flat `{ doc_id, success: true }` projection per D9, BUT the
+ * `doc_id` slot carries the **newly-created duplicate's id** — NOT
+ * the source-doc id. The verb's positional argv is the source-doc
+ * id; the wire returns the new id in its JSON payload, which
+ * {@link extractDuplicateDocId} pulls out (defensive across
+ * plausible shapes today; a future live wire response would
+ * narrow what the helper accepts).
+ *
+ * **No `--name <n>` slot per D8** — Monday's `duplicate_doc`
+ * mutation carries no rename-on-duplicate arg. Agents needing a
+ * renamed duplicate pair with a follow-up `monday doc rename
+ * <new-id> --name <n>` call.
+ */
+export declare const docDuplicateOutputSchema: z.ZodObject<{
+    doc_id: z.ZodString;
+    success: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type DocDuplicateOutput = DocMutationResult;
+/**
+ * GraphQL mutation document for `create_doc(location: {workspace:
+ * ...})`. Operation name pinned to `CreateDocInWorkspace`
+ * (R-NEW-37 W2 audit-point — operationNames NOT caller-overridable).
+ * Selects every base-Document field per the M32 cadence; `blocks`
+ * deliberately omitted (Monday's wire returns `blocks: null` on a
+ * fresh create — see the module header's create-variant note).
+ *
+ * `$input: CreateDocInput!` carries the mutually-exclusive wire
+ * shape; the verb's action body composes
+ * `{ workspace: { workspace_id, name, folder_id?, kind? } }` from
+ * the parsed argv. The `board` slot stays unset at the wire — the
+ * two-verb CLI split (per D7) makes the mutual-exclusion safely-
+ * by-construction.
+ */
+export declare const CREATE_DOC_IN_WORKSPACE_MUTATION = "\n  mutation CreateDocInWorkspace($input: CreateDocInput!) {\n    create_doc(location: $input) {\n      id\n      object_id\n      name\n      doc_kind\n      url\n      relative_url\n      workspace_id\n      workspace { id name }\n      doc_folder_id\n      created_at\n      created_by { id name }\n      updated_at\n      settings\n    }\n  }\n";
+/**
+ * GraphQL mutation document for `create_doc(location: {board: ...})`.
+ * Operation name pinned to `CreateDocOnColumn` (R-NEW-37 W2). Same
+ * Document selection as {@link CREATE_DOC_IN_WORKSPACE_MUTATION};
+ * `$input: CreateDocInput!` is composed as `{ board: { column_id,
+ * item_id } }` at the action body. Distinct named operation per
+ * verb so the wire-side `operationName` payload mirrors the CLI
+ * verb name verbatim (agents tracing wire traffic can identify the
+ * verb without parsing the doc body).
+ */
+export declare const CREATE_DOC_ON_COLUMN_MUTATION = "\n  mutation CreateDocOnColumn($input: CreateDocInput!) {\n    create_doc(location: $input) {\n      id\n      object_id\n      name\n      doc_kind\n      url\n      relative_url\n      workspace_id\n      workspace { id name }\n      doc_folder_id\n      created_at\n      created_by { id name }\n      updated_at\n      settings\n    }\n  }\n";
+/**
+ * GraphQL mutation document for `update_doc_name(docId, name) →
+ * JSON`. Operation name pinned to `UpdateDocName` (R-NEW-37 W2).
+ * The wire return type is the opaque `JSON` scalar — no selection
+ * set per GraphQL grammar (scalars are leaves). The CLI projects
+ * the opaque value to the flat `{ doc_id, success }` envelope at
+ * the fetcher boundary per D9.
+ *
+ * `docId` + `name` are camelCase on Monday's wire per Finding 7;
+ * the variable names mirror the wire shape verbatim. CLI argv is
+ * `<doc-id>` positional + `--name <n>` flag (kebab-case throughout).
+ */
+export declare const UPDATE_DOC_NAME_MUTATION = "\n  mutation UpdateDocName($docId: ID!, $name: String!) {\n    update_doc_name(docId: $docId, name: $name)\n  }\n";
+/**
+ * GraphQL mutation document for `delete_doc(docId) → JSON`.
+ * Operation name pinned to `DeleteDoc` (R-NEW-37 W2). Wire return
+ * is opaque JSON — same projection cadence as
+ * {@link UPDATE_DOC_NAME_MUTATION}.
+ *
+ * **Destructive-gate ordering.** The verb's action body MUST call
+ * `enforceDestructiveGate` BEFORE this fetcher per the M10 round-1
+ * P2 invariant. A missing `--yes` surfaces as
+ * `confirmation_required` from the action layer, never masked by
+ * `config_error` when no token is configured.
+ */
+export declare const DELETE_DOC_MUTATION = "\n  mutation DeleteDoc($docId: ID!) {\n    delete_doc(docId: $docId)\n  }\n";
+/**
+ * GraphQL mutation document for `duplicate_doc(docId,
+ * duplicateType?) → JSON`. Operation name pinned to `DuplicateDoc`
+ * (R-NEW-37 W2). `duplicateType` is the optional 2-value enum
+ * (see {@link DUPLICATE_TYPE_VALUES}); when omitted at the variable
+ * boundary, Monday's wire-side default (`duplicate_doc_with_content`,
+ * content-only) applies.
+ *
+ * The verb's `--with-updates` boolean argv maps to:
+ * absent → omit the variable entirely (wire default applies);
+ * present → `duplicateType: 'duplicate_doc_with_content_and_updates'`.
+ * The omit-vs-null discipline mirrors M34 `team-create`'s
+ * `is_guest_team` handling — Monday treats a `null` variable as
+ * "field present with null value" rather than "field omitted".
+ *
+ * Wire return is opaque JSON — same projection cadence as the
+ * rename + delete mutations.
+ */
+export declare const DUPLICATE_DOC_MUTATION = "\n  mutation DuplicateDoc($docId: ID!, $duplicateType: DuplicateType) {\n    duplicate_doc(docId: $docId, duplicateType: $duplicateType)\n  }\n";
+export interface CreateDocInWorkspaceInputs {
+    readonly client: MondayClient;
+    readonly workspaceId: string;
+    readonly name: string;
+    readonly folderId?: string;
+    readonly kind?: DocKind;
+}
+export interface CreateDocInWorkspaceResult {
+    readonly document: Document;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Creates a workspace-scoped workdoc via `create_doc(location:
+ * { workspace: {...} })` with `operationName:
+ * 'CreateDocInWorkspace'` (R-NEW-37 W2). Returns the created
+ * Document with `id` populated post-create.
+ *
+ * The fetcher composes `location: { workspace: { workspace_id,
+ * name, folder_id?, kind? } }` from the inputs; `folderId` /
+ * `kind` are omitted entirely from the wire payload when unset
+ * (Monday's per-arg server-side defaults apply — null would be
+ * treated as "field present" rather than "field omitted",
+ * mirroring M34 `createTeam`'s discipline).
+ *
+ * A missing-key wire response surfaces `internal_error` via
+ * `assertResponseFieldPresent`; a null payload surfaces
+ * `internal_error` too — a successful `create_doc` mutation must
+ * return the created Document per Monday's documented contract.
+ */
+export declare const createDocInWorkspace: (inputs: CreateDocInWorkspaceInputs) => Promise<CreateDocInWorkspaceResult>;
+export interface CreateDocOnColumnInputs {
+    readonly client: MondayClient;
+    readonly itemId: string;
+    readonly columnId: string;
+}
+export interface CreateDocOnColumnResult {
+    readonly document: Document;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Creates an item-scoped workdoc via `create_doc(location:
+ * { board: {...} })` with `operationName: 'CreateDocOnColumn'`
+ * (R-NEW-37 W2). Returns the created Document; the doc is
+ * embedded into the named column of the named item.
+ *
+ * The fetcher composes `location: { board: { column_id, item_id
+ * } }` from the inputs. Both slots are required on Monday's wire
+ * (`CreateDocBoardInput.column_id!` + `CreateDocBoardInput.
+ * item_id!`); the CLI verb's `--item <iid>` + `--column <cid>`
+ * flags are both required at the parse boundary.
+ *
+ * Failure modes mirror the workspace variant: missing-key
+ * response → `internal_error`; null payload → `internal_error`;
+ * column not configured for docs → `validation_failed` (Monday-
+ * side rejection — the CLI doesn't pre-check column-type
+ * compatibility, mirroring M8's `change_column_value` cadence).
+ */
+export declare const createDocOnColumn: (inputs: CreateDocOnColumnInputs) => Promise<CreateDocOnColumnResult>;
+export interface RenameDocInputs {
+    readonly client: MondayClient;
+    readonly docId: string;
+    readonly name: string;
+}
+export interface RenameDocResult {
+    readonly result: DocMutationResult;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Renames a workdoc via `update_doc_name(docId, name)` with
+ * `operationName: 'UpdateDocName'` (R-NEW-37 W2). Projects
+ * Monday's opaque JSON return into the flat
+ * `{ doc_id: <echoed>, success: true }` envelope per D9.
+ *
+ * Failure modes:
+ *
+ *   - **Missing `update_doc_name` key** → `internal_error` via
+ *     `assertResponseFieldPresent` (schema drift — Monday's
+ *     response shape regressed).
+ *   - **Present-but-null payload** → projected as success (the
+ *     `{doc_id, success: true}` envelope). Monday's probe
+ *     description for `update_doc_name` carries NO "returns X"
+ *     prose (unlike `delete_doc` which promises "success status
+ *     and the deleted document ID"), so a null wire payload is a
+ *     plausible empty-success indicator. If Monday returns a
+ *     typed error for non-existent doc IDs, that bubbles via
+ *     GraphQL `errors[]` (mapped to typed `ApiError`s upstream) —
+ *     a present-but-null JSON return reaching this projection is
+ *     by construction the success path. Distinct from
+ *     `deleteDoc` + `duplicateDoc` cadence which DO treat null
+ *     as `not_found` because their probe descriptions explicitly
+ *     promise a non-null return payload on success.
+ *   - **Typed Monday errors** (forbidden / not_found from a wire-
+ *     side `errors[]`) → bubble through the transport's error-
+ *     mapping layer.
+ */
+export declare const renameDoc: (inputs: RenameDocInputs) => Promise<RenameDocResult>;
+export interface DeleteDocInputs {
+    readonly client: MondayClient;
+    readonly docId: string;
+}
+export interface DeleteDocResult {
+    readonly result: DocMutationResult;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Deletes a workdoc by ID via `delete_doc(docId)` with
+ * `operationName: 'DeleteDoc'` (R-NEW-37 W2). Projects Monday's
+ * opaque JSON return into the flat `{ doc_id: <echoed>,
+ * success: true }` envelope per D9.
+ *
+ * A null `delete_doc` payload surfaces `not_found` — same
+ * cadence as M34 team-delete + M14 workspace-delete. A missing
+ * key surfaces `internal_error`.
+ *
+ * **Destructive-gate ordering.** The verb's action body MUST
+ * call `enforceDestructiveGate` BEFORE this fetcher per the
+ * M10 round-1 P2 invariant. A missing `--yes` surfaces as
+ * `confirmation_required` from the action layer, never masked
+ * by `config_error` when no token is configured.
+ */
+export declare const deleteDoc: (inputs: DeleteDocInputs) => Promise<DeleteDocResult>;
+export interface DuplicateDocInputs {
+    readonly client: MondayClient;
+    readonly docId: string;
+    readonly duplicateType?: DuplicateType;
+}
+export interface DuplicateDocResult {
+    readonly result: DocMutationResult;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Duplicates a workdoc by ID via `duplicate_doc(docId,
+ * duplicateType?)` with `operationName: 'DuplicateDoc'`
+ * (R-NEW-37 W2). Projects Monday's opaque JSON return into the
+ * flat `{ doc_id: <NEW>, success: true }` envelope per D9 — the
+ * `doc_id` slot carries the **newly-created duplicate's id**,
+ * NOT the input source-doc id (the source id stays accessible
+ * via the verb's positional argv).
+ *
+ * The fetcher omits the `duplicateType` variable entirely when
+ * `inputs.duplicateType` is unset so Monday's wire-side default
+ * applies (the M34 `team-create` omit-vs-null discipline). A
+ * null `duplicate_doc` payload surfaces `not_found` (source
+ * doc id bogus or inaccessible); missing key surfaces
+ * `internal_error`. The new-id extraction tolerates several
+ * common shapes Monday's opaque JSON might carry (bare string,
+ * `{id}`, `{doc_id}`, `{new_doc_id}`) — anything else surfaces
+ * `internal_error` with a re-probe hint.
+ */
+export declare const duplicateDoc: (inputs: DuplicateDocInputs) => Promise<DuplicateDocResult>;
+/**
+ * Monday's `DocBlockContentType` enum vocabulary (empirical probe
+ * 2026-05-15, API `2026-01`; 16 closed values per Finding 8). Pinned
+ * at M36 pre-flight as a closed literal-union enum so unknown
+ * `--type` values reject at the argv-parse boundary with
+ * `usage_error.details.issues[]` (D10 closure).
+ *
+ * Adding a 17th value to Monday's enum is a minor (additive) bump
+ * for the CLI — extend this list + the per-command flag help; the
+ * per-block content schema documentation in `docs/output-shapes.md`
+ * "Per-block content shapes" reference table gains a new row for
+ * the new variant once a live cassette pins its shape (extending
+ * the table is additive at any future v0.5.x patch).
+ */
+export declare const DOC_BLOCK_CONTENT_TYPE_VALUES: readonly ["bulleted_list", "check_list", "code", "divider", "image", "large_title", "layout", "medium_title", "normal_text", "notice_box", "numbered_list", "page_break", "quote", "small_title", "table", "video"];
+export type DocBlockContentType = (typeof DOC_BLOCK_CONTENT_TYPE_VALUES)[number];
+export declare const docBlockContentTypeSchema: z.ZodEnum<{
+    code: "code";
+    table: "table";
+    bulleted_list: "bulleted_list";
+    check_list: "check_list";
+    divider: "divider";
+    image: "image";
+    large_title: "large_title";
+    layout: "layout";
+    medium_title: "medium_title";
+    normal_text: "normal_text";
+    notice_box: "notice_box";
+    numbered_list: "numbered_list";
+    page_break: "page_break";
+    quote: "quote";
+    small_title: "small_title";
+    video: "video";
+}>;
+/**
+ * `DocumentBlockIdOnly` projection — Monday's `delete_doc_block`
+ * mutation return shape per the v0.5 empirical probe. Single-field
+ * OBJECT carrying only the deleted block's id; the wire description
+ * is "A monday.com doc block" but introspection pins exactly one
+ * field. Mirrors `DocumentBlock.id`'s `String!` shape (non-empty,
+ * opaque).
+ */
+export declare const documentBlockIdOnlySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>;
+export type DocumentBlockIdOnly = z.infer<typeof documentBlockIdOnlySchema>;
+/**
+ * Output shape for `monday doc block-create <doc-id> --type <t>
+ * --content <json> [--after <bid>] [--parent <bid>]`. Direct unwrap
+ * of the created DocumentBlock — `data: <DocumentBlock>` per cli-
+ * design §6.1 single-record convention. The 9-field `DocumentBlock`
+ * schema reused from {@link documentBlockSchema} (M32's `doc get`
+ * blocks-hydration leg).
+ */
+export declare const docBlockCreateOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodNullable<z.ZodString>;
+    content: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+    position: z.ZodNullable<z.ZodNumber>;
+    parent_block_id: z.ZodNullable<z.ZodString>;
+    doc_id: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodNullable<z.ZodString>;
+    created_by: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    updated_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type DocBlockCreateOutput = DocumentBlock;
+/**
+ * Output shape for `monday doc block-update <block-id> --content
+ * <json>`. Same 9-field `DocumentBlock` shape as block-create —
+ * Monday's wire returns the updated block with content / type /
+ * position / parent_block_id all reflecting post-update state.
+ */
+export declare const docBlockUpdateOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodNullable<z.ZodString>;
+    content: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+    position: z.ZodNullable<z.ZodNumber>;
+    parent_block_id: z.ZodNullable<z.ZodString>;
+    doc_id: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodNullable<z.ZodString>;
+    created_by: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    updated_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type DocBlockUpdateOutput = DocumentBlock;
+/**
+ * Output shape for `monday doc block-delete <block-id> --yes`.
+ * Single-field `{id: <echoed-block-id>}` projection from Monday's
+ * `DocumentBlockIdOnly` wire return — agents key off the echoed id
+ * for retry/idempotency reasoning. Envelope is intentionally
+ * narrower than the create/update variants because Monday's
+ * `delete_doc_block` wire only returns the id (NOT the full
+ * pre-delete block); the agent contract doesn't gain from
+ * speculatively rehydrating the block on the way out.
+ */
+export declare const docBlockDeleteOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>;
+export type DocBlockDeleteOutput = DocumentBlockIdOnly;
+/**
+ * GraphQL mutation document for `create_doc_block(doc_id, type,
+ * content, after_block_id?, parent_block_id?) → DocumentBlock`.
+ * Operation name pinned literally to `CreateDocBlock` (R-NEW-37
+ * W2 audit-point — operationNames NOT caller-overridable). Wire
+ * args are snake_case (Finding 7); variable names are camelCase
+ * (TS convention).
+ *
+ * Selects every `DocumentBlock` field per the M32 probe. The 9-
+ * field selection matches the `doc get` blocks-hydration leg so a
+ * future create-then-get pipeline can compare envelopes byte-for-
+ * byte.
+ */
+export declare const CREATE_DOC_BLOCK_MUTATION = "\n  mutation CreateDocBlock(\n    $docId: ID!,\n    $type: DocBlockContentType!,\n    $content: JSON!,\n    $afterBlockId: String,\n    $parentBlockId: String\n  ) {\n    create_doc_block(\n      doc_id: $docId,\n      type: $type,\n      content: $content,\n      after_block_id: $afterBlockId,\n      parent_block_id: $parentBlockId\n    ) {\n      id\n      type\n      content\n      position\n      parent_block_id\n      doc_id\n      created_at\n      created_by { id name }\n      updated_at\n    }\n  }\n";
+/**
+ * GraphQL mutation document for `update_doc_block(block_id,
+ * content) → DocumentBlock`. Operation name pinned to
+ * `UpdateDocBlock` (R-NEW-37 W2). Same 9-field `DocumentBlock`
+ * selection as the create variant — Monday's wire returns the
+ * full post-update block, not just a delta.
+ *
+ * No `--type` slot on `update_doc_block` (Monday's wire signature
+ * has no `type` arg); agents that need to switch a block's content
+ * type must `block-delete` + `block-create` (lossy: new id, new
+ * position). The CLI surface mirrors the wire constraint exactly
+ * — no client-side "change type" shim that papers over the
+ * destructive recreate.
+ */
+export declare const UPDATE_DOC_BLOCK_MUTATION = "\n  mutation UpdateDocBlock($blockId: String!, $content: JSON!) {\n    update_doc_block(block_id: $blockId, content: $content) {\n      id\n      type\n      content\n      position\n      parent_block_id\n      doc_id\n      created_at\n      created_by { id name }\n      updated_at\n    }\n  }\n";
+/**
+ * GraphQL mutation document for `delete_doc_block(block_id) →
+ * DocumentBlockIdOnly`. Operation name pinned to `DeleteDocBlock`
+ * (R-NEW-37 W2). Single-field selection — Monday's wire return is
+ * `DocumentBlockIdOnly` (`{id: String!}`).
+ *
+ * **Destructive-gate ordering.** The verb's action body MUST call
+ * `enforceDestructiveGate` BEFORE this fetcher per the M10 round-1
+ * P2 invariant. A missing `--yes` surfaces as
+ * `confirmation_required` from the action layer, never masked by
+ * `config_error` when no token is configured.
+ */
+export declare const DELETE_DOC_BLOCK_MUTATION = "\n  mutation DeleteDocBlock($blockId: String!) {\n    delete_doc_block(block_id: $blockId) {\n      id\n    }\n  }\n";
+export interface CreateDocBlockInputs {
+    readonly client: MondayClient;
+    readonly docId: string;
+    readonly type: DocBlockContentType;
+    /**
+     * Per-block content payload. Shape varies per
+     * {@link DocBlockContentType} value — Monday's wire is the source
+     * of truth for what each variant accepts; the CLI passes the JS
+     * value through to the wire `JSON` scalar unmodified. Per-type
+     * structure pinned by `docs/output-shapes.md` "Per-block content
+     * shapes" reference table (cassette-sourced rows + TBD / inferred
+     * rows pending live-probe cassettes).
+     */
+    readonly content: unknown;
+    /**
+     * Optional anchor block — newly-created block lands immediately
+     * after `afterBlockId` in the doc body order. Absent → block
+     * inserted at the document head (Monday's `create_doc_block`
+     * default per probe description: "If not provided, will be
+     * inserted first in the document").
+     */
+    readonly afterBlockId?: string;
+    /**
+     * Optional parent block — newly-created block nests under
+     * `parentBlockId` (for layout / nested-list variants where
+     * Monday supports parent/child block relationships per
+     * `DocumentBlock.parent_block_id`). Absent → block lands at the
+     * document root level.
+     */
+    readonly parentBlockId?: string;
+}
+export interface CreateDocBlockResult {
+    readonly block: DocumentBlock;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Creates a per-doc rich-text block via `create_doc_block(doc_id,
+ * type, content, after_block_id?, parent_block_id?)` with
+ * `operationName: 'CreateDocBlock'` (R-NEW-37 W2). Two-stage parse
+ * mirrors M34 / M35 cadence: the loose wrapping schema tolerates
+ * Monday's side-band debug keys, then the inner OBJECT pins via
+ * {@link documentBlockSchema} so per-field drift surfaces with
+ * structured `details.issues`.
+ *
+ * Failure modes:
+ *
+ *   - **Missing `create_doc_block` key** → `internal_error` via
+ *     `assertResponseFieldPresent` (Monday's response shape
+ *     regressed).
+ *   - **Present-but-null payload** → `internal_error` (a successful
+ *     `create_doc_block` mutation must return the created block per
+ *     Monday's documented contract — null indicates a wire-shape
+ *     regression worth surfacing loudly; distinct from
+ *     {@link updateDocBlock} / {@link deleteDocBlock} which treat
+ *     null as `not_found` per their probe-description-derived
+ *     contracts at R-v0.5-NEW-11).
+ *   - **Inner OBJECT drift** → `internal_error` via `unwrapOrThrow`
+ *     on {@link documentBlockSchema} (per-field shape regression).
+ *
+ * Omits `afterBlockId` / `parentBlockId` variables when unset so
+ * Monday's wire-side defaults apply (the M34 / M35 omit-vs-null
+ * discipline — undefined-keyed JSON serialises to a missing key,
+ * NOT `null`).
+ */
+export declare const createDocBlock: (inputs: CreateDocBlockInputs) => Promise<CreateDocBlockResult>;
+export interface UpdateDocBlockInputs {
+    readonly client: MondayClient;
+    readonly blockId: string;
+    /**
+     * Per-block content payload. Same shape contract as
+     * {@link CreateDocBlockInputs.content} — opaque JS value passed
+     * through to Monday's wire `JSON` scalar. Per-type structure
+     * pinned by `docs/output-shapes.md` "Per-block content shapes"
+     * reference table from M36 IMPL cassettes.
+     */
+    readonly content: unknown;
+}
+export interface UpdateDocBlockResult {
+    readonly block: DocumentBlock;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Updates a per-doc rich-text block's content via
+ * `update_doc_block(block_id, content)` with `operationName:
+ * 'UpdateDocBlock'` (R-NEW-37 W2). No type-switching slot on the
+ * wire — agents needing to change a block's content type
+ * `block-delete` + `block-create` (lossy: new id, new position).
+ *
+ * Failure modes:
+ *
+ *   - **Missing `update_doc_block` key** → `internal_error` via
+ *     `assertResponseFieldPresent` (schema drift).
+ *   - **Present-but-null payload** → `not_found` (the probe
+ *     description "Update a document block" promises the updated
+ *     block on success, so null reads as missing-record — block
+ *     bogus or not visible to the token; per R-v0.5-NEW-11
+ *     per-fetcher null-payload discipline).
+ *   - **Inner OBJECT drift** → `internal_error` via `unwrapOrThrow`
+ *     on {@link documentBlockSchema}.
+ */
+export declare const updateDocBlock: (inputs: UpdateDocBlockInputs) => Promise<UpdateDocBlockResult>;
+export interface DeleteDocBlockInputs {
+    readonly client: MondayClient;
+    readonly blockId: string;
+}
+export interface DeleteDocBlockResult {
+    readonly block: DocumentBlockIdOnly;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Deletes a per-doc rich-text block via `delete_doc_block(block_id)`
+ * with `operationName: 'DeleteDocBlock'` (R-NEW-37 W2). Wire return
+ * is `DocumentBlockIdOnly` (`{id: String!}`).
+ *
+ * Failure modes:
+ *
+ *   - **Missing `delete_doc_block` key** → `internal_error` via
+ *     `assertResponseFieldPresent` (schema drift).
+ *   - **Present-but-null payload** → `not_found` (id bogus or
+ *     block already deleted by a concurrent caller; mirrors M14
+ *     workspace-delete + M34 team-delete + M35 doc-delete cadence;
+ *     `delete_doc_block`'s probe description "Delete a document
+ *     block" promises confirmation on success).
+ *   - **Inner OBJECT drift** → `internal_error` via `unwrapOrThrow`
+ *     on {@link documentBlockIdOnlySchema}.
+ *
+ * The action body's destructive gate fires BEFORE this fetcher per
+ * the M10 round-1 P2 invariant.
+ */
+export declare const deleteDocBlock: (inputs: DeleteDocBlockInputs) => Promise<DeleteDocBlockResult>;
+/**
+ * Maximum byte-size for the inline `--html-string` / `--markdown-string`
+ * payload at the argv-parse boundary (empirical probe 2026-05-17, API
+ * `2026-01`; `scripts/probe/v0.5-m37-size-limits.report.txt`). Set
+ * conservatively at the LAST-KNOWN-GOOD probe size (250KB) — the wire's
+ * first-known-rejection sits at 500KB, so 250KB leaves the agent contract
+ * comfortably below the threshold without leaving room for the wire-side
+ * `INTERNAL_SERVER_ERROR` surprise.
+ *
+ * Bytes (NOT UTF-16 code units) — the parse-boundary check measures the
+ * payload via `Buffer.byteLength(payload, 'utf8')` so multi-byte
+ * characters in the payload count toward the limit the same way Monday's
+ * transport layer sees them.
+ *
+ * Raising this constant is a contract bump: any agent that relied on
+ * being rejected at the old limit might now silently succeed with a
+ * larger payload (additive change). Lowering it is a tighter rejection
+ * surface (potentially breaking — fold into a Codex review at the v0.6+
+ * pre-flight that touches doc-content import). Future API versions may
+ * shift Monday's wire threshold; re-running the probe at any v0.5.x or
+ * v0.6 pre-flight that re-opens this surface pins the new threshold.
+ */
+export declare const MAX_DOC_IMPORT_PAYLOAD_BYTES = 256000;
+/**
+ * Inner OBJECT schema for `import_doc_from_html`'s
+ * `ImportDocFromHtmlResult` wire return shape — 3 fields per the
+ * v0.5 introspection probe (`scripts/probe/v0.5-inputs-and-results.
+ * report.txt`):
+ *
+ *   - `success: Boolean!` — discriminator; pinned NON_NULL per
+ *     introspection.
+ *   - `doc_id: String` — nullable; populated on `success: true`,
+ *     null on `success: false` per Monday's documented contract.
+ *     Note Monday's wire types this slot as `String` (NOT `ID`!)
+ *     despite the value being a doc-id-shaped reference. The CLI
+ *     surfaces it as a brand-untyped string at the wire layer; the
+ *     CLI projection envelope re-brands via {@link DocIdSchema} on
+ *     the way out so agents read a `DocId`-shaped slot.
+ *   - `error: String` — nullable; populated on `success: false`,
+ *     null on `success: true`. Wire-side rejection reason (invalid
+ *     HTML, payload-too-large, etc.).
+ *
+ * `.strict()` mode — Monday's wire OBJECT shape is documented at
+ * exactly 3 fields; an unknown key would indicate wire-shape
+ * regression worth catching loudly (the wrapping `loose()` schema
+ * tolerates side-band debug keys at the response root, not at the
+ * inner OBJECT layer).
+ */
+export declare const importDocFromHtmlResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    doc_id: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ImportDocFromHtmlResult = z.infer<typeof importDocFromHtmlResultSchema>;
+/**
+ * Inner OBJECT schema for `add_content_to_doc_from_markdown`'s
+ * `DocBlocksFromMarkdownResult` wire return shape — 3 fields per the
+ * v0.5 introspection probe:
+ *
+ *   - `success: Boolean!` — discriminator; NON_NULL.
+ *   - `block_ids: [String!]` — nullable LIST of NON_NULL strings;
+ *     populated on `success: true` with the newly-created block
+ *     ids (one per parsed markdown block); null on `success:
+ *     false`. EMPTY array on success is plausible for non-empty
+ *     markdown that Monday parses to zero convertible blocks (e.g.
+ *     comments-only input); the schema accepts empty. Empty /
+ *     whitespace-only `--markdown-string` rejects at the parse /
+ *     read boundary as `usage_error` and never reaches the wire.
+ *   - `error: String` — nullable; populated on `success: false`,
+ *     null on `success: true`.
+ *
+ * `.strict()` mode for the same reason as
+ * {@link importDocFromHtmlResultSchema}.
+ */
+export declare const docBlocksFromMarkdownResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    block_ids: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type DocBlocksFromMarkdownResult = z.infer<typeof docBlocksFromMarkdownResultSchema>;
+/**
+ * CLI projection envelope for `monday doc import-html` — flat
+ * `{ doc_id, success: true }` shape mirroring M35's
+ * {@link docMutationResultSchema} cadence so agents read a uniform
+ * `{ doc_id, success }` shape across every doc-mutation success
+ * envelope (rename / delete / duplicate / import-html). `doc_id`
+ * carries the **NEWLY-CREATED** doc's id; `success` is literal-
+ * `true` because failure paths throw typed `ApiError`s
+ * (`validation_failed` for `success: false + error` per D12 / null
+ * for wire regression) BEFORE this projection schema is referenced.
+ *
+ * No `error` slot — failures don't reach this envelope. Agents read
+ * `error.code` + `error.details.error` from the failure envelope
+ * instead.
+ */
+export declare const docImportHtmlOutputSchema: z.ZodObject<{
+    doc_id: z.ZodString;
+    success: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type DocImportHtmlOutput = z.infer<typeof docImportHtmlOutputSchema>;
+/**
+ * CLI projection envelope for `monday doc append-markdown` —
+ * `{ doc_id (echoed input), block_ids, success: true }`. Echoes
+ * the input source-doc id so agents that pipe the append envelope
+ * into a follow-up call (e.g. a `monday doc get <doc-id>` to verify
+ * post-append state) have the parent doc context inline.
+ * `block_ids` carries the wire's full list of NEWLY-CREATED block
+ * ids (one per parsed markdown block) preserved in markdown-source
+ * order. Empty array IS a valid success shape for non-empty markdown
+ * that Monday parses to zero convertible blocks (e.g. comments-only
+ * input); empty / whitespace-only `--markdown-string` rejects at the
+ * parse / read boundary as `usage_error` and never reaches the wire.
+ *
+ * `success` is literal-`true` for the same reason as
+ * {@link docImportHtmlOutputSchema}.
+ */
+export declare const docAppendMarkdownOutputSchema: z.ZodObject<{
+    doc_id: z.ZodString;
+    block_ids: z.ZodArray<z.ZodString>;
+    success: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type DocAppendMarkdownOutput = z.infer<typeof docAppendMarkdownOutputSchema>;
+/**
+ * GraphQL mutation document for `import_doc_from_html(html,
+ * workspaceId, kind?, folderId?, title?) → ImportDocFromHtmlResult`.
+ * Operation name pinned literally to `ImportDocFromHtml` (R-NEW-37
+ * W2 audit-point — operationNames NOT caller-overridable). All wire
+ * args are camelCase (Finding 7); variable names match the wire
+ * shape verbatim.
+ *
+ * Selects every `ImportDocFromHtmlResult` field per the introspection
+ * probe — the 3-field selection lets the fetcher project the
+ * discriminator + payload + error in a single round-trip.
+ */
+export declare const IMPORT_DOC_FROM_HTML_MUTATION = "\n  mutation ImportDocFromHtml(\n    $html: String!,\n    $workspaceId: ID!,\n    $kind: DocKind,\n    $folderId: ID,\n    $title: String\n  ) {\n    import_doc_from_html(\n      html: $html,\n      workspaceId: $workspaceId,\n      kind: $kind,\n      folderId: $folderId,\n      title: $title\n    ) {\n      success\n      doc_id\n      error\n    }\n  }\n";
+/**
+ * GraphQL mutation document for `add_content_to_doc_from_markdown(
+ * docId, markdown, afterBlockId?) → DocBlocksFromMarkdownResult`.
+ * Operation name pinned to `AddContentToDocFromMarkdown` (R-NEW-37
+ * W2). camelCase wire arg names (Finding 7).
+ *
+ * `afterBlockId` is the optional opaque block-id positional anchor —
+ * Monday inserts the parsed markdown blocks immediately after the
+ * named block; absent → blocks land at the document tail (append-end
+ * semantics, NOT append-head; Monday's probe description: "Use this
+ * to append content to the end of a document or insert content after
+ * a specific block").
+ */
+export declare const ADD_CONTENT_TO_DOC_FROM_MARKDOWN_MUTATION = "\n  mutation AddContentToDocFromMarkdown(\n    $docId: ID!,\n    $markdown: String!,\n    $afterBlockId: String\n  ) {\n    add_content_to_doc_from_markdown(\n      docId: $docId,\n      markdown: $markdown,\n      afterBlockId: $afterBlockId\n    ) {\n      success\n      block_ids\n      error\n    }\n  }\n";
+export interface ImportDocFromHtmlInputs {
+    readonly client: MondayClient;
+    readonly html: string;
+    readonly workspaceId: string;
+    /**
+     * Optional doc-kind enum (`public` / `private` / `share`) — maps
+     * to wire `kind: DocKind`. Absent → omitted from the wire payload
+     * (Monday's wire-side default "public" applies per the probe
+     * description: "Defaults to 'public' if not specified").
+     */
+    readonly kind?: DocKind;
+    /**
+     * Optional folder id — maps to wire `folderId: ID`. Absent →
+     * omitted; Monday creates the doc at the workspace root level per
+     * the probe description: "If not provided, the document will be
+     * created at the root level of the workspace".
+     */
+    readonly folderId?: string;
+    /**
+     * Optional title — maps to wire `title: String`. Absent → omitted;
+     * Monday infers the title from the HTML content per the probe
+     * description: "If not provided, the title will be inferred from
+     * the HTML content".
+     */
+    readonly title?: string;
+}
+export interface ImportDocFromHtmlActionResult {
+    readonly result: DocImportHtmlOutput;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Imports an HTML payload as a new workdoc via
+ * `import_doc_from_html(html, workspaceId, kind?, folderId?, title?)`
+ * with `operationName: 'ImportDocFromHtml'` (R-NEW-37 W2 — pinned
+ * literally at the call site; NOT a caller-overridable input slot).
+ *
+ * Two-stage parse: the loose {@link importDocFromHtmlResponseSchema}
+ * wrapping schema tolerates side-band keys at the response root;
+ * `assertResponseFieldPresent` rewraps a missing key as
+ * `internal_error`; the inner OBJECT pins via
+ * {@link importDocFromHtmlResultSchema} (`.strict()` — drift surfaces
+ * `internal_error` with structured `details.issues`).
+ *
+ * Custom-OBJECT projection per D12 (5 branches):
+ *
+ *   - `success: true + doc_id present` → flat envelope
+ *     `{doc_id, success: true}` (mirrors M35
+ *     {@link docMutationResultSchema} cadence).
+ *   - `success: false + populated error` → throw `validation_failed`
+ *     with `details: {workspace_id, error, hint}` (Monday-side
+ *     rejection — invalid HTML, payload too large, etc.).
+ *   - `success: false + empty/null error` → throw `internal_error`
+ *     with a wire-regression hint (Monday's contract: `error` is
+ *     populated when `success: false`).
+ *   - `success: true + missing doc_id` → throw `internal_error`
+ *     (per-fetcher null-payload contract derived from Monday's probe
+ *     description "Returns the ID of the newly created document on
+ *     success" per R-v0.5-NEW-11).
+ *   - `success: true + null doc_id` → same as missing — wire-side
+ *     regression on the documented payload promise.
+ *
+ * Omits optional variables (`kind` / `folderId` / `title`) entirely
+ * when unset so Monday's per-arg server-side defaults apply (the M34 /
+ * M35 / M36 omit-vs-null discipline — undefined-keyed JSON serialises
+ * to a missing key, NOT `null`).
+ */
+export declare const importDocFromHtml: (inputs: ImportDocFromHtmlInputs) => Promise<ImportDocFromHtmlActionResult>;
+export interface AddContentToDocFromMarkdownInputs {
+    readonly client: MondayClient;
+    readonly docId: string;
+    readonly markdown: string;
+    /**
+     * Optional opaque block-id anchor — Monday inserts the parsed
+     * markdown blocks immediately after `afterBlockId` in the doc body
+     * order. Absent → blocks land at the document tail (append-end
+     * semantics per Monday's probe description).
+     */
+    readonly afterBlockId?: string;
+}
+export interface AddContentToDocFromMarkdownActionResult {
+    readonly result: DocAppendMarkdownOutput;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Appends parsed-markdown blocks to an existing workdoc via
+ * `add_content_to_doc_from_markdown(docId, markdown, afterBlockId?)`
+ * with `operationName: 'AddContentToDocFromMarkdown'` (R-NEW-37 W2).
+ *
+ * Two-stage parse: the loose
+ * {@link addContentToDocFromMarkdownResponseSchema} wrapping schema
+ * tolerates side-band keys; `assertResponseFieldPresent` rewraps a
+ * missing key as `internal_error`; the inner OBJECT pins via
+ * {@link docBlocksFromMarkdownResultSchema}.
+ *
+ * Custom-OBJECT projection per D12 (5 branches):
+ *
+ *   - `success: true + block_ids present (incl. EMPTY array)` →
+ *     success envelope `{doc_id (echoed), block_ids, success: true}`.
+ *     Empty `block_ids: []` IS a valid success shape per probe
+ *     finding — for non-empty markdown that Monday parses to zero
+ *     convertible blocks (e.g. comments-only payload Monday
+ *     collapses to zero structural blocks). Empty / whitespace-only
+ *     input is rejected at the parse / read boundary by
+ *     {@link readSourceContent}, so it can never reach this fetcher.
+ *   - `success: false + populated error` → throw `validation_failed`
+ *     with `details: {doc_id, error, hint}`.
+ *   - `success: false + empty/null error` → throw `internal_error`
+ *     with wire-regression hint.
+ *   - `success: true + null block_ids` → throw `internal_error`
+ *     (per-fetcher null-payload contract per R-v0.5-NEW-11 — Monday's
+ *     probe description "Returns the IDs of the newly created blocks
+ *     on success" promises a non-null array).
+ *
+ * Omits `afterBlockId` when undefined (M34 / M35 / M36 omit-vs-null
+ * discipline).
+ */
+export declare const addContentToDocFromMarkdown: (inputs: AddContentToDocFromMarkdownInputs) => Promise<AddContentToDocFromMarkdownActionResult>;
 //# sourceMappingURL=documents.d.ts.map