monday-cli 0.3.0 → 0.5.0

package/dist/api/documents.d.ts

@@ -0,0 +1,1652 @@
+/**
+ * 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(...)`:
+ *
+ *   - **List variant** — `Query.docs(workspace_ids: [ID],
+ *     order_by: DocsOrderBy, limit: Int, page: Int) → [Document]`.
+ *     Page/limit pagination (NOT cursor — Monday's workdocs surface
+ *     has no `items_page`-style cursor). Default `limit: 25` on the
+ *     wire side; CLI caps `--limit` at `MAX_DOC_LIST_LIMIT = 100`
+ *     to keep response sizes bounded (each Document is rich-text
+ *     plus metadata, and a `--limit 500` request could blow past
+ *     Monday's complexity budget on doc-heavy accounts). `--page`
+ *     is 1-based.
+ *   - **Get variant** — `Query.docs(ids: [ID!]) → [Document]` with
+ *     the per-doc `blocks` selection hydrated. Returns at most one
+ *     Document (single-id list). The CLI extracts the singleton
+ *     index 0; an empty array surfaces `not_found` (D8 — Monday's
+ *     wire collapses doesn't-exist + not-accessible into the same
+ *     shape), while a null `docs` root surfaces `internal_error`
+ *     with a drift hint (Monday's documented shape is `[Document]`,
+ *     possibly empty, never null — null indicates wire-shape
+ *     regression worth surfacing loudly). The
+ *     `Document.blocks: [DocumentBlock]` selection adds significant
+ *     payload, which is why `doc list` ships WITHOUT `blocks` and
+ *     `doc get` is the per-doc body-hydrating path.
+ *
+ * **`Document` object — 14 fields.** Per the M32 empirical probe:
+ * `id` (ID!), `object_id` (ID!), `blocks` ([DocumentBlock]; null
+ * unless hydrated), `created_at` (Date, nullable), `created_by`
+ * (User, nullable — projected to the slim `{id, name}` shape for
+ * envelope compactness), `doc_folder_id` (ID, nullable),
+ * `doc_kind` (BoardKind!, returning `'public'`/`'private'`/
+ * `'share'` per the DocKind probe at API `2026-01` — non-null on
+ * the wire; the standalone `DocKind` enum exists but isn't
+ * returned by `Document.doc_kind`), `name` (String!),
+ * `relative_url` (String, nullable),
+ * `settings` (JSON, nullable), `updated_at` (Date, nullable),
+ * `url` (String, nullable absolute URL), `workspace` (Workspace,
+ * nullable — projected to `{id, name}`), `workspace_id` (ID,
+ * nullable). The `object_id` is Monday's internal opaque object
+ * identifier (distinct from `id`); both flow through verbatim.
+ *
+ * **BoardKind reuse for `Document.doc_kind`.** Monday's wire schema
+ * types `Document.doc_kind` as `BoardKind!` (NOT `DocKind!`) — the
+ * `BoardKind` enum is reused across `Board.kind` and
+ * `Document.doc_kind`, returning the same three string values
+ * (`public`/`private`/`share`). The standalone `DocKind` enum exists
+ * on the schema but isn't returned by `Document.doc_kind`; it's a
+ * wire-side detail with no agent-visible asymmetry (the CLI surface
+ * mirrors the wire string values verbatim). Not a new R-NEW-41
+ * consumer — the wire-vs-CLI projection is symmetric.
+ *
+ * **`DocumentBlock` — 9 fields.** Per the M32 probe: `id` (String!),
+ * `type` (String, nullable — block type like `'text'` / `'heading'`
+ * / `'list'` / etc., values stay verbatim from Monday's wire),
+ * `content` (JSON, nullable — block payload), `position` (Float,
+ * nullable — fractional ordering within doc), `parent_block_id`
+ * (String, nullable — for nested blocks), `doc_id` (ID, nullable),
+ * `created_at` (Date, nullable), `created_by` (User, nullable —
+ * projected to slim `{id, name}`), `updated_at` (Date, nullable).
+ * Block-content schema validity is NOT cross-checked by the CLI;
+ * Monday's wire is the source of truth for what blocks look like.
+ *
+ * **`DocsOrderBy` enum — 2 values.** `created_at` (most-recently-
+ * created first; Monday's documented `desc` ordering) and `used_at`
+ * (most-recently-viewed-by-current-user first; also `desc`). No
+ * ascending variant on Monday's wire — agents that need ascending
+ * sort the projection client-side. Default CLI behaviour: `created_
+ * at` (matches Monday's wire default at API `2026-01`).
+ *
+ * **No new ERROR_CODES (29 stays — D8 closure).** Doc-read failures
+ * route through existing codes:
+ *
+ *   - `not_found` — `doc get <did>` against a non-existent or
+ *     inaccessible doc ID. Monday's wire returns an empty `docs`
+ *     array for both "doesn't exist" and "exists but token can't
+ *     read it"; the CLI surfaces both as `not_found` with
+ *     `details.doc_id`.
+ *   - `usage_error` — argv-parse rejections (out-of-range `--limit`
+ *     / `--page`, malformed `--workspace`, unknown `--order-by`).
+ *     Caught at parse boundary BEFORE any wire call.
+ *   - `validation_failed` — Monday-side rejection (very rare for
+ *     reads; included for completeness).
+ *   - `forbidden` / `unauthorized` — token lacks workdoc read scope.
+ *
+ * **Docs are live-only at v0.4-M32.** Per cli-design §8 cache scope,
+ * workdocs aren't cached — the `doc list` + `doc get` paths emit
+ * `meta.source: "live"` with `cache_age_seconds: null`. Workdocs
+ * are content-heavy + frequently human-edited, so caching would
+ * regularly surface stale prose. Mirrors `monday usage` (M22) +
+ * `monday status` (M22) + webhook list (M27) — diagnostics /
+ * volatile surfaces don't cache.
+ *
+ * **Runtime bodies landed at v0.4-M32 IMPL.** `listDocuments` +
+ * `getDocument` each issue a single `client.raw` round-trip with
+ * `operationName: 'ListDocs'` / `'GetDoc'` pinned literally at the
+ * fetcher boundary (R-NEW-37 W2 audit-point — operationNames are
+ * NOT caller-overridable). Responses parse through
+ * {@link documentSchema} / {@link documentWithBlocksSchema} via
+ * `unwrapOrThrow`, so payload drift surfaces `internal_error` with
+ * `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';
+import type { Complexity } from '../utils/output/envelope.js';
+/**
+ * Inclusive range for the `--limit` argv slot on `monday doc list`.
+ * Default `25` matches Monday's wire-side default at API `2026-01`
+ * (per the M32 empirical probe `Query.docs.args.limit.description`:
+ * "Number of items to get, the default is 25"); ceiling `100` keeps
+ * worst-case response sizes bounded for doc-heavy accounts (a
+ * `--limit 500` request would multiply payload across 500 rich-text
+ * Document records, easily blowing Monday's complexity budget).
+ */
+export declare const MIN_DOC_LIST_LIMIT = 1;
+export declare const MAX_DOC_LIST_LIMIT = 100;
+export declare const DEFAULT_DOC_LIST_LIMIT = 25;
+/**
+ * Monday's `DocsOrderBy` enum vocabulary (empirical probe 2026-05-14,
+ * API `2026-01`; 2 values). Pinned at M32 pre-flight as a closed
+ * literal-union enum so unknown `--order-by` values reject at parse
+ * boundary with `usage_error`.
+ *
+ * Both values sort `desc` on Monday's wire (most-recent first); no
+ * ascending variant is exposed. Adding a third value to Monday's
+ * enum is a minor (additive) bump for the CLI — extend this list +
+ * the per-command flag help.
+ */
+export declare const DOCS_ORDER_BY: readonly ["created_at", "used_at"];
+export type DocsOrderBy = (typeof DOCS_ORDER_BY)[number];
+export declare const docsOrderBySchema: z.ZodEnum<{
+    created_at: "created_at";
+    used_at: "used_at";
+}>;
+export declare const DEFAULT_DOCS_ORDER_BY: DocsOrderBy;
+/**
+ * Slim projection of Monday's `User` for the `Document.created_by` +
+ * `DocumentBlock.created_by` slots. Mirrors the M19 `account_tags`
+ * + M31 `Asset.uploaded_by` slim-User cadence: `{id, name}` only,
+ * keeping envelope size bounded. Full-User reads route through
+ * `monday user get <uid>`.
+ */
+export declare const docUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type DocUser = z.infer<typeof docUserSchema>;
+/**
+ * Slim projection of Monday's `Workspace` for the `Document.workspace`
+ * slot. Same `{id, name}` shape as {@link docUserSchema}. Full-
+ * Workspace reads route through `monday workspace get <wid>`.
+ */
+export declare const docWorkspaceSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type DocWorkspace = z.infer<typeof docWorkspaceSchema>;
+/**
+ * `doc_kind` literal-union enum (3 values per the M32 probe + the
+ * DocKind introspection result). Monday's wire types this field as
+ * `BoardKind!` — see the module header's "BoardKind reuse" note for
+ * the wire-side type-name aliasing. The CLI surface mirrors the
+ * three string values verbatim with no projection drift.
+ */
+export declare const DOC_KIND_VALUES: readonly ["public", "private", "share"];
+export type DocKind = (typeof DOC_KIND_VALUES)[number];
+export declare const docKindSchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+    share: "share";
+}>;
+/**
+ * DocumentBlock projection — Monday's 9-field block shape per the
+ * M32 probe. `content` is `JSON` on the wire (block payload — schema
+ * varies per `type`); the CLI passes it through unmodified as
+ * `unknown` so agents introspect the per-block-type payload
+ * themselves (Monday's wire is the source of truth for the per-
+ * block-type schema).
+ *
+ * Only surfaces under `doc get` envelopes (the per-doc body-hydrating
+ * path); `doc list` envelopes ship Documents WITHOUT `blocks` per
+ * the D6 list-row-projection closure.
+ */
+export declare const documentBlockSchema: 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 DocumentBlock = z.infer<typeof documentBlockSchema>;
+/**
+ * Base Document projection (13 fields — all of Monday's 14 minus
+ * `blocks`). Used as the list-row shape under `doc list` envelopes;
+ * appended with the required `blocks: [DocumentBlock]` slot for
+ * `doc get` envelopes via {@link documentWithBlocksSchema} (the
+ * extension makes `blocks` mandatory — `doc get` always hydrates
+ * the rich-text body per D6).
+ *
+ * `settings` is `JSON` on the wire (per-doc display/sharing config)
+ * — passed through as `unknown` for the same reason
+ * `DocumentBlock.content` is. Agents that need a specific settings
+ * key destructure client-side.
+ */
+export declare const documentSchema: 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 Document = z.infer<typeof documentSchema>;
+/**
+ * `doc get` projection — base Document + the `blocks` slot hydrated.
+ * Same shape as {@link documentSchema} with `blocks:
+ * [DocumentBlock]` appended (Monday's wire returns the block array
+ * directly under `Document.blocks`; the CLI surfaces it verbatim).
+ *
+ * `blocks` is non-null on the wire when the selection is requested;
+ * an empty doc surfaces `blocks: []` rather than `null`. The schema
+ * pins non-null for envelope predictability — an unexpected null
+ * surfaces `internal_error` at the IMPL parse boundary.
+ */
+export declare const documentWithBlocksSchema: 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>>;
+    blocks: z.ZodArray<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>>;
+}, z.core.$strict>;
+export type DocumentWithBlocks = z.infer<typeof documentWithBlocksSchema>;
+/**
+ * Output shape for `monday doc list [--workspace <wid>,...]
+ * [--order-by <created_at|used_at>] [--limit <n>] [--page <n>]`.
+ * Wrapped record (NOT bare array) because page/limit pagination
+ * surfaces pagination context inline rather than via `meta.cursor`
+ * (cli-design §6.1 cursor slot is for items_page-style surfaces;
+ * the workdocs wire has no cursor).
+ *
+ * `documents` — Monday's wire-ordered array (server-applied
+ * `created_at desc` or `used_at desc` per `--order-by`).
+ * `page` / `limit` — echoed inputs confirming what the wire saw.
+ * `returned_count` — `documents.length` cached for agent ergonomics.
+ * `has_more` — heuristic `returned_count === limit`; Monday's wire
+ * doesn't surface a total count, so "exactly `limit` rows returned"
+ * is the only signal that a follow-up page exists. Agents
+ * pessimistically re-fetch with `page + 1` if `has_more: true`.
+ */
+export declare const docListOutputSchema: z.ZodObject<{
+    documents: z.ZodArray<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>>;
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+    returned_count: z.ZodNumber;
+    has_more: z.ZodBoolean;
+}, z.core.$strict>;
+export type DocListOutput = z.infer<typeof docListOutputSchema>;
+/**
+ * Output shape for `monday doc get <did>`. Direct unwrap of the
+ * single Document (with blocks hydrated) — matches the convention
+ * for read-one verbs (`monday board get <bid>` returns `data:
+ * <Board>`, `monday user get <uid>` returns `data: <User>`).
+ *
+ * The Document's own `id` field is the echoed input — no separate
+ * `doc_id` slot needed.
+ */
+export declare const docGetOutputSchema: 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>>;
+    blocks: z.ZodArray<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>>;
+}, z.core.$strict>;
+export type DocGetOutput = DocumentWithBlocks;
+/**
+ * GraphQL query document for `Query.docs(...)` listing variant.
+ * Operation name pinned literally to `ListDocs` and matches the
+ * wire `operationName` payload (R-NEW-37 W2 audit-point — caller-
+ * overridable operationName slots were closed at M27 IMPL round-1
+ * P2-1; M32 maintains the safely-by-construction shape).
+ *
+ * Selects every list-row field (no `blocks` selection — list rows
+ * project the 13-field base shape per D6). `workspace_ids:` typed
+ * as `[ID]` to mirror Monday's wire signature (the inner ID is
+ * nullable on Monday's side — an empirical-probe finding that
+ * doesn't show up in the contract today but stays preserved for
+ * future-proofing).
+ */
+export declare const LIST_DOCS_QUERY = "\n  query ListDocs(\n    $workspaceIds: [ID],\n    $orderBy: DocsOrderBy,\n    $limit: Int,\n    $page: Int\n  ) {\n    docs(\n      workspace_ids: $workspaceIds,\n      order_by: $orderBy,\n      limit: $limit,\n      page: $page\n    ) {\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 query document for `Query.docs(ids:)` single-id read
+ * variant. Operation name pinned to `GetDoc` (R-NEW-37 W2). Selects
+ * all base Document fields plus the `blocks` selection (the per-doc
+ * body-hydrating leg).
+ *
+ * Single-id wire shape — Monday returns `[Document]` (an array even
+ * for one id); the fetcher extracts index 0. An empty array
+ * (Monday's response for "doc not found" or "doc not visible to
+ * token") surfaces `not_found` with `details.doc_id`.
+ */
+export declare const GET_DOC_QUERY = "\n  query GetDoc($ids: [ID!]!) {\n    docs(ids: $ids) {\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      blocks {\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  }\n";
+export interface ListDocumentsInputs {
+    readonly client: MondayClient;
+    /**
+     * Workspace ID filter slot — maps to wire `workspace_ids: [ID]`.
+     * Optional; absent → unfiltered (every visible doc across the
+     * account). Inaccessible workspace IDs surface as empty filter
+     * results (Monday's wire silently drops them — no resolver
+     * warning fires per D4 closure).
+     */
+    readonly workspaceIds?: readonly string[];
+    /**
+     * Order slot — maps to wire `order_by: DocsOrderBy`. Defaults
+     * to `'created_at'` per Monday's wire default. Both values sort
+     * `desc` server-side.
+     */
+    readonly orderBy?: DocsOrderBy;
+    /**
+     * Page size — `[1, 100]`, default `25`. Mirrors Monday's wire-
+     * side default; ceiling pins worst-case payload size per D3.
+     */
+    readonly limit?: number;
+    /**
+     * 1-based page number. Default `1`. Page/limit pagination is the
+     * only mechanism the workdocs surface exposes (no cursor).
+     */
+    readonly page?: number;
+}
+export interface ListDocumentsResult {
+    readonly documents: readonly Document[];
+    /**
+     * Echoed page input (defaults to `1` when caller omits). Surfaces
+     * into `data.page` so the agent sees what Monday actually
+     * received.
+     */
+    readonly page: number;
+    /**
+     * Echoed limit input (defaults to {@link DEFAULT_DOC_LIST_LIMIT}
+     * when caller omits). Surfaces into `data.limit`.
+     */
+    readonly limit: number;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Fetches the workdocs visible to the token via a single
+ * `Query.docs(...)` round-trip with `operationName: 'ListDocs'`
+ * (R-NEW-37 W2). Source is always `'live'` per cli-design §8 cache
+ * scope; workdocs aren't cached at v0.4 per D7.
+ *
+ * Variables map to Monday's wire `Query.docs(...)` args:
+ * `workspaceIds` → `workspace_ids: [ID]`; `orderBy` →
+ * `order_by: DocsOrderBy`; `limit` → `limit: Int`; `page` →
+ * `page: Int`. Omitted inputs drop the corresponding `$variable`
+ * so Monday's per-arg server-side default applies (rather than
+ * threading an explicit `null` that the wire treats as "field
+ * present").
+ *
+ * Echoed `page` / `limit` carry Monday's defaults when the caller
+ * omits them ({@link DEFAULT_DOC_LIST_LIMIT} for limit, `1` for
+ * page) so the envelope's pagination-invariant `.superRefine`
+ * sees consistent values regardless of which inputs the verb
+ * received.
+ *
+ * A null `docs` root surfaces `internal_error` (Monday's documented
+ * shape is `[Document]` even for empty accounts — the array, never
+ * null at this layer). Schema drift in the per-doc shape rewraps to
+ * `internal_error` with `details.issues` via `unwrapOrThrow`.
+ */
+export declare const listDocuments: (inputs: ListDocumentsInputs) => Promise<ListDocumentsResult>;
+export interface GetDocumentInputs {
+    readonly client: MondayClient;
+    readonly docId: string;
+}
+export interface GetDocumentResult {
+    readonly document: DocumentWithBlocks;
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Fetches a single workdoc by ID via a single `Query.docs(ids:)`
+ * round-trip with `operationName: 'GetDoc'` (R-NEW-37 W2). Returns
+ * the Document with `blocks` hydrated. Source is always `'live'`
+ * per cli-design §8 cache scope.
+ *
+ * Empty wire response (Monday's shape for "doc doesn't exist" OR
+ * "doc not visible to token") surfaces `not_found` with
+ * `details.doc_id` — no `forbidden` rewrap, because Monday's wire
+ * collapses the two cases into one shape and the CLI can't
+ * distinguish them per D8.
+ *
+ * A multi-element wire response (which Monday's `docs(ids:)`
+ * shouldn't return for a single-id query) surfaces `internal_error`
+ * as a defensive guard — the CLI assumes one doc per id and a
+ * count mismatch indicates a wire-shape regression worth surfacing
+ * 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