@zapier/zapier-sdk 0.48.1 → 0.49.0

package/dist/plugins/triggers/createTriggerInbox/index.d.ts

@@ -0,0 +1,62 @@
+import { CreateTriggerInboxSchema } from "./schemas";
+import type { GetVersionedImplementationId } from "../../manifest/schemas";
+import type { ConnectionsPluginProvides } from "../../connections";
+export declare const createTriggerInboxPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        getVersionedImplementationId: GetVersionedImplementationId;
+    } & ConnectionsPluginProvides["context"];
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    createTriggerInbox: (options?: {
+        app: string;
+        action: string;
+        connection?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        notificationUrl?: string | undefined;
+    } | undefined) => Promise<{
+        data: {
+            id: string;
+            created_at: string;
+            name: string | null;
+            status: string;
+            paused_reason: string | null;
+            notification_url: string | null;
+            subscription: {
+                connection_id: string | number | null;
+                app_key: string;
+                action_key: string;
+                inputs: Record<string, unknown>;
+            };
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            createTriggerInbox: import("../../..").PluginMeta;
+        };
+    };
+};
+export type CreateTriggerInboxPluginProvides = ReturnType<typeof createTriggerInboxPlugin>;
+export { CreateTriggerInboxSchema };
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/triggers/createTriggerInbox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/createTriggerInbox/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAA0B,MAAM,WAAW,CAAC;AAU7E,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAInE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;aAIpB;QACP,4BAA4B,EAAE,4BAA4B,CAAC;KAC5D,GAAG,yBAAyB,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgF/C,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/plugins/triggers/createTriggerInbox/index.js

@@ -0,0 +1,54 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { CreateTriggerInboxSchema, TriggerInboxItemSchema } from "./schemas";
+import { ZapierConfigurationError } from "../../../types/errors";
+import { appKeyResolver, actionKeyResolver, connectionIdResolver, inputsResolver, } from "../../../resolvers";
+import { resolveConnectionId } from "../../../utils/domain-utils";
+import { triggersDefaults } from "../shared";
+export const createTriggerInboxPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "createTriggerInbox",
+    type: "create",
+    itemType: "TriggerInbox",
+    inputSchema: CreateTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    // actionKeyResolver and inputsResolver depend on actionType, which is
+    // always "read" for triggers. Pin it as a constant resolver so it's
+    // seeded into resolvedParams without polluting the user-facing schema
+    // (where it would leak into the SDK method signature and CLI flags).
+    resolvers: {
+        app: appKeyResolver,
+        action: actionKeyResolver,
+        connection: connectionIdResolver,
+        inputs: inputsResolver,
+        actionType: { type: "constant", value: "read" },
+    },
+    handler: async ({ sdk, options }) => {
+        const { api } = sdk.context;
+        const { app: appKey, action: actionKey, connection, inputs = {}, notificationUrl, } = options;
+        const resolvedConnectionId = await resolveConnectionId({
+            connection,
+            resolveConnection: sdk.context.resolveConnection,
+        });
+        const selectedApi = await sdk.context.getVersionedImplementationId(appKey);
+        if (!selectedApi) {
+            throw new ZapierConfigurationError(`No current_implementation_id found for app "${appKey}"`, { configType: "current_implementation_id" });
+        }
+        const requestBody = {
+            subscription: {
+                app_key: selectedApi,
+                action_key: actionKey,
+                inputs,
+            },
+        };
+        if (notificationUrl !== undefined) {
+            requestBody.notification_url = notificationUrl;
+        }
+        if (resolvedConnectionId !== undefined &&
+            resolvedConnectionId !== null) {
+            requestBody.subscription.connection_id = resolvedConnectionId;
+        }
+        const rawResponse = await api.post("/trigger-inbox/api/v1/inboxes", requestBody, { authRequired: true });
+        return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    },
+}));
+export { CreateTriggerInboxSchema };

package/dist/plugins/triggers/createTriggerInbox/schemas.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import { TriggerInboxItemSchema, type TriggerInboxItem } from "../../../schemas/TriggerInbox";
+export declare const CreateTriggerInboxSchema: z.ZodObject<{
+    app: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    action: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+    connection: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    notificationUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateTriggerInboxOptions = z.infer<typeof CreateTriggerInboxSchema> & FunctionOptions;
+export interface CreateTriggerInboxResult {
+    data: TriggerInboxItem;
+}
+export { TriggerInboxItemSchema };
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/triggers/createTriggerInbox/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/createTriggerInbox/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAOhE,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACtB,MAAM,+BAA+B,CAAC;AAKvC,eAAO,MAAM,wBAAwB;;;;;;;;;;iBAkBK,CAAC;AAE3C,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,wBAAwB,CAChC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/plugins/triggers/createTriggerInbox/schemas.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { AppPropertySchema, ActionPropertySchema, ConnectionPropertySchema, InputsPropertySchema, } from "../../../types/properties";
+import { TriggerInboxItemSchema, } from "../../../schemas/TriggerInbox";
+const CreateTriggerInboxDescription = "Create a new trigger inbox subscription with an auto-generated name. Always creates; use ensureTriggerInbox for get-or-create on a stable name.";
+export const CreateTriggerInboxSchema = z
+    .object({
+    app: AppPropertySchema,
+    action: ActionPropertySchema,
+    connection: ConnectionPropertySchema.nullable()
+        .optional()
+        .describe("Connection alias or connection ID. Optional for triggers that don't require auth."),
+    inputs: InputsPropertySchema.optional().describe("Input parameters for the trigger subscription"),
+    notificationUrl: z
+        .string()
+        .url()
+        .optional()
+        .describe("Webhook URL to POST to when new messages arrive"),
+})
+    .describe(CreateTriggerInboxDescription);
+export { TriggerInboxItemSchema };

package/dist/plugins/triggers/deleteTriggerInbox/index.d.ts

@@ -0,0 +1,50 @@
+export declare const deleteTriggerInboxPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    deleteTriggerInbox: (options?: {
+        inbox: string;
+    } | undefined) => Promise<{
+        data: {
+            id: string;
+            created_at: string;
+            name: string | null;
+            status: string;
+            paused_reason: string | null;
+            notification_url: string | null;
+            subscription: {
+                connection_id: string | number | null;
+                app_key: string;
+                action_key: string;
+                inputs: Record<string, unknown>;
+            };
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            deleteTriggerInbox: import("../../..").PluginMeta;
+        };
+    };
+};
+export type DeleteTriggerInboxPluginProvides = ReturnType<typeof deleteTriggerInboxPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/triggers/deleteTriggerInbox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/deleteTriggerInbox/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BpC,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,OAAO,wBAAwB,CAChC,CAAC"}

package/dist/plugins/triggers/deleteTriggerInbox/index.js

@@ -0,0 +1,27 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { DeleteTriggerInboxSchema, TriggerInboxItemSchema } from "./schemas";
+import { triggerInboxResolver } from "../../../resolvers";
+import { resolveTriggerInboxId } from "../utils";
+import { triggersDefaults } from "../shared";
+export const deleteTriggerInboxPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "deleteTriggerInbox",
+    type: "delete",
+    itemType: "TriggerInbox",
+    inputSchema: DeleteTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    resolvers: { inbox: triggerInboxResolver },
+    confirm: "delete",
+    handler: async ({ sdk, options }) => {
+        const { inbox } = options;
+        const inboxId = await resolveTriggerInboxId({
+            api: sdk.context.api,
+            inbox,
+        });
+        const rawResponse = await sdk.context.api.delete(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}`, undefined, {
+            authRequired: true,
+            resource: { type: "trigger_inbox", id: inboxId },
+        });
+        return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    },
+}));

package/dist/plugins/triggers/deleteTriggerInbox/schemas.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { FunctionOptions } from "../../../types/functions";
+import { TriggerInboxItemSchema, type TriggerInboxItem } from "../../../schemas/TriggerInbox";
+export declare const DeleteTriggerInboxSchema: z.ZodObject<{
+    inbox: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("../../..").PositionalMetadata;
+    };
+}, z.core.$strip>;
+export type DeleteTriggerInboxOptions = z.infer<typeof DeleteTriggerInboxSchema> & FunctionOptions;
+export interface DeleteTriggerInboxResult {
+    data: TriggerInboxItem;
+}
+export { TriggerInboxItemSchema };
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/triggers/deleteTriggerInbox/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/deleteTriggerInbox/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhE,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACtB,MAAM,+BAA+B,CAAC;AAEvC,eAAO,MAAM,wBAAwB;;;;iBAIW,CAAC;AAEjD,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,wBAAwB,CAChC,GACC,eAAe,CAAC;AAElB,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/plugins/triggers/deleteTriggerInbox/schemas.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { TriggerInboxPropertySchema } from "../../../types/properties";
+import { TriggerInboxItemSchema, } from "../../../schemas/TriggerInbox";
+export const DeleteTriggerInboxSchema = z
+    .object({
+    inbox: TriggerInboxPropertySchema,
+})
+    .describe("Mark a trigger inbox for deletion");
+export { TriggerInboxItemSchema };

package/dist/plugins/triggers/drainTriggerInbox/index.d.ts

@@ -0,0 +1,213 @@
+import { type DrainTriggerInboxCallback, type DrainTriggerInboxOptions } from "./schemas";
+import type { ApiPluginProvides } from "../../api";
+import type { LeaseTriggerInboxMessagesPluginProvides } from "../leaseTriggerInboxMessages";
+import type { AckTriggerInboxMessagesPluginProvides } from "../ackTriggerInboxMessages";
+import type { ReleaseTriggerInboxMessagesPluginProvides } from "../releaseTriggerInboxMessages";
+import type { LeasedTriggerMessageItem } from "../../../schemas/TriggerMessage";
+export { ZapierAbortDrainSignal, ZapierReleaseTriggerMessageSignal, } from "./schemas";
+interface RunDrainPassOptions {
+    sdk: ApiPluginProvides & LeaseTriggerInboxMessagesPluginProvides & AckTriggerInboxMessagesPluginProvides & ReleaseTriggerInboxMessagesPluginProvides;
+    inboxId: string;
+    onMessage: DrainTriggerInboxCallback;
+    concurrency: number;
+    leaseLimit: number;
+    leaseSeconds: number | undefined;
+    maxMessages: number | undefined;
+    releaseOnError: boolean;
+    continueOnError: boolean;
+    onError: ((err: unknown, msg: LeasedTriggerMessageItem) => void | Promise<void>) | undefined;
+    signal: AbortSignal | undefined;
+    firstFetch: boolean;
+}
+export interface RunDrainPassOutcome {
+    /** True if a callback raised the abort signal during this pass. */
+    abortedFromCallback: boolean;
+    /** Number of items the pipeline marked done (ok or rejected). */
+    processed: number;
+}
+/**
+ * One drain pass through `runBatchedDrainPipeline`. Used directly by
+ * `drainTriggerInbox` (single pass) and as the inner loop body of
+ * `watchTriggerInbox` (called repeatedly with poll backoff between
+ * empty passes).
+ */
+export declare function runDrainPass(options: RunDrainPassOptions): Promise<RunDrainPassOutcome>;
+/**
+ * Validate the per-message callback. `onMessage` is required — no
+ * identity default, since "lease and ack everything in this inbox"
+ * is a footgun on a casual call. JS callers that skip onMessage hit
+ * this guard at runtime; TS callers are rejected at the call site.
+ */
+export declare function requireOnMessage(onMessage: DrainTriggerInboxCallback | undefined): DrainTriggerInboxCallback;
+/**
+ * Compute concurrency and lease size with symmetric defaulting:
+ *
+ *   both unset     -> concurrency=1, leaseLimit=1
+ *   concurrency=N  -> concurrency=N, leaseLimit=N
+ *   leaseLimit=L   -> concurrency=L, leaseLimit=L
+ *   both set       -> use both as given
+ *
+ * The symmetry kills the "set leaseLimit alone, get prefetch
+ * pathology" footgun: a leased message buffer is never larger than
+ * the worker pool that can immediately work it.
+ */
+export declare function resolveConcurrencyAndLease(options: {
+    concurrency?: number;
+    leaseLimit?: number;
+}): {
+    concurrency: number;
+    leaseLimit: number;
+};
+export declare const drainTriggerInboxPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    leaseTriggerInboxMessages: (options?: {
+        inbox: string;
+        leaseLimit?: number | undefined;
+        leaseSeconds?: number | undefined;
+        signal?: AbortSignal | undefined;
+    } | undefined) => Promise<{
+        data: {
+            lease_id: string | null;
+            leased_until: string | null;
+            results: {
+                id: string;
+                created_at: string;
+                status: string;
+                message_attributes: {
+                    lease_count: number;
+                    error_message: string | null;
+                    possible_duplicate_data: boolean;
+                };
+                payload: Record<string, unknown>;
+            }[];
+            inbox_attributes: {
+                status: string;
+                paused_reason: string | null;
+            };
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            leaseTriggerInboxMessages: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    ackTriggerInboxMessages: (options?: {
+        inbox: string;
+        lease: string;
+        messages?: string[] | undefined;
+    } | undefined) => Promise<{
+        data: {
+            acked_id: string | null;
+            results: {
+                id: string;
+                created_at: string;
+                status: string;
+                message_attributes: {
+                    lease_count: number;
+                    error_message: string | null;
+                    possible_duplicate_data: boolean;
+                };
+            }[];
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            ackTriggerInboxMessages: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    releaseTriggerInboxMessages: (options?: {
+        inbox: string;
+        lease: string;
+        messages?: string[] | undefined;
+    } | undefined) => Promise<{
+        data: {
+            released_id: string | null;
+            results: {
+                id: string;
+                created_at: string;
+                status: string;
+                message_attributes: {
+                    lease_count: number;
+                    error_message: string | null;
+                    possible_duplicate_data: boolean;
+                };
+            }[];
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            releaseTriggerInboxMessages: import("../../..").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    drainTriggerInbox: (options: DrainTriggerInboxOptions) => Promise<void>;
+    context: {
+        meta: {
+            drainTriggerInbox: {
+                type: "create";
+                description: string;
+                itemType: string;
+                returnType: string;
+                inputSchema: import("zod").ZodObject<{
+                    inbox: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../../..").PositionalMetadata;
+                    };
+                    onMessage: import("zod").ZodOptional<import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>>;
+                    concurrency: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    leaseLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    leaseSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    releaseOnError: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    continueOnError: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    onError: import("zod").ZodOptional<import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>>;
+                    signal: import("zod").ZodOptional<import("zod").ZodCustom<AbortSignal, AbortSignal>>;
+                    maxMessages: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>;
+                resolvers: {
+                    inbox: import("../../..").DynamicResolver<{
+                        id: string;
+                        created_at: string;
+                        name: string | null;
+                        status: string;
+                        paused_reason: string | null;
+                        notification_url: string | null;
+                        subscription: {
+                            connection_id: string | number | null;
+                            app_key: string;
+                            action_key: string;
+                            inputs: Record<string, unknown>;
+                        };
+                    }, {}>;
+                };
+                packages: readonly ["sdk"];
+                categories: string[];
+                experimental: true;
+            };
+        };
+    };
+};
+export type DrainTriggerInboxPluginProvides = ReturnType<typeof drainTriggerInboxPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/triggers/drainTriggerInbox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/drainTriggerInbox/index.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,8BAA8B,CAAC;AAC5F,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,4BAA4B,CAAC;AACxF,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,gCAAgC,CAAC;AAGhG,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAMhF,OAAO,EACL,sBAAsB,EACtB,iCAAiC,GAClC,MAAM,WAAW,CAAC;AAcnB,UAAU,mBAAmB;IAC3B,GAAG,EAAE,iBAAiB,GACpB,uCAAuC,GACvC,qCAAqC,GACrC,yCAAyC,CAAC;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,yBAAyB,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,EACH,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,wBAAwB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GACvE,SAAS,CAAC;IACd,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IAChC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,mEAAmE;IACnE,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CAsI9B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,yBAAyB,GAAG,SAAS,GAC/C,yBAAyB,CAK3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAI9C;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAQrB,wBAAwB,KAChC,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDnB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,UAAU,CACtD,OAAO,uBAAuB,CAC/B,CAAC"}