monday-cli 0.2.0

package/dist/commands/board/group-archive.d.ts

@@ -0,0 +1,83 @@
+/**
+ * `monday board group-archive <bid> <gid> --yes [--dry-run]` —
+ * archive a group on a board (`cli-design.md` §4.3 line 1359,
+ * `v0.2-plan.md` §3 M17).
+ *
+ * **Confirmation gate** (cli-design §3.1 #7 + §8 decision 9: archive
+ * is consistently `--yes`-gated across nouns: item / board / M17
+ * group). Mirrors `board archive` shape — gate fires BEFORE
+ * `resolveClient()` so a missing `--yes` always surfaces as
+ * `confirmation_required`, never masked by a `config_error` from
+ * `loadConfig()`'s missing-token check (M10 round-1 P2 ordering
+ * invariant; R29's `assertConfirmation` helper preserves it via
+ * already-parsed `globalFlags`). The `confirmation_required`
+ * envelope carries the single-target destructive-gate `details`
+ * shape per §6.5: `{board_id, group_id, hint}` — group-archive's
+ * wire signature is two-tuple, so both ids echo via R29's
+ * `extraDetails` slot. R29 helper count: 8 → 9 (item archive /
+ * item delete / update delete / update clear-all / workspace delete
+ * / board archive / board delete / column-delete / group-archive);
+ * 2nd two-tuple `extraDetails` consumer after M16 column-delete.
+ *
+ * **`--dry-run` bypasses the confirmation gate** per cli-design
+ * §3.1 #7 — dry-run is non-executing and the gate is for live
+ * destructive writes only. Mirrors `item archive` / `item delete` /
+ * `board archive` / `board delete` / M16 column-delete precedent.
+ *
+ * **Wire shape.** Single round-trip via `archive_group(board_id,
+ * group_id)` per SDK 14.0.0 `MutationArchive_GroupArgs`. Monday's
+ * `archive_group` returns `Maybe<Group>` (the group's last-look
+ * projection before archive — Monday convention). A null result
+ * surfaces as `not_found`.
+ *
+ * **Dry-run shape** per cli-design §6.4 group-archive variant:
+ * `{operation: "archive_group", board_id, group_id, group:
+ * <projected source snapshot>}`. The preflight read goes through
+ * `loadBoardMetadata` so cache hits are observable; `meta.source:
+ * 'live' | 'cache'`. The cached `boardMetadataSchema.groups[*]`
+ * projection covers the full Group metadata field set (`{id,
+ * title, color, position, archived, deleted}` — every Group field
+ * except `items_page`), so the snapshot carries every field agents
+ * need for "preview before archive" without requiring a separate
+ * read query. Mirrors `board archive`'s snapshot-bearing shape;
+ * diverges from `column-delete` / `board-delete` / `group-delete`'s
+ * destructive-no-read minimal shape.
+ *
+ * **Cache-staleness caveat.** Cache-sourced snapshots may lag live
+ * state up to TTL — pass `--no-cache` for a force-live preview
+ * when freshness is critical (e.g. archiving after a recent rename
+ * or color change).
+ *
+ * **Eager invalidation** (cli-design §8 single-leg call-site
+ * contract). On success, calls `invalidateBoard(boardId)` AFTER
+ * the success envelope's `data` projection completes; ordered
+ * BEFORE `emitMutation` so a cache-unlink failure surfaces through
+ * the runner's catch-all. Skipped on the error path (a failed call
+ * didn't change board state). Required because archive flips the
+ * cached `groups[*].archived` field false → true; without
+ * invalidation a same-process `board describe` would return stale
+ * archived state until TTL eviction.
+ *
+ * **Idempotent: true.** Re-archiving an already-archived group is
+ * a no-op on Monday's side (per §9.1 idempotency table — same row
+ * that covers `archive_item` / `archive_board`).
+ */
+import { z } from 'zod';
+import { type CommandModule } from '../types.js';
+import { type GroupProjection } from '../../api/group-mutation-result.js';
+export declare const boardGroupArchiveOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    color: z.ZodNullable<z.ZodString>;
+    position: z.ZodNullable<z.ZodString>;
+    archived: z.ZodNullable<z.ZodBoolean>;
+    deleted: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strict>;
+export type BoardGroupArchiveOutput = GroupProjection;
+declare const inputSchema: z.ZodObject<{
+    boardId: z.core.$ZodBranded<z.ZodString, "BoardId", "out">;
+    groupId: z.core.$ZodBranded<z.ZodString, "GroupId", "out">;
+}, z.core.$strict>;
+export declare const boardGroupArchiveCommand: CommandModule<z.infer<typeof inputSchema>, BoardGroupArchiveOutput>;
+export {};
+//# sourceMappingURL=group-archive.d.ts.map

package/dist/commands/board/group-archive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-archive.d.ts","sourceRoot":"","sources":["../../../src/commands/board/group-archive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAYnE,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,oCAAoC,CAAC;AAU5C,eAAO,MAAM,6BAA6B;;;;;;;kBAAwB,CAAC;AACnE,MAAM,MAAM,uBAAuB,GAAG,eAAe,CAAC;AAEtD,QAAA,MAAM,WAAW;;;kBAKN,CAAC;AAQZ,eAAO,MAAM,wBAAwB,EAAE,aAAa,CAClD,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,EAC3B,uBAAuB,CA+LxB,CAAC"}

package/dist/commands/board/group-archive.js

@@ -0,0 +1,264 @@
+/**
+ * `monday board group-archive <bid> <gid> --yes [--dry-run]` —
+ * archive a group on a board (`cli-design.md` §4.3 line 1359,
+ * `v0.2-plan.md` §3 M17).
+ *
+ * **Confirmation gate** (cli-design §3.1 #7 + §8 decision 9: archive
+ * is consistently `--yes`-gated across nouns: item / board / M17
+ * group). Mirrors `board archive` shape — gate fires BEFORE
+ * `resolveClient()` so a missing `--yes` always surfaces as
+ * `confirmation_required`, never masked by a `config_error` from
+ * `loadConfig()`'s missing-token check (M10 round-1 P2 ordering
+ * invariant; R29's `assertConfirmation` helper preserves it via
+ * already-parsed `globalFlags`). The `confirmation_required`
+ * envelope carries the single-target destructive-gate `details`
+ * shape per §6.5: `{board_id, group_id, hint}` — group-archive's
+ * wire signature is two-tuple, so both ids echo via R29's
+ * `extraDetails` slot. R29 helper count: 8 → 9 (item archive /
+ * item delete / update delete / update clear-all / workspace delete
+ * / board archive / board delete / column-delete / group-archive);
+ * 2nd two-tuple `extraDetails` consumer after M16 column-delete.
+ *
+ * **`--dry-run` bypasses the confirmation gate** per cli-design
+ * §3.1 #7 — dry-run is non-executing and the gate is for live
+ * destructive writes only. Mirrors `item archive` / `item delete` /
+ * `board archive` / `board delete` / M16 column-delete precedent.
+ *
+ * **Wire shape.** Single round-trip via `archive_group(board_id,
+ * group_id)` per SDK 14.0.0 `MutationArchive_GroupArgs`. Monday's
+ * `archive_group` returns `Maybe<Group>` (the group's last-look
+ * projection before archive — Monday convention). A null result
+ * surfaces as `not_found`.
+ *
+ * **Dry-run shape** per cli-design §6.4 group-archive variant:
+ * `{operation: "archive_group", board_id, group_id, group:
+ * <projected source snapshot>}`. The preflight read goes through
+ * `loadBoardMetadata` so cache hits are observable; `meta.source:
+ * 'live' | 'cache'`. The cached `boardMetadataSchema.groups[*]`
+ * projection covers the full Group metadata field set (`{id,
+ * title, color, position, archived, deleted}` — every Group field
+ * except `items_page`), so the snapshot carries every field agents
+ * need for "preview before archive" without requiring a separate
+ * read query. Mirrors `board archive`'s snapshot-bearing shape;
+ * diverges from `column-delete` / `board-delete` / `group-delete`'s
+ * destructive-no-read minimal shape.
+ *
+ * **Cache-staleness caveat.** Cache-sourced snapshots may lag live
+ * state up to TTL — pass `--no-cache` for a force-live preview
+ * when freshness is critical (e.g. archiving after a recent rename
+ * or color change).
+ *
+ * **Eager invalidation** (cli-design §8 single-leg call-site
+ * contract). On success, calls `invalidateBoard(boardId)` AFTER
+ * the success envelope's `data` projection completes; ordered
+ * BEFORE `emitMutation` so a cache-unlink failure surfaces through
+ * the runner's catch-all. Skipped on the error path (a failed call
+ * didn't change board state). Required because archive flips the
+ * cached `groups[*].archived` field false → true; without
+ * invalidation a same-process `board describe` would return stale
+ * archived state until TTL eviction.
+ *
+ * **Idempotent: true.** Re-archiving an already-archived group is
+ * a no-op on Monday's side (per §9.1 idempotency table — same row
+ * that covers `archive_item` / `archive_board`).
+ */
+import { z } from 'zod';
+import { ensureSubcommand } from '../types.js';
+import { emitDryRun, emitMutation } from '../emit.js';
+import { resolveClient } from '../../api/resolve-client.js';
+import { BoardIdSchema, GroupIdSchema } from '../../types/ids.js';
+import { parseArgv } from '../parse-argv.js';
+import { parseGlobalFlags } from '../../types/global-flags.js';
+import { enforceDestructiveGate } from '../../api/destructive-gate.js';
+import { ApiError } from '../../utils/errors.js';
+import { unwrapOrThrow } from '../../utils/parse-boundary.js';
+import { withBoardInvalidationSingleLeg } from '../../api/board-mutation-invalidation.js';
+import { findBoardChildOrThrow } from '../../api/board-child-finder.js';
+import { loadBoardMetadata } from '../../api/board-metadata.js';
+import { GROUP_FIELDS_FRAGMENT, groupProjectionSchema, projectMutationGroup, } from '../../api/group-mutation-result.js';
+const ARCHIVE_GROUP_MUTATION = `
+  mutation GroupArchive($boardId: ID!, $groupId: String!) {
+    archive_group(board_id: $boardId, group_id: $groupId) {
+      ${GROUP_FIELDS_FRAGMENT}
+    }
+  }
+`;
+export const boardGroupArchiveOutputSchema = groupProjectionSchema;
+const inputSchema = z
+    .object({
+    boardId: BoardIdSchema,
+    groupId: GroupIdSchema,
+})
+    .strict();
+const responseSchema = z
+    .object({
+    archive_group: z.unknown(),
+})
+    .loose();
+export const boardGroupArchiveCommand = {
+    name: 'board.group-archive',
+    summary: 'Archive a group on a board (--yes required)',
+    examples: [
+        'monday board group-archive 12345 topics --yes',
+        'monday board group-archive 12345 topics --dry-run',
+        'monday board group-archive 12345 topics --yes --json',
+    ],
+    // Re-archiving an already-archived group is a no-op on Monday's
+    // side per cli-design §9.1; safe to retry on transient failure.
+    idempotent: true,
+    inputSchema,
+    outputSchema: boardGroupArchiveOutputSchema,
+    attach: (program, ctx) => {
+        const noun = ensureSubcommand(program, 'board', 'Board commands');
+        noun
+            .command('group-archive <boardId> <groupId>')
+            .description(boardGroupArchiveCommand.summary)
+            .addHelpText('after', ['', 'Examples:', ...boardGroupArchiveCommand.examples.map((e) => `  ${e}`), ''].join('\n'))
+            .action(async (boardId, groupId) => {
+            const parsed = parseArgv(boardGroupArchiveCommand.inputSchema, {
+                boardId,
+                groupId,
+            });
+            // Gate fires BEFORE resolveClient() so a missing --yes
+            // surfaces as confirmation_required, not config_error
+            // (M10 round-1 P2 ordering invariant; R29 helper preserves
+            // it via already-parsed globalFlags). The two-tuple wire
+            // signature carries both ids in the confirmation envelope
+            // per cli-design §6.5: `extraDetails: {board_id}` rides
+            // alongside the canonical `group_id` detailKey so agents
+            // see both ids without re-parsing argv.
+            const globalFlags = parseGlobalFlags(program.opts(), ctx.env);
+            enforceDestructiveGate({
+                globalFlags,
+                verb: 'board group-archive',
+                target: parsed.groupId,
+                detailKey: 'group_id',
+                extraDetails: { board_id: parsed.boardId },
+                action: `archive group ${parsed.groupId} on board ${parsed.boardId}`,
+                hint: 'archive is destructive — Monday retains archived ' +
+                    'groups but exposes no unarchive_group mutation ' +
+                    '(cli-design §5.4 + §8 decision 9). The archived ' +
+                    'group becomes invisible to default reads; pass ' +
+                    '`--include-archived` to surface it again.',
+            });
+            const { client, apiVersion, toEmit } = resolveClient(ctx, program.opts());
+            if (globalFlags.dryRun) {
+                // Preflight read via loadBoardMetadata so the v0.1
+                // board-metadata cache can serve fresh entries.
+                // loadBoardMetadata throws ApiError(not_found) when the
+                // board is absent; bubbles to the runner's catch-all.
+                const preflight = await loadBoardMetadata({
+                    client,
+                    boardId: parsed.boardId,
+                    env: ctx.env,
+                    noCache: globalFlags.noCache,
+                });
+                // R51 lift — `findBoardChildOrThrow` consolidates the
+                // board-level read succeeded but the group ID isn't on
+                // the board → not_found-with-details.group_id carve-out
+                // shared with `column-update` + `group-update`.
+                const current = findBoardChildOrThrow({
+                    metadata: preflight.metadata,
+                    kind: 'groups',
+                    id: parsed.groupId,
+                    boardId: parsed.boardId,
+                });
+                // Project to the GroupProjection shape — the cached
+                // `boardMetadataSchema.groups[*]` is byte-identical with
+                // `groupProjectionSchema`'s field set, so a direct copy
+                // is canonical.
+                const snapshot = {
+                    id: current.id,
+                    title: current.title,
+                    color: current.color,
+                    position: current.position,
+                    archived: current.archived,
+                    deleted: current.deleted,
+                };
+                emitDryRun({
+                    ctx,
+                    programOpts: program.opts(),
+                    plannedChanges: [
+                        {
+                            operation: 'archive_group',
+                            board_id: parsed.boardId,
+                            group_id: parsed.groupId,
+                            group: snapshot,
+                        },
+                    ],
+                    source: preflight.source,
+                    cacheAgeSeconds: preflight.cacheAgeSeconds,
+                    warnings: [],
+                    apiVersion,
+                });
+                return;
+            }
+            // Live path. archive_group returns the archived Group's
+            // last-look projection directly; no preflight read needed.
+            //
+            // §8 single-leg call-site contract via `withBoardInvalidation
+            // SingleLeg` (R46): the helper invalidates AFTER the closure
+            // returns (i.e. after `data` projection completes), BEFORE
+            // emitMutation so a cache-unlink failure surfaces through
+            // the runner's catch-all. The closure's throws on schema
+            // drift / null payload bypass invalidation. Required
+            // because archive flips the cached `groups[*].archived`
+            // field false → true; without invalidation a same-process
+            // `board describe` would return stale archived state until
+            // TTL eviction.
+            const { data: projected, response } = await withBoardInvalidationSingleLeg({
+                boardId: parsed.boardId,
+                env: ctx.env,
+                perform: async () => {
+                    const wireResponse = await client.raw(ARCHIVE_GROUP_MUTATION, { boardId: parsed.boardId, groupId: parsed.groupId }, { operationName: 'GroupArchive' });
+                    const data = unwrapOrThrow(responseSchema.safeParse(wireResponse.data), {
+                        context: 'Monday returned a malformed GroupArchive response',
+                        details: { board_id: parsed.boardId, group_id: parsed.groupId },
+                        hint: "this is a data-integrity error in Monday's response; " +
+                            'verify the response shape and update responseSchema if ' +
+                            "Monday's contract has changed.",
+                    });
+                    // Distinguish missing-root-key (schema-drift →
+                    // internal_error) from null payload (group missing →
+                    // not_found). Mirrors the M15 board-archive missing-root
+                    // vs null distinction.
+                    if (!('archive_group' in data)) {
+                        throw new ApiError('internal_error', `Monday's GroupArchive response is missing the archive_group root field`, {
+                            details: {
+                                board_id: parsed.boardId,
+                                group_id: parsed.groupId,
+                                hint: "this is a schema-drift error in Monday's GraphQL " +
+                                    'response; verify the mutation declaration and update ' +
+                                    "the response schema if Monday's contract has changed.",
+                            },
+                        });
+                    }
+                    // R48 lift: null-payload guard + projection. Archive's
+                    // null path uses `not_found` (Monday's idiomatic
+                    // missing-or-no-access response) per the M15 board-
+                    // archive precedent.
+                    const projection = projectMutationGroup({
+                        raw: data.archive_group,
+                        errorCode: 'not_found',
+                        errorMessage: `Monday returned no group payload from archive_group for board ${parsed.boardId} group ${parsed.groupId}`,
+                        boardId: parsed.boardId,
+                        idKey: 'group_id',
+                        idValue: parsed.groupId,
+                    });
+                    return { data: projection, response: wireResponse };
+                },
+            });
+            emitMutation({
+                ctx,
+                data: projected,
+                schema: boardGroupArchiveCommand.outputSchema,
+                programOpts: program.opts(),
+                warnings: [],
+                ...toEmit(response),
+                source: 'live',
+                cacheAgeSeconds: null,
+            });
+        });
+    },
+};
+//# sourceMappingURL=group-archive.js.map

package/dist/commands/board/group-archive.js.map

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

package/dist/commands/board/group-create.d.ts

@@ -0,0 +1,118 @@
+/**
+ * `monday board group-create <bid> --name <n> [--color <c>]
+ * [--dry-run]` — create a new group on a board (`cli-design.md`
+ * §4.3 line 1174, `v0.2-plan.md` §3 M17).
+ *
+ * **Wire shape.** Single round-trip via `create_group(board_id,
+ * group_name, position?, position_relative_method?, relative_to?,
+ * group_color?)` per SDK 14.0.0 `MutationCreate_GroupArgs`. The CLI
+ * flag `--name` maps to wire `group_name: String!`; `--color` maps
+ * to wire `group_color: String?`. M17 deliberately OMITS all three
+ * placement surfaces (`position` is per-changelog deprecated and
+ * `top|bottom` literal semantics are wire-ambiguous; the relative-
+ * position pair `position_relative_method` + `relative_to` is
+ * deferred to v0.3 with `--before <gid>` / `--after <gid>` flags).
+ * Agents needing placement today call the wire mutation via M9's
+ * `dev mutate` escape hatch.
+ *
+ * **`--color` validation.** Monday's accepted colour names are
+ * documented outside the SDK's typed surface (the SDK types
+ * `group_color` as plain `String?`); the v0.2 implementation owns
+ * the field set per cli-design §4.3 group-create. Argv-parses
+ * against the pinned `GROUP_COLOR_VALUES` palette in
+ * `src/api/group-color.ts` (shared with `group-update` so a colour
+ * accepted by create round-trips through update without surprise
+ * rejections). Bogus palette names surface as `usage_error` (exit
+ * 1) BEFORE any network call. Mirrors M16 column-create's per-type
+ * `--settings` field-set ownership rationale — pinning specific
+ * values inline in the contract would force docs revisions every
+ * time Monday tweaks the palette; the implementation owns the
+ * field set so the contract pins only the SHAPE.
+ *
+ * **Live-envelope projection.** Returned `Maybe<Group>` is projected
+ * through `groupProjectionSchema` (the M17 R48-lifted shared shape)
+ * via `projectMutationGroup`. Sharing the schema keeps create /
+ * update / archive / duplicate / delete envelopes byte-identical
+ * for the same record.
+ *
+ * **Dry-run shape** per cli-design §6.4 group-create variant:
+ * minimal `{operation: "create_group", board_id, name, color?}`. No
+ * preflight read fires; the dry-run is purely argv-derived.
+ * `meta.source: 'none'`.
+ *
+ * **Eager invalidation** (cli-design §8 single-leg call-site
+ * contract). On success, calls `invalidateBoard(boardId)` AFTER
+ * the success envelope's `data` projection completes — never
+ * before the wire mutation, never between mutation and projection.
+ * Skipped on the error path (a failed single-leg call didn't
+ * change board state). The cache entry's stale `groups: [...]`
+ * list is dropped so subsequent reads in the same process see
+ * fresh state without TTL eviction.
+ *
+ * **Idempotent: false.** Re-running creates a second group with
+ * the same name (Monday auto-generates a fresh group id per call).
+ * NOT destructive (no --yes gate).
+ */
+import { z } from 'zod';
+import { type CommandModule } from '../types.js';
+import { type GroupProjection } from '../../api/group-mutation-result.js';
+export declare const boardGroupCreateOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    color: z.ZodNullable<z.ZodString>;
+    position: z.ZodNullable<z.ZodString>;
+    archived: z.ZodNullable<z.ZodBoolean>;
+    deleted: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strict>;
+export type BoardGroupCreateOutput = GroupProjection;
+declare const inputSchema: z.ZodObject<{
+    boardId: z.core.$ZodBranded<z.ZodString, "BoardId", "out">;
+    name: z.ZodString;
+    color: z.ZodOptional<z.ZodEnum<{
+        "dark-red": "dark-red";
+        red: "red";
+        "stuck-red": "stuck-red";
+        "sofia-pink": "sofia-pink";
+        lipstick: "lipstick";
+        berry: "berry";
+        "dark-orange": "dark-orange";
+        orange: "orange";
+        "working-orange": "working-orange";
+        peachy: "peachy";
+        sunset: "sunset";
+        "sun-yellow": "sun-yellow";
+        yellow: "yellow";
+        "dark-yellow": "dark-yellow";
+        gold: "gold";
+        "lime-green": "lime-green";
+        "grass-green": "grass-green";
+        "done-green": "done-green";
+        "dark-green": "dark-green";
+        "sea-foam": "sea-foam";
+        teal: "teal";
+        turqouise: "turqouise";
+        sky: "sky";
+        "light-blue": "light-blue";
+        "bright-blue": "bright-blue";
+        blue: "blue";
+        "dark-blue": "dark-blue";
+        royal: "royal";
+        indigo: "indigo";
+        "dark-indigo": "dark-indigo";
+        navy: "navy";
+        purple: "purple";
+        "dark-purple": "dark-purple";
+        lavender: "lavender";
+        "dark-pink": "dark-pink";
+        pink: "pink";
+        brown: "brown";
+        pecan: "pecan";
+        tan: "tan";
+        "american-gray": "american-gray";
+        "gray-gray": "gray-gray";
+        blackish: "blackish";
+    }>>;
+}, z.core.$strict>;
+export declare const boardGroupCreateCommand: CommandModule<z.infer<typeof inputSchema>, BoardGroupCreateOutput>;
+export {};
+//# sourceMappingURL=group-create.d.ts.map

package/dist/commands/board/group-create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-create.d.ts","sourceRoot":"","sources":["../../../src/commands/board/group-create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AASnE,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,oCAAoC,CAAC;AAkB5C,eAAO,MAAM,4BAA4B;;;;;;;kBAAwB,CAAC;AAClE,MAAM,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAErD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcN,CAAC;AAQZ,eAAO,MAAM,uBAAuB,EAAE,aAAa,CACjD,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,EAC3B,sBAAsB,CAgKvB,CAAC"}