@zapier/zapier-sdk 0.6.4 → 0.8.0

package/dist/plugins/listInputFieldChoices/index.js

@@ -0,0 +1,78 @@
+import { ListInputFieldChoicesSchema, } from "./schemas";
+import { ZapierApiError } from "../../types/errors";
+import { createPaginatedFunction } from "../../utils/function-utils";
+// Transform NeedChoices to InputFieldChoiceItem
+function transformNeedChoicesToInputFieldChoiceItem(choice) {
+    return {
+        key: choice.key,
+        label: choice.label,
+        sample: choice.sample,
+        value: choice.value,
+    };
+}
+export const listInputFieldChoicesPlugin = ({ context, sdk }) => {
+    const listInputFieldChoices = createPaginatedFunction(async function listInputFieldChoicesPage(options) {
+        const { api } = context;
+        // Extract parameters
+        const { appKey, actionType, actionKey, inputFieldKey, authenticationId, inputs, page, cursor, } = options;
+        // Use sdk.getAction to get the action ID
+        const actionResult = await sdk.getAction({ appKey, actionType, actionKey });
+        const actionId = actionResult.data.id;
+        if (!actionId) {
+            throw new ZapierApiError(`Action ${actionKey} does not have an ID - cannot retrieve input field choices`);
+        }
+        // Build choices request using action ID from getAction
+        // Use cursor (from pagination) as page number if available, otherwise use explicit page or default to 0
+        const requestPage = cursor ? parseInt(cursor, 10) : (page ?? 0);
+        const choicesRequest = {
+            action_id: actionId,
+            input_field_id: inputFieldKey,
+            page: requestPage,
+            params: inputs || {},
+        };
+        // Only include authentication_id if it's not null (skip authentication when null)
+        if (authenticationId !== null) {
+            choicesRequest.authentication_id = authenticationId;
+        }
+        const choicesData = await api.post("/api/v4/implementations/choices/", choicesRequest);
+        if (!choicesData.success) {
+            throw new ZapierApiError(`Failed to get input field choices: ${choicesData.errors?.join(", ") || "Unknown error"}`);
+        }
+        // Transform NeedChoices objects to InputFieldChoiceItem objects
+        const choices = (choicesData.choices || []).map(transformNeedChoicesToInputFieldChoiceItem);
+        // Handle pagination
+        let nextCursor;
+        if (choicesData.next_page !== undefined) {
+            nextCursor = choicesData.next_page.toString();
+        }
+        else if (choicesData.links?.next) {
+            // Extract page from next URL for external actions
+            try {
+                const nextUrl = new URL(choicesData.links.next);
+                const nextPage = nextUrl.searchParams.get("page");
+                if (nextPage) {
+                    nextCursor = nextPage;
+                }
+            }
+            catch {
+                // Handle malformed URLs gracefully by not setting nextCursor
+                nextCursor = undefined;
+            }
+        }
+        return {
+            data: choices,
+            nextCursor,
+        };
+    }, ListInputFieldChoicesSchema);
+    return {
+        listInputFieldChoices,
+        context: {
+            meta: {
+                listInputFieldChoices: {
+                    categories: ["action"],
+                    inputSchema: ListInputFieldChoicesSchema,
+                },
+            },
+        },
+    };
+};

package/dist/plugins/listInputFieldChoices/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/listInputFieldChoices/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFieldChoices/index.test.ts"],"names":[],"mappings":""}

package/dist/plugins/listInputFieldChoices/index.test.js

@@ -0,0 +1,537 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierApiError } from "../../types/errors";
+import { listInputFieldChoicesPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { GetActionSchema } from "../getAction/schemas";
+const mockChoices = [
+    {
+        key: "general",
+        label: "General Channel",
+        sample: "#general",
+        value: "general",
+    },
+    {
+        key: "random",
+        label: "Random Channel",
+        sample: "#random",
+        value: "random",
+    },
+    {
+        key: "dev",
+        label: "Development Channel",
+        sample: "#dev",
+        value: "dev",
+    },
+];
+const mockChoicesResponse = {
+    success: true,
+    choices: mockChoices,
+};
+const mockPaginatedChoicesResponse = {
+    success: true,
+    choices: mockChoices.slice(0, 2),
+    next_page: 1,
+};
+const mockExternalChoicesResponse = {
+    success: true,
+    choices: mockChoices,
+    meta: { page: "0" },
+    links: {
+        next: "https://api.zapier.com/api/v4/implementations/choices/?page=1",
+        prev: null,
+    },
+};
+describe("listInputFieldChoices plugin", () => {
+    let mockApiClient;
+    let mockGetAction;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = {
+            post: vi.fn().mockResolvedValue(mockChoicesResponse),
+        };
+        mockGetAction = vi.fn().mockResolvedValue({
+            data: { id: "core:123", key: "send_message", action_type: "read" },
+        });
+    });
+    function createTestSdk() {
+        // Create a mock getAction plugin
+        const mockGetActionPlugin = () => ({
+            getAction: mockGetAction,
+            context: {
+                meta: {
+                    getAction: {
+                        inputSchema: GetActionSchema,
+                    },
+                },
+            },
+        });
+        // Build SDK with proper plugin composition
+        return createSdk({}, {}, { api: mockApiClient, meta: {} })
+            .addPlugin(mockGetActionPlugin)
+            .addPlugin(listInputFieldChoicesPlugin);
+    }
+    describe("schema validation", () => {
+        it("should throw validation error for missing inputFieldKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    actionKey: "send_message",
+                    // Missing inputFieldKey
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+        it("should throw validation error for missing actionKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    inputFieldKey: "channel",
+                    // Missing actionKey
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+        it("should pass validation with action method", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toBeDefined();
+        });
+        it("should pass validation with optional fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                authenticationId: 456,
+                inputs: { workspace: "my-team" },
+                page: 0,
+            });
+            expect(result.data).toBeDefined();
+        });
+        it("should throw validation error for empty string actionKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    actionKey: "", // Empty string
+                    inputFieldKey: "channel",
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+        it("should throw validation error for empty string inputFieldKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    actionKey: "send_message",
+                    inputFieldKey: "", // Empty string
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+    });
+    describe("API integration - action method", () => {
+        it("should call the correct API endpoint with action method", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(mockGetAction).toHaveBeenCalledWith({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 0,
+                params: {},
+            });
+        });
+        it("should include authentication_id when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                authenticationId: 456,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                authentication_id: 456,
+                page: 0,
+                params: {},
+            });
+        });
+        it("should exclude authentication_id when null", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                authenticationId: null,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 0,
+                params: {},
+                // No authentication_id
+            });
+        });
+        it("should include inputs when provided", async () => {
+            const sdk = createTestSdk();
+            const inputs = { workspace: "my-team", board: "project" };
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                inputs,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 0,
+                params: inputs,
+            });
+        });
+        it("should include page when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                page: 2,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 2,
+                params: {},
+            });
+        });
+    });
+    describe("data transformation", () => {
+        it("should transform choices to input field choice items correctly", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toHaveLength(3);
+            // Check first choice transformation
+            expect(result.data[0]).toEqual({
+                key: "general",
+                label: "General Channel",
+                sample: "#general",
+                value: "general",
+            });
+            // Check second choice transformation
+            expect(result.data[1]).toEqual({
+                key: "random",
+                label: "Random Channel",
+                sample: "#random",
+                value: "random",
+            });
+        });
+        it("should handle choices with missing fields gracefully", async () => {
+            const sparseChoices = [
+                { key: "item1", label: "Item 1" },
+                { value: "item2", sample: "item2" },
+                { label: "Item 3" },
+            ];
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                choices: sparseChoices,
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "item",
+            });
+            expect(result.data).toHaveLength(3);
+            expect(result.data[0]).toEqual({
+                key: "item1",
+                label: "Item 1",
+                sample: undefined,
+                value: undefined,
+            });
+            expect(result.data[1]).toEqual({
+                key: undefined,
+                label: undefined,
+                sample: "item2",
+                value: "item2",
+            });
+        });
+    });
+    describe("pagination handling", () => {
+        it("should handle next_page pagination correctly in the plugin", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockResolvedValue(mockPaginatedChoicesResponse);
+            const sdk = createTestSdk();
+            // Test that the plugin correctly sets nextCursor when next_page is present
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                pageSize: 2, // Set a small page size to test pagination behavior
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBe("1");
+        });
+        it("should handle external action link-based pagination correctly in the plugin", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockResolvedValue(mockExternalChoicesResponse);
+            const sdk = createTestSdk();
+            // Test that the plugin correctly extracts cursor from links.next
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "option",
+                pageSize: 3, // Set a small page size to test pagination behavior
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBe("1"); // Extracted from links.next URL
+        });
+        it("should handle no pagination", async () => {
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBeUndefined();
+        });
+        it("should support async iteration over individual items", async () => {
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            const items = [];
+            for await (const item of listChoicesResult.items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(3);
+            expect(items[0].key).toBe("general");
+        });
+        it("should handle malformed links.next URL gracefully", async () => {
+            const malformedExternalResponse = {
+                success: true,
+                choices: mockChoices,
+                links: {
+                    next: "invalid-url-format", // Malformed URL
+                    prev: null,
+                },
+            };
+            mockApiClient.post = vi.fn().mockResolvedValue(malformedExternalResponse);
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "option",
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break;
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBeUndefined(); // Should handle gracefully
+        });
+        it("should handle links.next URL without page parameter", async () => {
+            const noPageResponse = {
+                success: true,
+                choices: mockChoices,
+                links: {
+                    next: "https://api.zapier.com/api/v4/implementations/choices/", // No page param
+                    prev: null,
+                },
+            };
+            mockApiClient.post = vi.fn().mockResolvedValue(noPageResponse);
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "option",
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break;
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBeUndefined();
+        });
+    });
+    describe("error handling", () => {
+        it("should throw ZapierApiError when API response indicates failure", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                errors: ["Invalid field", "Missing authentication"],
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "invalid_field",
+            })).rejects.toThrow(ZapierApiError);
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "invalid_field",
+            })).rejects.toThrow("Failed to get input field choices: Invalid field, Missing authentication");
+        });
+        it("should handle API errors gracefully", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockRejectedValue(new Error("Network error"));
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Network error");
+        });
+        it("should handle empty choices array response", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                choices: [], // Empty choices
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toEqual([]);
+        });
+        it("should handle missing choices field in response", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                // Missing choices field
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toEqual([]);
+        });
+        it("should treat missing success field as failure", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                // Missing success field (undefined)
+                choices: mockChoices,
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Failed to get input field choices: Unknown error");
+        });
+        it("should handle API response with errors but no error messages", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                // Missing errors field
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Failed to get input field choices: Unknown error");
+        });
+        it("should handle API response with empty errors array", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                errors: [], // Empty errors array
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Failed to get input field choices: Unknown error");
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.listInputFieldChoices).toBeDefined();
+            expect(context.meta.listInputFieldChoices.inputSchema).toBeDefined();
+        });
+    });
+});

package/dist/plugins/listInputFieldChoices/schemas.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import type { PaginatedSdkFunction } from "../../types/functions";
+import type { ZapierConfigurationError, ZapierApiError, ZapierAuthenticationError, ZapierAppNotFoundError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
+export declare const InputFieldChoiceItemSchema: z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    sample: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value?: string | undefined;
+    key?: string | undefined;
+    label?: string | undefined;
+    sample?: string | undefined;
+}, {
+    value?: string | undefined;
+    key?: string | undefined;
+    label?: string | undefined;
+    sample?: string | undefined;
+}>;
+export type InputFieldChoiceItem = z.infer<typeof InputFieldChoiceItemSchema>;
+export declare const ListInputFieldChoicesSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+    inputFieldKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    inputFieldKey: string;
+    page?: number | undefined;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, any> | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    inputFieldKey: string;
+    page?: number | undefined;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, any> | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
+}>;
+export type ListInputFieldChoicesOptions = z.infer<typeof ListInputFieldChoicesSchema>;
+export type ListInputFieldChoicesError = ZapierConfigurationError | ZapierApiError | ZapierAuthenticationError | ZapierAppNotFoundError | ZapierValidationError | ZapierUnknownError;
+export interface ListInputFieldChoicesPage {
+    data: InputFieldChoiceItem[];
+    nextCursor?: string;
+}
+export interface ListInputFieldChoicesSdkFunction {
+    listInputFieldChoices: PaginatedSdkFunction<ListInputFieldChoicesOptions, InputFieldChoiceItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/listInputFieldChoices/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFieldChoices/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EACV,wBAAwB,EACxB,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAM5B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;EAuCtC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCvC,CAAC;AAGF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,2BAA2B,CACnC,CAAC;AAGF,MAAM,MAAM,0BAA0B,GAClC,wBAAwB,GACxB,cAAc,GACd,yBAAyB,GACzB,sBAAsB,GACtB,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,oBAAoB,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,gCAAgC;IAC/C,qBAAqB,EAAE,oBAAoB,CACzC,4BAA4B,EAC5B,oBAAoB,CACrB,CAAC;CACH"}