monday-cli 0.2.0

package/dist/api/people.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Pure people-resolution helpers for the `people` column-value
+ * translator (`cli-design.md` §5.3 step 3, the people grammar
+ * line 728-734 + the `me` token rule line 704-707).
+ *
+ * Surface:
+ *
+ *   - `parsePeopleInput` — accepts the comma-split email list +
+ *     `me` token sugar `cli-design.md` §5.3 step 3 enumerates and
+ *     returns the Monday wire payload (`{personsAndTeams: [...]}`).
+ *     Async because email→ID resolution can hit the network; the
+ *     caller injects a `PeopleResolutionContext` carrying
+ *     `resolveMe` + `resolveEmail` callbacks so this module stays
+ *     pure (no `client` imports — same inversion `filters.ts` uses
+ *     for its `me` plumbing).
+ *
+ * **Why a separate module.** column-values.ts owns translator
+ * *dispatch* — the switch over WritableColumnType, the
+ * mutation-selection helper, and the ApiError builder. The people
+ * translator's machinery is a small async function with regex
+ * shape-checks + token classification + safe-integer conversion;
+ * splitting keeps column-values.ts at one screen of dispatch logic
+ * and the people-specific concerns isolated for unit testing —
+ * same template `dates.ts` followed in the previous M5a session.
+ *
+ * **Why the `me` callback shape mirrors filters.ts.** `filters.ts`
+ * already takes `resolveMe: () => Promise<string>` for its `me`
+ * sugar on people-style columns. M5b's command layer plumbs the
+ * same callback through both surfaces — agents learning one `me`
+ * rule for read filters don't need to learn a different one for
+ * `--set`. A second callback (`resolveEmail`) handles the email
+ * branch; M5b will wire it to `resolvers.userByEmail` (which owns
+ * the directory cache + `users(emails:)` fallback).
+ *
+ * **No `kind: 'team'` support in v0.1.** cli-design.md §5.3 step 3
+ * line 730 prescribes `{id, kind: 'person'}` only. Monday's API
+ * accepts `kind: 'team'` for team assignments but the design
+ * defers teams to a v0.2 candidate. Logged as a spec gap in
+ * v0.1-plan.md §3 M5a.
+ *
+ * **Numeric tokens rejected.** cli-design.md §5.3 step 3 only
+ * lists emails + `me`. Numeric tokens (`--set Owner=12345`) are
+ * rejected with a `usage_error`. Agents with a raw user ID either
+ * look up the email and use the email form, or use the M8
+ * `--set-raw <col>=<json>` escape hatch with the literal Monday
+ * wire shape. cli-design doesn't say either way; logged as a spec
+ * gap.
+ *
+ * **Shared seams.** `isMeToken` lives in `src/api/me-token.ts`
+ * (R15) — same helper backs `--where Owner=me` (filters.ts) and
+ * `item search --where Owner=me` (commands/item/search.ts).
+ * `DECIMAL_USER_ID_PATTERN` lives in `src/types/ids.ts` (R16) —
+ * same regex backs the resolver-side `userDirectoryEntrySchema`
+ * brand in resolvers.ts. Both lifts replaced verbatim copies that
+ * had drifted independently across the people-session Codex
+ * passes; consolidating the source of truth prevents the next
+ * drift outright.
+ */
+/**
+ * Wire payload shape for a `people` column. Matches Monday's
+ * `change_column_value(value: JSON!)` JSON scalar:
+ *   `{personsAndTeams: [{id: <number>, kind: 'person'}, ...]}`
+ *
+ * cli-design.md §5.3 step 3 line 730 pins the shape exactly:
+ *   - `id` is an integer (number, not string — Monday's user IDs
+ *     are auto-incremented integers and the JSON scalar serialises
+ *     a number as a number).
+ *   - `kind` is the literal string `'person'` (singular `person`
+ *     is deprecated; `personsAndTeams` is the plural canonical
+ *     wire-shape key — Monday's per-column blob spelling).
+ *
+ * Frozen to one-of-two shapes by the literal type on `kind` so
+ * any future "send `team`" branch fails type-checking until the
+ * union is widened intentionally.
+ */
+export interface PeoplePayload {
+    readonly personsAndTeams: readonly PeoplePayloadEntry[];
+}
+export interface PeoplePayloadEntry {
+    readonly id: number;
+    readonly kind: 'person';
+}
+export interface PeopleResolutionContext {
+    /**
+     * Resolves the `me` token to the current user's ID. Async because
+     * the production path issues a `me { id }` query; tests stub it
+     * synchronously. Mirrors `filters.ts`'s `resolveMe` slot one-to-one
+     * so the same M5b wiring resolves `me` for both `--where owner=me`
+     * (filter) and `--set Owner=me` (write).
+     *
+     * Called at most once per `parsePeopleInput` call regardless of
+     * how many `me` tokens appear in the input — same caching shape
+     * `filters.ts` uses.
+     */
+    readonly resolveMe: () => Promise<string>;
+    /**
+     * Resolves an email to a Monday user ID. Throws
+     * `ApiError(user_not_found)` for unknown emails — the translator
+     * surfaces this verbatim per cli-design.md §5.3 step 3 line 733.
+     * M5b wires this to `resolvers.userByEmail` (which owns the
+     * directory cache + `users(emails:)` fallback).
+     *
+     * Email matching is the callback's responsibility — `userByEmail`
+     * already does NFC + case-fold per its own contract. The
+     * translator forwards the verbatim email so the unmatched-email
+     * detail in any thrown `user_not_found` echoes what the agent
+     * typed.
+     */
+    readonly resolveEmail: (email: string) => Promise<string>;
+}
+/**
+ * Token-by-token resolution echo the dry-run engine renders as
+ * `details.resolved_from` per cli-design §6.4 (the people-column
+ * analogue of `DateResolution` from `dates.ts`). Each entry pairs
+ * the verbatim input token (post-trim) with its resolved Monday
+ * user ID — agents reading dry-run output see exactly which
+ * email/`me` resolved to which ID without having to re-derive the
+ * mapping from the `personsAndTeams` array.
+ *
+ * cli-design.md doesn't pin the shape (the §6.4 sample only shows
+ * the date case); logged as a v0.1-plan §3 M5a spec gap.
+ */
+export interface PeopleResolution {
+    readonly tokens: readonly PeopleResolutionToken[];
+}
+export interface PeopleResolutionToken {
+    /** The verbatim input token (post-trim, pre-resolution). */
+    readonly input: string;
+    /**
+     * The resolved Monday user ID (string form, decimal non-negative).
+     * Matches the directory schema's shape — string here so the echo
+     * round-trips through `JSON.stringify` without losing precision
+     * for IDs in the high range.
+     */
+    readonly resolved_id: string;
+}
+export interface ParsedPeopleInput {
+    readonly payload: PeoplePayload;
+    /**
+     * Per-token resolution echo for the dry-run engine. Always
+     * populated (one entry per non-empty input token); empty input
+     * throws `usage_error` before reaching this slot. cli-design
+     * §5.3 step 3 lists the input grammar; the echo shape itself is
+     * a v0.1-plan §3 M5a spec gap for cli-design backfill.
+     */
+    readonly resolution: PeopleResolution;
+}
+/**
+ * Parses a `people` column input per cli-design.md §5.3 step 3.
+ *
+ * Accepted inputs:
+ *   - **Single email** `alice@example.com` → one-element
+ *     `personsAndTeams` payload.
+ *   - **Multiple emails** `alice@example.com,bob@example.com` →
+ *     comma-split, per-segment trimmed, empty segments dropped;
+ *     each email resolved through `ctx.resolveEmail`.
+ *   - **`me` token** (case-insensitive) `me` / `ME` / `Me` →
+ *     resolved through `ctx.resolveMe` to the connected user's ID.
+ *   - **Mixed** `me,alice@example.com` → both resolve, ordered.
+ *
+ * Throws `usage_error` (UsageError):
+ *   - empty input after trim+filter (no labels, no IDs);
+ *   - numeric token (`--set Owner=12345`) — friendly form only
+ *     accepts emails / `me`. Agents with a raw user ID look up
+ *     the email, or use the M8 `--set-raw` escape hatch with
+ *     the literal Monday wire shape.
+ *   - resolved user ID exceeds `Number.MAX_SAFE_INTEGER` (2^53 - 1)
+ *     — defensive guard against a future Monday user-ID range
+ *     expansion. Same shape as the status / dropdown safe-integer
+ *     guards.
+ *
+ * Throws `ApiError(user_not_found)` (bubbled from
+ * `ctx.resolveEmail`) for unknown emails per cli-design.md §5.3
+ * step 3 line 733.
+ *
+ * @param raw - The raw user-supplied value (post-`--set` parsing).
+ * @param columnId - Column ID for error messages.
+ * @param ctx - Resolution context; the caller wires `resolveMe`
+ *   to a whoami query and `resolveEmail` to `userByEmail`.
+ */
+export declare const parsePeopleInput: (raw: string, columnId: string, ctx: PeopleResolutionContext) => Promise<ParsedPeopleInput>;
+//# sourceMappingURL=people.d.ts.map

package/dist/api/people.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"people.d.ts","sourceRoot":"","sources":["../../src/api/people.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAMH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,eAAe,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACzD;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3D;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACnD;AAED,MAAM,WAAW,qBAAqB;IACpC,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,gBAAgB,GAC3B,KAAK,MAAM,EACX,UAAU,MAAM,EAChB,KAAK,uBAAuB,KAC3B,OAAO,CAAC,iBAAiB,CAuC3B,CAAC"}

package/dist/api/people.js

@@ -0,0 +1,260 @@
+/**
+ * Pure people-resolution helpers for the `people` column-value
+ * translator (`cli-design.md` §5.3 step 3, the people grammar
+ * line 728-734 + the `me` token rule line 704-707).
+ *
+ * Surface:
+ *
+ *   - `parsePeopleInput` — accepts the comma-split email list +
+ *     `me` token sugar `cli-design.md` §5.3 step 3 enumerates and
+ *     returns the Monday wire payload (`{personsAndTeams: [...]}`).
+ *     Async because email→ID resolution can hit the network; the
+ *     caller injects a `PeopleResolutionContext` carrying
+ *     `resolveMe` + `resolveEmail` callbacks so this module stays
+ *     pure (no `client` imports — same inversion `filters.ts` uses
+ *     for its `me` plumbing).
+ *
+ * **Why a separate module.** column-values.ts owns translator
+ * *dispatch* — the switch over WritableColumnType, the
+ * mutation-selection helper, and the ApiError builder. The people
+ * translator's machinery is a small async function with regex
+ * shape-checks + token classification + safe-integer conversion;
+ * splitting keeps column-values.ts at one screen of dispatch logic
+ * and the people-specific concerns isolated for unit testing —
+ * same template `dates.ts` followed in the previous M5a session.
+ *
+ * **Why the `me` callback shape mirrors filters.ts.** `filters.ts`
+ * already takes `resolveMe: () => Promise<string>` for its `me`
+ * sugar on people-style columns. M5b's command layer plumbs the
+ * same callback through both surfaces — agents learning one `me`
+ * rule for read filters don't need to learn a different one for
+ * `--set`. A second callback (`resolveEmail`) handles the email
+ * branch; M5b will wire it to `resolvers.userByEmail` (which owns
+ * the directory cache + `users(emails:)` fallback).
+ *
+ * **No `kind: 'team'` support in v0.1.** cli-design.md §5.3 step 3
+ * line 730 prescribes `{id, kind: 'person'}` only. Monday's API
+ * accepts `kind: 'team'` for team assignments but the design
+ * defers teams to a v0.2 candidate. Logged as a spec gap in
+ * v0.1-plan.md §3 M5a.
+ *
+ * **Numeric tokens rejected.** cli-design.md §5.3 step 3 only
+ * lists emails + `me`. Numeric tokens (`--set Owner=12345`) are
+ * rejected with a `usage_error`. Agents with a raw user ID either
+ * look up the email and use the email form, or use the M8
+ * `--set-raw <col>=<json>` escape hatch with the literal Monday
+ * wire shape. cli-design doesn't say either way; logged as a spec
+ * gap.
+ *
+ * **Shared seams.** `isMeToken` lives in `src/api/me-token.ts`
+ * (R15) — same helper backs `--where Owner=me` (filters.ts) and
+ * `item search --where Owner=me` (commands/item/search.ts).
+ * `DECIMAL_USER_ID_PATTERN` lives in `src/types/ids.ts` (R16) —
+ * same regex backs the resolver-side `userDirectoryEntrySchema`
+ * brand in resolvers.ts. Both lifts replaced verbatim copies that
+ * had drifted independently across the people-session Codex
+ * passes; consolidating the source of truth prevents the next
+ * drift outright.
+ */
+import { ApiError, UsageError } from '../utils/errors.js';
+import { DECIMAL_USER_ID_PATTERN } from '../types/ids.js';
+import { isMeToken } from './me-token.js';
+/**
+ * Parses a `people` column input per cli-design.md §5.3 step 3.
+ *
+ * Accepted inputs:
+ *   - **Single email** `alice@example.com` → one-element
+ *     `personsAndTeams` payload.
+ *   - **Multiple emails** `alice@example.com,bob@example.com` →
+ *     comma-split, per-segment trimmed, empty segments dropped;
+ *     each email resolved through `ctx.resolveEmail`.
+ *   - **`me` token** (case-insensitive) `me` / `ME` / `Me` →
+ *     resolved through `ctx.resolveMe` to the connected user's ID.
+ *   - **Mixed** `me,alice@example.com` → both resolve, ordered.
+ *
+ * Throws `usage_error` (UsageError):
+ *   - empty input after trim+filter (no labels, no IDs);
+ *   - numeric token (`--set Owner=12345`) — friendly form only
+ *     accepts emails / `me`. Agents with a raw user ID look up
+ *     the email, or use the M8 `--set-raw` escape hatch with
+ *     the literal Monday wire shape.
+ *   - resolved user ID exceeds `Number.MAX_SAFE_INTEGER` (2^53 - 1)
+ *     — defensive guard against a future Monday user-ID range
+ *     expansion. Same shape as the status / dropdown safe-integer
+ *     guards.
+ *
+ * Throws `ApiError(user_not_found)` (bubbled from
+ * `ctx.resolveEmail`) for unknown emails per cli-design.md §5.3
+ * step 3 line 733.
+ *
+ * @param raw - The raw user-supplied value (post-`--set` parsing).
+ * @param columnId - Column ID for error messages.
+ * @param ctx - Resolution context; the caller wires `resolveMe`
+ *   to a whoami query and `resolveEmail` to `userByEmail`.
+ */
+export const parsePeopleInput = async (raw, columnId, ctx) => {
+    const tokens = raw
+        .split(',')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+    if (tokens.length === 0) {
+        throw emptyPeopleInputError(columnId, raw);
+    }
+    // Cache `me` resolution within the call — same shape filters.ts
+    // uses. An input like `me,me,me` resolves once.
+    let cachedMe;
+    const resolveMeOnce = async () => {
+        cachedMe ??= await ctx.resolveMe();
+        return cachedMe;
+    };
+    const entries = [];
+    const resolutionTokens = [];
+    for (const token of tokens) {
+        if (NON_NEGATIVE_INTEGER.test(token)) {
+            // Numeric tokens aren't in cli-design's people grammar. Reject
+            // with a hint pointing at the email form first and the M8
+            // `--set-raw` escape as the path for raw IDs. Logged as a spec
+            // gap in v0.1-plan.md §3 M5a.
+            throw numericPeopleTokenError(columnId, token, raw);
+        }
+        const id = isMeToken(token)
+            ? await resolveMeOnce()
+            : await ctx.resolveEmail(token);
+        entries.push({ id: idStringToNumber(id, columnId, token), kind: 'person' });
+        resolutionTokens.push({ input: token, resolved_id: id });
+    }
+    return {
+        payload: { personsAndTeams: entries },
+        resolution: { tokens: resolutionTokens },
+    };
+};
+/**
+ * Non-negative integer: matches `0`, `42`, `1234567` but not `-1`,
+ * `0.5`, `1e3`. Used to gate numeric-token rejection on people
+ * input. Same regex `column-values.ts` uses for status indexes /
+ * dropdown IDs — pin via local copy because importing from
+ * `column-values.ts` would create a circular import (column-values
+ * imports parsePeopleInput).
+ */
+const NON_NEGATIVE_INTEGER = /^\d+$/u;
+/**
+ * Converts a string user ID (Monday's directory shape) to a
+ * number for the `personsAndTeams[].id` wire field. Two layers
+ * of validation, both required:
+ *
+ *   1. **Decimal-shape regex** (`DECIMAL_USER_ID_PATTERN` from
+ *      `src/types/ids.ts`, R16-shared). `Number()`
+ *      alone accepts hex (`"0x2a"` → 42), scientific notation
+ *      (`"1e3"` → 1000), empty strings (`""` → 0), and signed
+ *      forms (`"-1"` → -1) — none of which are valid Monday user
+ *      IDs but all of which would silently land at Monday as the
+ *      wrong number. Codex review pass-1 finding: caller's
+ *      `userByEmail` validates only `z.string().min(1)`, so the
+ *      translator must defend its own boundary. Throws
+ *      `internal_error` (data corruption from the resolver, not
+ *      user-input fault).
+ *   2. **Safe-integer guard.** Defensive against a future Monday
+ *      user-ID range expansion that would silently round through
+ *      `Number()` and corrupt the wire payload. Throws
+ *      `usage_error` (consistent with the status / dropdown
+ *      safe-integer guards — agent-actionable).
+ *
+ * `token` is included in error details so the agent's debug log
+ * shows which email/me-token resolved to the unsafe ID.
+ */
+const idStringToNumber = (id, columnId, token) => {
+    if (!DECIMAL_USER_ID_PATTERN.test(id)) {
+        // Resolver returned something that isn't a decimal non-negative
+        // integer string. This is a data-integrity problem with the
+        // directory, not a user-input fault — surface as internal_error
+        // with enough context for an agent to file a bug, but don't
+        // pretend the user can fix it by editing their --set value.
+        throw new ApiError('internal_error', `People column "${columnId}" resolved token "${token}" to a ` +
+            `non-decimal user ID ${JSON.stringify(id)}. Monday's user IDs ` +
+            `are decimal non-negative integers; the resolver returned an ` +
+            `unexpected shape.`, {
+            details: {
+                column_id: columnId,
+                column_type: 'people',
+                token,
+                resolved_id: id,
+                hint: 'this is a data-integrity error in the user directory or ' +
+                    'the resolver wiring; verify the directory cache and the ' +
+                    'shape of the response from `users(emails:)`.',
+            },
+        });
+    }
+    const parsed = Number(id);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new UsageError(`People column "${columnId}" got a resolved user ID "${id}" ` +
+            `(from token "${token}") that exceeds JavaScript's safe-integer ` +
+            `range (2^53 - 1, i.e. 9007199254740991). Number(id) would lose ` +
+            `precision, corrupting the personsAndTeams wire payload. Use ` +
+            `--set-raw <col>=<json> with the literal Monday wire shape ` +
+            `instead.`, {
+            details: {
+                column_id: columnId,
+                column_type: 'people',
+                token,
+                resolved_id: id,
+                hint: 'this user ID exceeds JS safe-integer range; the friendly ' +
+                    "translator can't round-trip it. Use --set-raw <col>=<json> " +
+                    'with the literal Monday wire shape (e.g. --set-raw ' +
+                    `${columnId}='{"personsAndTeams":[{"id":${id},"kind":"person"}]}').`,
+            },
+        });
+    }
+    return parsed;
+};
+/**
+ * Builds the `usage_error` for empty input — no emails, no `me`,
+ * nothing left after trim+filter (`--set Owner=""` or
+ * `--set Owner=" , "` etc.). Mirrors the dropdown empty-input
+ * branch's shape so an agent that handles one details payload
+ * handles them all. Pointing at `monday item clear` keeps `--set`
+ * and the dedicated clear verb non-overlapping per cli-design.md
+ * §5.3 (clear is the verb that empties a column; `--set` is the
+ * verb that writes a new value).
+ */
+const emptyPeopleInputError = (columnId, raw) => new UsageError(`People column "${columnId}" needs at least one email or the \`me\` ` +
+    `token. Got "${raw}". To clear a people column, use ` +
+    `\`monday item clear <iid> ${columnId} [--board <bid>]\` instead.`, {
+    details: {
+        column_id: columnId,
+        column_type: 'people',
+        raw_input: raw,
+        hint: 'pass a comma-separated list of emails (e.g. --set ' +
+            `${columnId}=alice@example.com,bob@example.com), or ` +
+            `--set ${columnId}=me. The --set-raw escape hatch accepts ` +
+            'the literal Monday wire shape if email resolution is not ' +
+            'an option.',
+    },
+});
+/**
+ * Builds the `usage_error` for a numeric token that the translator
+ * doesn't accept. cli-design.md §5.3 step 3 only lists emails and
+ * `me` for the people grammar — numeric tokens are an explicit
+ * grammar gap. Agents with a raw user ID either look up the
+ * email, or use the `--set-raw <col>=<json>` escape hatch (M8)
+ * with the literal Monday wire shape.
+ *
+ * `raw` is included alongside `token` because the failing token
+ * may be one of many in a comma list (`alice@example.com,12345`)
+ * and the agent's debug log benefits from seeing both.
+ */
+const numericPeopleTokenError = (columnId, token, raw) => new UsageError(`People column "${columnId}" got numeric token "${token}", which ` +
+    `is not in the people grammar (cli-design.md §5.3 step 3 only ` +
+    `lists emails and \`me\`). Look up the user's email and use the ` +
+    `email form, or use --set-raw <col>=<json> with the literal ` +
+    `Monday wire shape.`, {
+    details: {
+        column_id: columnId,
+        column_type: 'people',
+        token,
+        raw_input: raw,
+        hint: `pass the user's email instead (e.g. --set ${columnId}=` +
+            `alice@example.com), or use --set-raw ${columnId}=` +
+            `'{"personsAndTeams":[{"id":${token},"kind":"person"}]}'.`,
+    },
+});
+//# sourceMappingURL=people.js.map

package/dist/api/people.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"people.js","sourceRoot":"","sources":["../../src/api/people.ts"],"names":[],"mappings":"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"}

package/dist/api/phones.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Pure phone-resolution helpers for the `phone` column-value translator
+ * (`cli-design.md` §5.3 step 3 v0.2 expansion, `v0.2-plan.md` §3 M8).
+ *
+ * Surface:
+ *   - `parsePhoneInput` — accepts the **mandatory** pipe-form
+ *     `<phone>|<country>` cli-design §5.3 enumerates. E.164-loose
+ *     phone validation; ISO 3166-1 alpha-2 country code validated
+ *     against a frozen allowlist (`iso-country-codes.ts`).
+ *
+ * **Why pipe form is mandatory.** Monday's phone-column validation
+ * requires both the number AND the 2-letter country code AND verifies
+ * they match (per Monday's phone-validation changelog). The friendly
+ * translator can't safely default `countryShortName: ""` — Monday
+ * would reject the mutation as `validation_failed`. Agents who need
+ * to write a phone with no country (Monday allows it for some legacy
+ * fixtures) use `--set-raw`.
+ *
+ * **E.164-loose validation.** The phone segment matches `+?\d{6,15}`
+ * — leading `+` optional, 6-15 digits otherwise. E.164's strict rule
+ * is "1-15 digits" but the CLI insists on at least 6 to catch
+ * obvious typos (`--set Mobile=+1|US` would silently land at Monday
+ * and fail server-side). The bound is a sanity check, not a
+ * complete E.164 validator — Monday is the validator of last resort.
+ *
+ * **No internal whitespace, no dashes.** `+1 555 123 4567` and
+ * `+1-555-123-4567` are rejected. cli-design doesn't pin this
+ * explicitly but Monday's API expects bare digits + an optional
+ * leading `+`. Agents who paste a formatted phone strip the
+ * separators in the shell pipeline (`tr -d ' -'`).
+ *
+ * **Why a separate module.** Same template `links.ts` / `dates.ts`
+ * follow — column-values.ts owns translator dispatch; the per-type
+ * grammar machinery lives one module deeper. The ISO allowlist is
+ * larger again (`iso-country-codes.ts`) so the layering keeps
+ * column-values.ts at one screen of dispatch logic.
+ */
+/**
+ * Wire payload shape for a `phone` column. Matches Monday's
+ * `change_column_value(value: JSON!)` JSON scalar:
+ *   `{phone: <phone>, countryShortName: <country>}`
+ *
+ * cli-design.md §5.3 step 3 v0.2 expansion line 815-827 pins the
+ * shape. `countryShortName` is the uppercase 2-letter ISO 3166-1
+ * alpha-2 code; the field name spelling is Monday's choice
+ * (camelCase, no trailing `code`).
+ */
+export interface PhonePayload {
+    readonly phone: string;
+    readonly countryShortName: string;
+}
+/**
+ * Parses a `phone` column input per cli-design.md §5.3 step 3 v0.2
+ * expansion.
+ *
+ * Accepted input — pipe form is **mandatory**:
+ *   - `<phone>|<country>` → `{phone, countryShortName}`. Both
+ *     segments trimmed; pipe-split max 1. Country code uppercased
+ *     before allowlist check (so `us` and `US` both work).
+ *
+ * Rejected (all `usage_error`):
+ *   - **Single segment** (`+15551234567` without `|US`) — Monday
+ *     requires both. Agents who need an empty country use
+ *     `--set-raw`. cli-design §5.3 line 819-827.
+ *   - **Phone fails E.164-loose** (`+?\d{6,15}` after trim).
+ *   - **Country fails ISO allowlist** (after uppercase).
+ *   - **Empty leader / trailer** (`|US` or `+1555|`).
+ *   - **Empty input** after trim.
+ *
+ * @param raw - The raw user-supplied value (post-`--set` parsing).
+ * @param columnId - Column ID for error messages.
+ */
+export declare const parsePhoneInput: (raw: string, columnId: string) => PhonePayload;
+//# sourceMappingURL=phones.d.ts.map

package/dist/api/phones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phones.d.ts","sourceRoot":"","sources":["../../src/api/phones.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAKH;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,MAAM,EACX,UAAU,MAAM,KACf,YAuHF,CAAC"}