@zapier/zapier-sdk 0.77.1 → 0.78.0

package/dist/utils/agent.js

@@ -1,76 +0,0 @@
-// Matches "1" or "true" (case-insensitive).
-const isTruthy = (value) => {
-    const lower = value.toLowerCase();
-    return lower === "1" || lower === "true";
-};
-// Any non-empty string — for vars whose value is meaningful rather than boolean.
-const isNonEmpty = (value) => value !== "";
-const agentDetectors = [
-    { name: "claude-code", key: "CLAUDECODE", predicate: isTruthy },
-    { name: "github-copilot", key: "COPILOT_AGENT", predicate: isTruthy },
-    { name: "cursor", key: "CURSOR_AGENT", predicate: isTruthy },
-    { name: "codex", key: "CODEX_SANDBOX", predicate: isNonEmpty },
-    { name: "gemini-cli", key: "GEMINI_CLI", predicate: isTruthy },
-    { name: "augment", key: "AUGMENT_AGENT", predicate: isTruthy },
-    { name: "cline", key: "CLINE_ACTIVE", predicate: isTruthy },
-    { name: "opencode", key: "OPENCODE_CLIENT", predicate: isNonEmpty },
-];
-/**
- * Detects which AI coding agent is executing the current process by inspecting
- * well-known environment variables set by each agent's runtime.
- *
- * Claude Code
- *   CLAUDECODE — set to "1" in all subprocesses spawned by Claude Code
- *     https://code.claude.com/docs/en/env-vars
- *
- * GitHub Copilot
- *   COPILOT_AGENT — set to "1" in VS Code agent terminal sessions
- *     https://github.com/microsoft/vscode/pull/316267
- *
- * Cursor
- *   CURSOR_AGENT — set to "1" by Cursor when executing terminal commands
- *     https://cursor.com/docs/agent/tools/terminal
- *
- * Codex CLI
- *   CODEX_SANDBOX — set to "seatbelt" (macOS) or a non-empty string (Linux/Windows)
- *     https://github.com/openai/codex/blob/main/codex-rs/core/src/spawn.rs
- *
- * Gemini CLI
- *   GEMINI_CLI — set to "1" in subprocesses spawned by Gemini CLI's shell tool
- *     https://github.com/google-gemini/gemini-cli/blob/main/packages/core/src/services/shellExecutionService.ts
- *
- * Augment
- *   AUGMENT_AGENT — set to "1" when Auggie executes shell commands via its launch-process tool
- *     https://docs.augmentcode.com/cli/reference
- *
- * Cline
- *   CLINE_ACTIVE — set to "true" when Cline is executing terminal commands
- *     https://github.com/cline/cline/pull/5367
- *
- * OpenCode
- *   OPENCODE_CLIENT — client identifier set by OpenCode (defaults to "cli")
- *     https://anomalyco-opencode.mintlify.app/cli/overview#environment-variables
- *
- * Returns null if no known agent is detected or process is unavailable.
- *
- * Never throws: try/catch guards against exotic environments (e.g. a Proxy on
- * globalThis.process) where property access could unexpectedly fail. Event
- * emission must never cascade into a thrown exception.
- */
-export function getAgent() {
-    try {
-        const env = globalThis.process?.env;
-        if (!env)
-            return null;
-        for (const detector of agentDetectors) {
-            const value = env[detector.key];
-            if (value !== undefined && detector.predicate(value)) {
-                return detector.name;
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/utils/array-utils.d.ts

@@ -1,31 +0,0 @@
-/**
- * Array utility functions for working with async iterators and arrays
- */
-/**
- * Creates an array from an async iterable, similar to Array.from() but for async iterables
- *
- * @param asyncIterable - An async iterable to convert to an array
- * @returns Promise that resolves to an array containing all items from the async iterable
- *
- * @example
- * async function* generateNumbers() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * }
- *
- * const numbers = await fromAsync(generateNumbers()); // [1, 2, 3]
- *
- * @example
- * // With async generator that fetches data
- * async function* fetchUsers() {
- *   for (let page = 1; page <= 3; page++) {
- *     const users = await fetchUsersPage(page);
- *     yield* users;
- *   }
- * }
- *
- * const allUsers = await fromAsync(fetchUsers());
- */
-export declare function toArrayFromAsync<T>(asyncIterable: AsyncIterable<T>): Promise<T[]>;
-//# sourceMappingURL=array-utils.d.ts.map

package/dist/utils/array-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array-utils.d.ts","sourceRoot":"","sources":["../../src/utils/array-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,aAAa,EAAE,aAAa,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,CAAC,EAAE,CAAC,CAQd"}

package/dist/utils/array-utils.js

@@ -1,36 +0,0 @@
-/**
- * Array utility functions for working with async iterators and arrays
- */
-/**
- * Creates an array from an async iterable, similar to Array.from() but for async iterables
- *
- * @param asyncIterable - An async iterable to convert to an array
- * @returns Promise that resolves to an array containing all items from the async iterable
- *
- * @example
- * async function* generateNumbers() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * }
- *
- * const numbers = await fromAsync(generateNumbers()); // [1, 2, 3]
- *
- * @example
- * // With async generator that fetches data
- * async function* fetchUsers() {
- *   for (let page = 1; page <= 3; page++) {
- *     const users = await fetchUsersPage(page);
- *     yield* users;
- *   }
- * }
- *
- * const allUsers = await fromAsync(fetchUsers());
- */
-export async function toArrayFromAsync(asyncIterable) {
-    const result = [];
-    for await (const item of asyncIterable) {
-        result.push(item);
-    }
-    return result;
-}

package/dist/utils/batch-utils.d.ts

@@ -1,72 +0,0 @@
-/**
- * Batch Operation Utilities
- *
- * This module provides utilities for executing multiple async operations
- * with concurrency control and retry logic.
- */
-/**
- * Options for batch execution
- */
-export interface BatchOptions {
-    /**
-     * Maximum number of concurrent operations (default: 10)
-     * Lower values are more "polite" but slower
-     * Higher values are faster but risk rate limits
-     */
-    concurrency?: number;
-    /**
-     * Whether to retry failed operations (default: true)
-     * When enabled, each operation gets up to MAX_CONSECUTIVE_ERRORS retries
-     */
-    retry?: boolean;
-    /**
-     * Delay in milliseconds between starting batches (default: 100ms)
-     * Adds a small delay between concurrent batches to avoid burst patterns
-     */
-    batchDelay?: number;
-    /**
-     * Overall timeout for the entire batch operation in milliseconds (default: 180000ms / 3 minutes)
-     * When exceeded, throws ZapierTimeoutError and stops processing remaining tasks
-     */
-    timeoutMs?: number;
-    /**
-     * Timeout for individual tasks in milliseconds (default: none)
-     * When set, each task will be cancelled if it exceeds this duration
-     * Tasks that timeout will be marked as rejected in the results
-     */
-    taskTimeoutMs?: number;
-}
-/**
- * Execute multiple async operations with concurrency limiting and retry logic
- *
- * This prevents overwhelming APIs by:
- * 1. Limiting concurrent operations (worker pool pattern)
- * 2. Adding small delays between batches to avoid burst detection
- * 3. Retrying failed operations with exponential backoff
- *
- * Problem Solved:
- * - Rate limit prevention: Steady stream instead of burst requests
- * - Connection pool management: Stays within browser/Node limits (~6-8 per domain)
- * - Resilience: Transient failures are retried automatically
- * - Observability: Returns detailed success/failure info for each operation
- *
- * Example Usage:
- * ```typescript
- * // Instead of Promise.allSettled (fires all at once):
- * const results = await Promise.allSettled(
- *   actions.map(a => sdk.listInputFields(a))
- * );
- *
- * // Use batch (controlled concurrency):
- * const results = await batch(
- *   actions.map(a => () => sdk.listInputFields(a)),
- *   { concurrency: 10, retry: true }
- * );
- * ```
- *
- * @param tasks - Array of functions that return promises (NOT promises themselves!)
- * @param options - Configuration for concurrency and retry behavior
- * @returns Promise resolving to array of settled results (same as Promise.allSettled)
- */
-export declare function batch<T>(tasks: (() => Promise<T>)[], options?: BatchOptions): Promise<PromiseSettledResult<T>[]>;
-//# sourceMappingURL=batch-utils.d.ts.map

package/dist/utils/batch-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch-utils.d.ts","sourceRoot":"","sources":["../../src/utils/batch-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2BH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,EAC3B,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,CAuIpC"}

package/dist/utils/batch-utils.js

@@ -1,161 +0,0 @@
-/**
- * Batch Operation Utilities
- *
- * This module provides utilities for executing multiple async operations
- * with concurrency control and retry logic.
- */
-import { sleep, calculateErrorBackoffMs, MAX_CONSECUTIVE_ERRORS, } from "./retry-utils";
-import { ZapierTimeoutError } from "../types/errors";
-/**
- * Default number of concurrent operations
- * Chosen to be "polite" to APIs while still providing good throughput
- */
-const DEFAULT_CONCURRENCY = 10;
-/**
- * Delay between starting each batch of concurrent operations (milliseconds)
- * This prevents burst patterns that might trigger rate limiting
- */
-const BATCH_START_DELAY_MS = 25;
-/**
- * Default timeout for entire batch operation (milliseconds)
- * Set to 3 minutes to match polling default timeout
- */
-const DEFAULT_BATCH_TIMEOUT_MS = 180000;
-/**
- * Execute multiple async operations with concurrency limiting and retry logic
- *
- * This prevents overwhelming APIs by:
- * 1. Limiting concurrent operations (worker pool pattern)
- * 2. Adding small delays between batches to avoid burst detection
- * 3. Retrying failed operations with exponential backoff
- *
- * Problem Solved:
- * - Rate limit prevention: Steady stream instead of burst requests
- * - Connection pool management: Stays within browser/Node limits (~6-8 per domain)
- * - Resilience: Transient failures are retried automatically
- * - Observability: Returns detailed success/failure info for each operation
- *
- * Example Usage:
- * ```typescript
- * // Instead of Promise.allSettled (fires all at once):
- * const results = await Promise.allSettled(
- *   actions.map(a => sdk.listInputFields(a))
- * );
- *
- * // Use batch (controlled concurrency):
- * const results = await batch(
- *   actions.map(a => () => sdk.listInputFields(a)),
- *   { concurrency: 10, retry: true }
- * );
- * ```
- *
- * @param tasks - Array of functions that return promises (NOT promises themselves!)
- * @param options - Configuration for concurrency and retry behavior
- * @returns Promise resolving to array of settled results (same as Promise.allSettled)
- */
-export async function batch(tasks, options = {}) {
-    const { concurrency = DEFAULT_CONCURRENCY, retry = true, batchDelay = BATCH_START_DELAY_MS, timeoutMs = DEFAULT_BATCH_TIMEOUT_MS, taskTimeoutMs, } = options;
-    // Validate inputs
-    if (concurrency <= 0) {
-        throw new Error("Concurrency must be greater than 0");
-    }
-    if (timeoutMs <= 0) {
-        throw new Error("Timeout must be greater than 0");
-    }
-    if (taskTimeoutMs !== undefined && taskTimeoutMs <= 0) {
-        throw new Error("Task timeout must be greater than 0");
-    }
-    if (tasks.length === 0) {
-        return [];
-    }
-    // Track overall batch timing
-    const startTime = Date.now();
-    // Pre-allocate results array to maintain input order
-    const results = new Array(tasks.length);
-    // Create task queue with retry state
-    const taskQueue = tasks.map((task, index) => ({
-        index,
-        task,
-        errorCount: 0,
-    }));
-    /**
-     * Execute a single task with retry logic and optional per-task timeout
-     */
-    async function executeTask(taskState) {
-        const { index, task, errorCount } = taskState;
-        try {
-            let result;
-            // Apply per-task timeout if specified
-            if (taskTimeoutMs !== undefined) {
-                const timeoutPromise = sleep(taskTimeoutMs).then(() => {
-                    throw new ZapierTimeoutError(`Task timed out after ${taskTimeoutMs}ms`);
-                });
-                result = await Promise.race([task(), timeoutPromise]);
-            }
-            else {
-                result = await task();
-            }
-            results[index] = { status: "fulfilled", value: result };
-        }
-        catch (error) {
-            const newErrorCount = errorCount + 1;
-            // Don't retry timeout errors - they're unlikely to succeed on retry
-            const isTimeout = error instanceof ZapierTimeoutError;
-            // If retry is enabled and we haven't hit max errors and it's not a timeout, retry with backoff
-            if (retry && !isTimeout && newErrorCount < MAX_CONSECUTIVE_ERRORS) {
-                // Calculate backoff delay (base 1000ms with jitter and error scaling)
-                const waitTime = calculateErrorBackoffMs(1000, newErrorCount);
-                await sleep(waitTime);
-                // Re-queue the task with incremented error count
-                taskQueue.push({
-                    index,
-                    task,
-                    errorCount: newErrorCount,
-                });
-            }
-            else {
-                // Max retries reached, retry disabled, or timeout error - mark as rejected
-                results[index] = { status: "rejected", reason: error };
-            }
-        }
-    }
-    /**
-     * Worker that continuously picks up and executes tasks from the queue
-     * Checks overall batch timeout before processing each task
-     */
-    async function worker() {
-        while (taskQueue.length > 0) {
-            // Check overall batch timeout before processing next task
-            const elapsedTime = Date.now() - startTime;
-            if (elapsedTime >= timeoutMs) {
-                throw new ZapierTimeoutError(`Batch operation timed out after ${Math.floor(elapsedTime / 1000)}s. ${taskQueue.length} task(s) not completed.`);
-            }
-            const taskState = taskQueue.shift();
-            if (!taskState)
-                break;
-            await executeTask(taskState);
-            // Small delay to prevent burst patterns within a worker
-            // Only delay if there are more tasks to process
-            if (taskQueue.length > 0 && batchDelay > 0) {
-                await sleep(batchDelay);
-            }
-        }
-    }
-    /**
-     * Start workers in small batches to avoid initial burst
-     * This helps avoid rate limit triggers when starting many workers
-     */
-    const workerCount = Math.min(concurrency, tasks.length);
-    const workers = [];
-    for (let i = 0; i < workerCount; i++) {
-        workers.push(worker());
-        // Add small delay between starting workers to stagger the initial requests
-        // Skip delay for last worker
-        if (i < workerCount - 1 && batchDelay > 0) {
-            await sleep(batchDelay / 10); // 10ms between worker starts
-        }
-    }
-    // Wait for all workers to complete
-    await Promise.all(workers);
-    return results;
-}

package/dist/utils/caller-context.d.ts

@@ -1,21 +0,0 @@
-export interface CallerContext {
-    packageOperation?: string;
-}
-/**
- * Run `fn` with the given caller context merged onto any parent context, so
- * the operation that initiated the call (e.g. a CLI command or MCP tool) stays
- * observable through every SDK call it makes.
- *
- * Caller context is telemetry-only: reading the parent scope is wrapped so a
- * broken ALS store can never crash the wrapped command. Errors thrown by `fn`
- * itself are intentionally NOT caught — they propagate.
- */
-export declare function runWithCallerContext<T>(context: CallerContext, fn: () => T): T;
-/**
- * Read the active caller context, or an empty object outside any caller scope.
- *
- * Read on the outbound HTTP path to set a telemetry header, so a failure here
- * must never break the request — it falls back to an empty context.
- */
-export declare function getCallerContext(): CallerContext;
-//# sourceMappingURL=caller-context.d.ts.map

package/dist/utils/caller-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"caller-context.d.ts","sourceRoot":"","sources":["../../src/utils/caller-context.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,OAAO,EAAE,aAAa,EACtB,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAQH;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,CAMhD"}

package/dist/utils/caller-context.js

@@ -1,35 +0,0 @@
-import { createAsyncContext } from "kitcore";
-const callerContext = createAsyncContext();
-/**
- * Run `fn` with the given caller context merged onto any parent context, so
- * the operation that initiated the call (e.g. a CLI command or MCP tool) stays
- * observable through every SDK call it makes.
- *
- * Caller context is telemetry-only: reading the parent scope is wrapped so a
- * broken ALS store can never crash the wrapped command. Errors thrown by `fn`
- * itself are intentionally NOT caught — they propagate.
- */
-export function runWithCallerContext(context, fn) {
-    let parent;
-    try {
-        parent = callerContext.get() ?? {};
-    }
-    catch {
-        return fn();
-    }
-    return callerContext.run({ ...parent, ...context }, fn);
-}
-/**
- * Read the active caller context, or an empty object outside any caller scope.
- *
- * Read on the outbound HTTP path to set a telemetry header, so a failure here
- * must never break the request — it falls back to an empty context.
- */
-export function getCallerContext() {
-    try {
-        return callerContext.get() ?? {};
-    }
-    catch {
-        return {};
-    }
-}

package/dist/utils/domain-utils.d.ts

@@ -1,96 +0,0 @@
-/**
- * Domain utility functions for working with app identifiers and data normalization
- */
-import type { Action, ImplementationMeta } from "../api/types";
-import type { ConnectionEntry } from "../types/connections";
-import type { ActionItem, AppItem, ConnectionItem } from "../types/domain";
-/**
- * Checks if a string value looks like a direct connection ID rather than a named alias.
- * Returns true for numeric strings and UUIDs.
- */
-export declare function isConnectionId(value: string): boolean;
-/**
- * Resolves a connectionId from the connection-related parameters that can be passed
- * to SDK methods (connectionId, connection, authenticationId).
- *
- * Handles mutual exclusivity validation, string alias lookup via the connections map,
- * and numeric passthrough.
- */
-export declare function resolveConnectionId({ connectionId, connection, authenticationId, resolveConnection, label, }: {
-    connectionId?: string | number | null;
-    connection?: string | number | null;
-    authenticationId?: string | number | null;
-    resolveConnection: (name: string) => Promise<ConnectionEntry | undefined>;
-    label?: string;
-}): Promise<string | number | undefined>;
-/**
- * Splits a versioned key to extract the base key and version
- *
- * @param versionedKey - Versioned key in format "KeyName@version" (e.g., "SlackCLIAPI@1.21.1")
- * @returns Tuple of [baseKey, version] or [versionedKey, undefined] if no @ symbol
- *
- * @example
- * splitVersionedKey("SlackCLIAPI@1.21.1") // ["SlackCLIAPI", "1.21.1"]
- * splitVersionedKey("SomeAPI") // ["SomeAPI", undefined]
- */
-export declare function splitVersionedKey(versionedKey: string): [string, string | undefined];
-/**
- * Converts a lightweight ImplementationMeta to a slimmed AppItem
- *
- * @param implementationMeta - Raw ImplementationMeta from API
- * @returns Normalized AppItem with essential fields only
- */
-export declare function normalizeImplementationMetaToAppItem(implementationMeta: ImplementationMeta): AppItem;
-export declare function normalizeActionItem(action: Action): ActionItem;
-/**
- * Prefer public IDs over numeric IDs in a connection item.
- * The API returns extra public_id, account_public_id, and customuser_public_id
- * fields alongside the stringified numeric IDs. This function swaps them in.
- */
-export declare function transformConnectionItem(item: ConnectionItem): ConnectionItem;
-/**
- * Groups app keys by their type based on format patterns
- *
- * @param appKeys Array of app key strings to categorize
- * @returns Object with arrays of keys grouped by type: selectedApi (CLI APIs), slug (everything else)
- *
- * @example
- * groupVersionedAppKeysByType([
- *   'FormatterCLIAPI@1.0.0',
- *   'slack',
- *   'AnotherAPI'
- * ])
- * // Returns: {
- * //   selectedApi: ['FormatterCLIAPI@1.0.0', 'AnotherAPI'],
- * //   slug: ['slack']
- * // }
- */
-export declare function groupVersionedAppKeysByType(appKeys: string[]): {
-    selectedApi: string[];
-    slug: string[];
-};
-export declare function groupAppKeysByType(appKeys: string[]): {
-    selectedApi: string[];
-    slug: string[];
-};
-export declare function isSlug(slug: string): boolean;
-export declare function isSnakeCasedSlug(slug: string): boolean;
-export declare function dashifySnakeCasedSlug(slug: string): string;
-export interface AppLocator {
-    lookupAppKey: string;
-    slug?: string;
-    implementationName?: string;
-    version?: string;
-}
-export interface ResolvedAppLocator extends AppLocator {
-    implementationName: string;
-}
-export declare function isUuid(appKey: string): boolean;
-export declare function toAppLocator(appKey: string): AppLocator;
-export declare function isResolvedAppLocator(appLocator: AppLocator): appLocator is ResolvedAppLocator;
-export declare function toImplementationId(appLocator: ResolvedAppLocator): string;
-export declare function getAppKeyList(app: {
-    key: string;
-    slug: string;
-}): string[];
-//# sourceMappingURL=domain-utils.d.ts.map

package/dist/utils/domain-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"domain-utils.d.ts","sourceRoot":"","sources":["../../src/utils/domain-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAO3E;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,GACN,EAAE;IACD,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC1C,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,CAiCvC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,GACnB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAQ9B;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,kBAAkB,EAAE,kBAAkB,GACrC,OAAO,CAYT;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAsB9D;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,CA8B5E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG;IAC9D,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAgCA;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG;IACrD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAUA;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOtD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAY1D;AAED,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AACD,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAI9C;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAkBvD;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,GACrB,UAAU,IAAI,kBAAkB,CAElC;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAEzE;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CAK1E"}