ask-marcel-office-cli 0.5.5 → 1.4.0

package/dist/use-cases/commands/command-types.d.ts

@@ -3,14 +3,80 @@ import type { Result } from '../../domain/result.js';
 import type { GraphClient } from '../../infra/graph-client.js';
 type CommandSchema = z.ZodType;
 type CommandExecute = (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, import('../../infra/graph-client.js').GraphError>>;
-type CommandCategory = 'auth' | 'drive' | 'excel' | 'sharepoint' | 'tasks' | 'mail' | 'notes' | 'user' | 'calendar' | 'contacts' | 'chats' | 'teams' | 'meta';
+type CommandCategory = 'drive' | 'excel' | 'sharepoint' | 'tasks' | 'mail' | 'notes' | 'user' | 'calendar' | 'chats' | 'teams' | 'meta' | 'lifecycle';
 type CommandHttpMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE';
+type CommandOptionAlias = {
+    readonly name: string;
+    readonly key: string;
+};
+/**
+ * Structured type-hint for a CLI flag value. Surfaces in `help-json` so an
+ * LLM can avoid the trial-and-error of "is this an ID or a name?" prose
+ * reading. Optional — populate only where the hint is non-obvious from the
+ * flag name itself.
+ */
+type ArgumentHint = {
+    readonly kind: 'idOrName';
+} | {
+    readonly kind: 'magicValue';
+    readonly values: ReadonlyArray<string>;
+} | {
+    readonly kind: 'a1Address';
+} | {
+    readonly kind: 'iso8601';
+} | {
+    readonly kind: 'graphSubpath';
+};
 type CommandOptionMeta = {
     readonly name: string;
     readonly key: string;
     readonly description: string;
-    readonly required: true;
+    /**
+     * `true` for required flags (the historical default; commander rejects the
+     * invocation if the flag is missing). `false` for optional flags such as the
+     * OData passthrough query parameters (`--top`, `--filter`, …) which
+     * commands accept but do not demand.
+     */
+    readonly required: boolean;
+    /**
+     * Optional secondary spellings of the same flag. Both the canonical
+     * `name` and every alias name are accepted on the command line; values
+     * passed under an alias are normalized to the canonical `key` before
+     * the schema runs. The canonical name is what `--help` shows first.
+     */
+    readonly aliases?: ReadonlyArray<CommandOptionAlias>;
+    /**
+     * Structured value-type hint for LLM consumers. Optional.
+     */
+    readonly argumentHint?: ArgumentHint;
+};
+/**
+ * A positional argument (i.e. NOT a `--flag`). Used today only for the
+ * `docs` lifecycle command (`ask-marcel docs <command>`) but kept as its
+ * own field so the manifest never claims a positional is a flag. An LLM
+ * consumer reading `help-json` can branch on the presence of
+ * `positionalArguments` to know to skip the `--` prefix.
+ */
+type CommandPositionalArgumentMeta = {
+    readonly name: string;
+    readonly required: boolean;
+    readonly description: string;
 };
+/**
+ * How a paginated command produces subsequent pages. Optional — populate
+ * for any command that has `pagination: true`. Lets an LLM tell which
+ * cursor field to feed back to `next-page` (or whether `next-page` is even
+ * applicable, vs `deltaLink`, vs the header-translation case).
+ */
+type PaginationStrategy = 
+/** Standard: `?$top=N&$skip=K` + `@odata.nextLink` cursor. */
+'nextLink'
+/** `?$top=N` + `nextLink` (Graph rejects `$skip` on this endpoint). */
+ | 'nextLinkNoSkip'
+/** Delta endpoints — `nextLink` while paging, `deltaLink` on final page. */
+ | 'deltaLink'
+/** `--top` translated to `Prefer: odata.maxpagesize` header; `$top` rejected as query. */
+ | 'preferMaxPageSize';
 type CommandMeta = {
     readonly summary: string;
     readonly category: CommandCategory;
@@ -18,13 +84,52 @@ type CommandMeta = {
     readonly graphPathTemplate: string;
     readonly graphDocsUrl: string;
     readonly options: ReadonlyArray<CommandOptionMeta>;
+    readonly positionalArguments?: ReadonlyArray<CommandPositionalArgumentMeta>;
     readonly example: string;
     readonly responseShape?: string;
     readonly bodyTemplate?: string;
+    readonly pagination?: true;
+    readonly paginationStrategy?: PaginationStrategy;
+    /**
+     * Graph permission scopes the endpoint requires. The basic Teams web-client
+     * token grants ~30 scopes (run `ask-marcel scopes-check` to see). Commands
+     * with unmet scopes return `403 Forbidden: Missing scope` at the wire. Use
+     * this for pre-flight checks rather than failing on-the-wire. Optional —
+     * populated only on commands where the audit confirmed a scope-failure
+     * path; absent means "should work with the basic Teams token".
+     */
+    readonly scopesRequired?: ReadonlyArray<string>;
+    /**
+     * `true` if the command needs the M365ChatClient elevated token (captured
+     * at login from `m365.cloud.microsoft`, ODSP allow-list). Only 3 commands
+     * today — the historical-version downloads. An LLM should check this
+     * field before invoking; if the elevated capture failed at login, these
+     * commands will time out.
+     */
+    readonly needsElevatedToken?: true;
+    /**
+     * `true` if the command returns inlined bytes (`{contentType, size, base64}`
+     * or `{contentType, size, text}`) and is therefore a valid target for the
+     * global `--output-path` flag. Used by the CLI composition to derive the
+     * rejection-message whitelist from the manifest rather than hand-keeping it
+     * as a string literal. Audit round-8 Wave E2.
+     */
+    readonly producesBytes?: true;
+    /**
+     * Stability tier of the command. Omitted from manifest entries when the
+     * command is `'stable'` (the implicit default), surfaced only on
+     * `'experimental'` commands so an LLM can prefer stable siblings when they
+     * exist. `'experimental'` today means the command rides a Microsoft-internal
+     * substrate (chatsvcagg / IC3) that is not in the public Graph API and can
+     * break on a Teams web-client update — the docstring "Best-effort, may break
+     * on Microsoft client updates" warnings now have a structured pair.
+     * Audit Hervé-session §6.
+     */
+    readonly stability?: 'experimental';
 };
 type Command = {
     readonly schema: CommandSchema;
     readonly execute: CommandExecute;
     readonly meta: CommandMeta;
 };
-export type { Command, CommandCategory, CommandExecute, CommandHttpMethod, CommandMeta, CommandOptionMeta, CommandSchema };
+export type { ArgumentHint, Command, CommandCategory, CommandExecute, CommandHttpMethod, CommandMeta, CommandOptionAlias, CommandOptionMeta, CommandPositionalArgumentMeta, CommandSchema, PaginationStrategy, };

package/dist/use-cases/commands/convert-mail-attachment-to-markdown.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    messageId: z.ZodString;
+    attachmentId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/convert-mail-attachment-to-pdf.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    messageId: z.ZodString;
+    attachmentId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/convert-mail-to-markdown.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    messageId: z.ZodString;
+    inlineImages: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/docs-render.d.ts

@@ -1,4 +1,4 @@
-import type { CommandCategory, CommandMeta } from './command-types.js';
+import type { CommandCategory, CommandMeta, PaginationStrategy } from './command-types.js';
 export type CommandManifestEntry = {
     readonly name: string;
     readonly summary: string;
@@ -7,10 +7,19 @@ export type CommandManifestEntry = {
     readonly graphPathTemplate: string;
     readonly graphDocsUrl: string;
     readonly options: CommandMeta['options'];
+    readonly positionalArguments?: CommandMeta['positionalArguments'];
     readonly example: string;
     readonly responseShape?: string;
     readonly bodyTemplate?: string;
+    readonly pagination?: true;
+    readonly paginationStrategy?: CommandMeta['paginationStrategy'];
+    readonly scopesRequired?: CommandMeta['scopesRequired'];
+    readonly needsElevatedToken?: CommandMeta['needsElevatedToken'];
+    readonly producesBytes?: CommandMeta['producesBytes'];
+    readonly stability?: CommandMeta['stability'];
 };
+export declare const paginationHintFor: (strategy: PaginationStrategy | undefined) => string;
+export declare const PAGINATION_HINT = "Paginated by Microsoft Graph. The CLI hoists `@odata.nextLink` out of `data` to the **top-level `nextLink`** field of the response envelope. Pass that URL to `next-page --url <link>` and repeat until the field is absent. Do NOT look for `data[\"@odata.nextLink\"]` \u2014 the presenter strips it from `data` so the cursor is always at envelope level.";
 export type CommandManifest = {
     readonly package: string;
     readonly version: string;

package/dist/use-cases/commands/docs.d.ts

@@ -1,10 +1,53 @@
 import type { Result } from '../../domain/result.js';
-import type { Command } from './command-types.js';
+import type { CommandCategory, Command, CommandMeta } from './command-types.js';
 import type { CommandManifest } from './docs-render.js';
 export type DocsError = {
     type: 'unknown_command';
     readonly name: string;
     readonly available: ReadonlyArray<string>;
 };
+/**
+ * Terse manifest entry — only the fields an LLM needs to *discover* a command
+ * (i.e. "does this CLI do X?"). Drops `options`, `example`, `graphPathTemplate`,
+ * `graphDocsUrl`, `responseShape`, `bodyTemplate`, `paginationStrategy`,
+ * `scopesRequired` — everything the LLM only needs once it's already decided
+ * to invoke. `stability` is kept (it's a discovery-time concern: LLMs prefer
+ * stable siblings when they exist, so they need to see the tag at discovery
+ * time, not after a second full-manifest fetch). Audit Hervé-session §B/§6.
+ */
+export type TerseManifestEntry = {
+    readonly name: string;
+    readonly summary: string;
+    readonly category: CommandCategory;
+    readonly stability?: CommandMeta['stability'];
+};
+export type TerseManifest = {
+    readonly package: string;
+    readonly version: string;
+    readonly generatedAt: string;
+    readonly commands: ReadonlyArray<TerseManifestEntry>;
+};
+export type ManifestFilterError = {
+    readonly type: 'unknown_category';
+    readonly category: string;
+    readonly available: ReadonlyArray<string>;
+};
 export declare const buildManifest: (registry: Readonly<Record<string, Command>>, packageName: string, version: string, now?: () => Date) => CommandManifest;
+/**
+ * Terse manifest — `{ name, summary, category }` per command. Roughly 95%
+ * smaller than the full manifest (no options/example/Graph endpoint per entry).
+ * Use `help-json --terse` to surface this to an LLM as the discovery view.
+ */
+export declare const buildTerseManifest: (registry: Readonly<Record<string, Command>>, packageName: string, version: string, now?: () => Date) => TerseManifest;
+/**
+ * Filter a `CommandManifest` (or terse variant) down to a single category.
+ * Returns `err({ type: 'unknown_category', ... })` if the requested category
+ * isn't a known one — the CLI surfaces this through the standard error
+ * envelope rather than silently returning an empty list.
+ */
+export declare const filterManifestByCategory: <M extends {
+    readonly commands: ReadonlyArray<{
+        readonly category: CommandCategory;
+    }>;
+}>(manifest: M, category: string) => Result<M, ManifestFilterError>;
 export declare const renderSingleCommand: (registry: Readonly<Record<string, Command>>, name: string) => Result<string, DocsError>;

package/dist/use-cases/commands/docx-to-markdown.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+type MarkdownEnvelope = {
+    readonly contentType: 'text/markdown';
+    readonly size: number;
+    readonly text: string;
+};
+declare const promoteFirstRowToThead: (html: string) => string;
+declare const docxToMarkdown: (bytes: Uint8Array) => Promise<Result<MarkdownEnvelope, GraphError>>;
+export { docxToMarkdown, promoteFirstRowToThead };
+export type { MarkdownEnvelope };

package/dist/use-cases/commands/{download-drive-item-version-content.d.ts → download-drive-item-as-markdown.d.ts}

@@ -5,7 +5,6 @@ import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     driveId: z.ZodString;
     itemId: z.ZodString;
-    versionId: z.ZodString;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/download-drive-item-as-pdf.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/download-drive-item-version.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+    versionId: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<{
+        markdown: "markdown";
+        pdf: "pdf";
+        original: "original";
+    }>>;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/download-onedrive-file-content.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 import type { Result } from '../../domain/result.js';
-import type { GraphClient } from '../../infra/graph-client.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     driveId: z.ZodString;
     itemId: z.ZodString;
 }, z.core.$strip>;
-declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, import("../../infra/graph-client.js").GraphError>>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/embedded-item-to-markdown.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Render an itemAttachment's inner resource (a `microsoft.graph.message`,
+ * `event`, or `contact`) directly to markdown — no RTF round-trip, no
+ * Graph conversion call.
+ *
+ * Each renderer emits a small header block (`**Subject:** …`, etc.) and
+ * appends the body run through htmlToMarkdown when the inner resource
+ * has one. Callers (the convert-mail-attachment-to-markdown command)
+ * choose the right renderer by branching on `item['@odata.type']`.
+ */
+type EmailAddress = {
+    readonly name?: string;
+    readonly address?: string;
+};
+type Recipient = {
+    readonly emailAddress?: EmailAddress;
+};
+type Body = {
+    readonly contentType?: string;
+    readonly content?: string;
+};
+type EmbeddedMessage = {
+    readonly subject?: string;
+    readonly from?: Recipient;
+    readonly toRecipients?: ReadonlyArray<Recipient>;
+    readonly sentDateTime?: string;
+    readonly body?: Body;
+};
+declare const embeddedMessageToMarkdown: (m: EmbeddedMessage) => string;
+type EventDateTime = {
+    readonly dateTime?: string;
+    readonly timeZone?: string;
+};
+type Location = {
+    readonly displayName?: string;
+};
+type EmbeddedEvent = {
+    readonly subject?: string;
+    readonly start?: EventDateTime;
+    readonly end?: EventDateTime;
+    readonly location?: Location;
+    readonly organizer?: Recipient;
+    readonly attendees?: ReadonlyArray<Recipient>;
+    readonly body?: Body;
+};
+declare const embeddedEventToMarkdown: (e: EmbeddedEvent) => string;
+type EmbeddedContact = {
+    readonly displayName?: string;
+    readonly emailAddresses?: ReadonlyArray<{
+        address?: string;
+    }>;
+    readonly businessPhones?: ReadonlyArray<string>;
+    readonly mobilePhone?: string;
+    readonly companyName?: string;
+    readonly jobTitle?: string;
+};
+declare const embeddedContactToMarkdown: (c: EmbeddedContact) => string;
+export { embeddedContactToMarkdown, embeddedEventToMarkdown, embeddedMessageToMarkdown };
+export type { EmbeddedContact, EmbeddedEvent, EmbeddedMessage };

package/dist/use-cases/commands/excel-error.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+declare const mapWacError: (e: GraphError) => GraphError;
+type ExecuteFn = (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const wrapExcelExecute: (inner: ExecuteFn) => ExecuteFn;
+export { mapWacError, wrapExcelExecute };

package/dist/use-cases/commands/extract-sharepoint-links-in-mail.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+type ResolvedLink = {
+    readonly url: string;
+    readonly driveId?: string;
+    readonly itemId?: string;
+    readonly name?: string;
+    readonly webUrl?: string;
+    readonly error?: string;
+};
+type LinkExtractionSummary = {
+    readonly messageId: string;
+    readonly subject?: string;
+    readonly links: ReadonlyArray<ResolvedLink>;
+    readonly truncated: boolean;
+    readonly skippedCount: number;
+};
+declare const schema: z.ZodObject<{
+    messageId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<LinkExtractionSummary, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };
+export type { LinkExtractionSummary, ResolvedLink };

package/dist/use-cases/commands/fetch-raw-bytes.d.ts

@@ -0,0 +1,56 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+/**
+ * Helpers that consolidate the "Graph hands you a 302, follow the CDN
+ * redirect, return the bytes" dance used by every command that needs
+ * raw file content.
+ *
+ * Real Graph responses for `/drives/{id}/items/{id}/content` (and the
+ * `?format=pdf` / `?format=html` variants) are 302 redirects to a CDN URL.
+ * `getBinary` captures the redirect and returns
+ * `{ '@microsoft.graph.downloadUrl': '...' }` — NOT inline bytes. To get
+ * the bytes we have to follow the URL via `fetchUrl`, which is host-allow-
+ * listed for SharePoint / ODSP / Microsoft media-transform domains.
+ *
+ * Two shapes for the return value depending on what the caller needs:
+ *   - `fetchRawBytes(graph, path, opts)` → `Uint8Array` for local
+ *     conversion (mammoth / sheetjs / turndown).
+ *   - `inlineBinary(graph, path, opts)` → `{ contentType, size, base64 }`
+ *     for "stream the bytes back through the JSON envelope" workflows
+ *     (PDF conversion, image attachments, anything the LLM consumer
+ *     either pipes to disk or saves via --output-path).
+ *
+ * The historical-version commands pass `elevated: true` so that the
+ * initial Graph call is signed with an M365ChatClient token (on the
+ * ODSP `logicalPermissions` allow-list); without that, Graph's 302
+ * redirects to a streamContent URL whose embedded tempauth is signed
+ * by Teams web client identity and rejected by SharePoint with 403.
+ */
+export type FetchOptions = {
+    readonly elevated?: boolean;
+};
+export type InlineBinary = {
+    readonly contentType: string;
+    readonly size: number;
+    readonly base64: string;
+};
+export declare const fetchRawBytes: (graph: GraphClient, contentPath: string, opts?: FetchOptions) => Promise<Result<Uint8Array, GraphError>>;
+export declare const inlineBinary: (graph: GraphClient, contentPath: string, opts?: FetchOptions) => Promise<Result<InlineBinary, GraphError>>;
+/**
+ * Detect Graph's silent-raw-bytes fallback on `?format=pdf` requests.
+ *
+ * When `format=pdf` succeeds, the response contentType is `application/pdf`.
+ * For some inputs (notably historical-version pptx on certain tenants, or
+ * reference-attachment edge cases) Graph silently falls back to returning
+ * the raw source bytes — same envelope shape, but contentType is the
+ * source MIME (or `application/octet-stream`). The audit (round-5 #2)
+ * caught this happening on `download-drive-item-version --format pdf` for v79
+ * of a pptx: the response said `contentType: "application/octet-stream"`
+ * with the exact source byte size, and an LLM that saved it as `.pdf`
+ * would have had a corrupt file.
+ *
+ * Tag the result with `passthrough: true` and a sharp note so the LLM
+ * knows the conversion didn't run and saves the bytes with the source
+ * extension instead of `.pdf`.
+ */
+export declare const tagPdfPassthrough: (result: Result<InlineBinary, GraphError>, sourceLabel: string) => Result<unknown, GraphError>;

package/dist/use-cases/commands/find-chats-with-user.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    name: z.ZodString;
+    maxPages: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/format-zod-error.d.ts

@@ -0,0 +1,14 @@
+import type { z } from 'zod';
+/**
+ * Render a Zod validation error as a single human-readable line keyed off the
+ * CLI flag name. The audit's gripe with the previous formatter
+ * (`messageRuleId: Too small: expected string to have >=1 characters`) was
+ * that an LLM piping the JSON envelope through jq sees Zod jargon plus the
+ * camelCase schema key — neither matches what the user typed on the command
+ * line. This formatter prepends `--<kebab-case-flag>` and translates the two
+ * common Zod codes to plain English: missing values become `is missing`,
+ * empty strings become `is empty`. Multi-issue failures join with `; ` to
+ * stay on one line.
+ */
+declare const formatZodError: (error: z.ZodError) => string;
+export { formatZodError };

package/dist/use-cases/commands/get-calendar-event.d.ts

@@ -1,8 +1,4 @@
-import { z } from 'zod';
 import type { CommandMeta } from './command-types.js';
-declare const schema: z.ZodObject<{
-    eventId: z.ZodString;
-}, z.core.$strip>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-calendar-view.d.ts

@@ -1,9 +1,4 @@
-import { z } from 'zod';
 import type { CommandMeta } from './command-types.js';
-declare const schema: z.ZodObject<{
-    startDateTime: z.ZodString;
-    endDateTime: z.ZodString;
-}, z.core.$strip>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-channel-files-folder.d.ts

@@ -0,0 +1,4 @@
+import type { CommandMeta } from './command-types.js';
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-chat.d.ts

@@ -0,0 +1,4 @@
+import type { CommandMeta } from './command-types.js';
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-current-user.d.ts

@@ -1,6 +1,4 @@
-import { z } from 'zod';
 import type { CommandMeta } from './command-types.js';
-declare const schema: z.ZodObject<{}, z.core.$strict>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-delta.d.ts

@@ -1,9 +1,4 @@
-import { z } from 'zod';
 import type { CommandMeta } from './command-types.js';
-declare const schema: z.ZodObject<{
-    driveId: z.ZodString;
-    itemId: z.ZodString;
-}, z.core.$strip>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-item-analytics.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: import("./command-types.js").CommandExecute;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-item-created-by-user.d.ts

@@ -0,0 +1,4 @@
+import type { CommandMeta } from './command-types.js';
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-item-last-modified-by-user.d.ts

@@ -0,0 +1,4 @@
+import type { CommandMeta } from './command-types.js';
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-item-list-item.d.ts

@@ -0,0 +1,4 @@
+import type { CommandMeta } from './command-types.js';
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-item.d.ts

@@ -1,9 +1,4 @@
-import { z } from 'zod';
 import type { CommandMeta } from './command-types.js';
-declare const schema: z.ZodObject<{
-    driveId: z.ZodString;
-    itemId: z.ZodString;
-}, z.core.$strip>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-root-delta.d.ts

@@ -0,0 +1,4 @@
+import type { CommandMeta } from './command-types.js';
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-root-item.d.ts

@@ -1,8 +1,4 @@
-import { z } from 'zod';
 import type { CommandMeta } from './command-types.js';
-declare const schema: z.ZodObject<{
-    driveId: z.ZodString;
-}, z.core.$strip>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/get-drive-special-folder.d.ts

@@ -0,0 +1,4 @@
+import type { CommandMeta } from './command-types.js';
+declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-excel-range.d.ts

@@ -6,6 +6,6 @@ declare const schema: z.ZodObject<{
     worksheetId: z.ZodString;
     address: z.ZodString;
 }, z.core.$strip>;
-declare const execute: import("./command-types.js").CommandExecute;
+declare const execute: (graph: import("../../index.js").GraphClient, params: Record<string, string>) => Promise<import("../../index.js").Result<unknown, import("../../index.js").GraphError>>;
 declare const meta: CommandMeta;
 export { execute, meta, schema };