@zapier/zapier-sdk 0.18.4 → 0.19.0

package/dist/plugins/listActions/index.d.ts

@@ -1,30 +0,0 @@
-import type { Plugin, GetSdkType } from "../../types/plugin";
-import type { ApiClient } from "../../api";
-import type { ActionItem } from "../../types/domain";
-import { ListActionsSchema, type ListActionsOptions } from "./schemas";
-import type { ManifestPluginProvides } from "../manifest";
-import type { GetVersionedImplementationId } from "../manifest/schemas";
-import type { EventEmissionContext } from "../eventEmission";
-export interface ListActionsPluginProvides {
-    listActions: (options?: ListActionsOptions) => Promise<{
-        data: ActionItem[];
-        nextCursor?: string;
-    }> & AsyncIterable<{
-        data: ActionItem[];
-        nextCursor?: string;
-    }> & {
-        items(): AsyncIterable<ActionItem>;
-    };
-    context: {
-        meta: {
-            listActions: {
-                inputSchema: typeof ListActionsSchema;
-            };
-        };
-    };
-}
-export declare const listActionsPlugin: Plugin<GetSdkType<ManifestPluginProvides>, {
-    api: ApiClient;
-    getVersionedImplementationId: GetVersionedImplementationId;
-} & EventEmissionContext, ListActionsPluginProvides>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/listActions/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listActions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EACL,iBAAiB,EACjB,KAAK,kBAAkB,EAExB,MAAM,WAAW,CAAC;AAOnB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAI7D,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE,kBAAkB,KAAK,OAAO,CAAC;QACrD,IAAI,EAAE,UAAU,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,UAAU,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC3D,KAAK,IAAI,aAAa,CAAC,UAAU,CAAC,CAAC;KACpC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,WAAW,EAAE;gBACX,WAAW,EAAE,OAAO,iBAAiB,CAAC;aACvC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CACpC,UAAU,CAAC,sBAAsB,CAAC,EAClC;IACE,GAAG,EAAE,SAAS,CAAC;IACf,4BAA4B,EAAE,4BAA4B,CAAC;CAC5D,GAAG,oBAAoB,EACxB,yBAAyB,CAoG1B,CAAC"}

package/dist/plugins/listActions/index.js

@@ -1,75 +0,0 @@
-import { normalizeActionItem } from "../../utils/domain-utils";
-import { ListActionsSchema, } from "./schemas";
-import { ActionItemSchema } from "../../schemas/Action";
-import { ZapierConfigurationError, ZapierAuthenticationError, } from "../../types/errors";
-import { createPaginatedFunction } from "../../utils/function-utils";
-import { appKeyResolver, actionTypeResolver } from "../../resolvers";
-import { createTelemetryCallback } from "../../utils/telemetry-utils";
-import { stripPageSuffix } from "../../utils/string-utils";
-export const listActionsPlugin = ({ context }) => {
-    const methodMeta = {
-        categories: ["action"],
-        type: "list",
-        itemType: "Action",
-        inputSchema: ListActionsSchema,
-        outputSchema: ActionItemSchema,
-        resolvers: {
-            appKey: appKeyResolver,
-            actionType: actionTypeResolver,
-        },
-    };
-    async function listActionsPage(options) {
-        const { api, getVersionedImplementationId } = context;
-        // Use getVersionedImplementationId (optimized to check manifest first)
-        const selectedApi = await getVersionedImplementationId(options.appKey);
-        if (!selectedApi) {
-            throw new ZapierConfigurationError("No current_implementation_id found for app", { configType: "current_implementation_id" });
-        }
-        const searchParams = {
-            global: "true",
-            public_only: "true",
-            selected_apis: selectedApi,
-        };
-        const data = await api.get("/zapier/api/v4/implementations/", {
-            searchParams,
-            customErrorHandler: ({ status }) => {
-                if (status === 401) {
-                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access implementations or may be expired. (HTTP ${status})`, { statusCode: status });
-                }
-                if (status === 403) {
-                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to list implementations. (HTTP ${status})`, { statusCode: status });
-                }
-                return undefined;
-            },
-        });
-        let allActions = [];
-        for (const implementation of data.results || []) {
-            if (implementation.actions) {
-                for (const action of implementation.actions) {
-                    const actionWithContext = {
-                        ...action,
-                        selected_api: action.selected_api || implementation.selected_api,
-                    };
-                    allActions.push(normalizeActionItem(actionWithContext));
-                }
-            }
-        }
-        if (options.actionType) {
-            allActions = allActions.filter((action) => action.action_type === options.actionType);
-        }
-        return {
-            data: allActions,
-            nextCursor: undefined,
-        };
-    }
-    const methodName = stripPageSuffix(listActionsPage.name);
-    const listActionsDefinition = createPaginatedFunction(listActionsPage, ListActionsSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName), methodName);
-    return {
-        listActions: listActionsDefinition,
-        context: {
-            meta: {
-                listActions: methodMeta,
-            },
-        },
-    };
-};

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

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

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

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

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

@@ -1,453 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierAuthenticationError, ZapierConfigurationError, } from "../../types/errors";
-import { listActionsPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { listAppsPlugin } from "../listApps";
-import { eventEmissionPlugin } from "../eventEmission";
-const mockImplementationsResponse = {
-    results: [
-        {
-            slug: "slack",
-            selected_api: "slack",
-            actions: [
-                {
-                    key: "user_by_email",
-                    name: "Search User by Email",
-                    description: "Find a user by email address",
-                    type_of: "search",
-                    type: "search",
-                },
-                {
-                    key: "send_message",
-                    name: "Send Message",
-                    description: "Send a message to a channel",
-                    type_of: "write",
-                    type: "write",
-                },
-                {
-                    key: "create_channel",
-                    name: "Create Channel",
-                    description: "Create a new channel",
-                    type_of: "write",
-                    type: "write",
-                },
-            ],
-        },
-    ],
-    meta: {
-        next_cursor: null,
-    },
-};
-const mockEmptyImplementationsResponse = {
-    results: [],
-    meta: {
-        next_cursor: null,
-    },
-};
-describe("listActions plugin", () => {
-    let mockApiClient;
-    let mockGetVersionedImplementationId;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApiClient = {
-            get: vi.fn().mockResolvedValue(mockImplementationsResponse),
-        };
-        mockGetVersionedImplementationId = vi
-            .fn()
-            .mockResolvedValue("SlackCLIAPI@1.21.1");
-    });
-    const mockResolveAppKeys = vi.fn().mockResolvedValue([]);
-    function createTestSdk() {
-        // Create a proper plugin chain with context dependencies
-        // Build SDK with proper plugin composition, providing API in initial context
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(() => ({
-            context: {
-                api: mockApiClient,
-            },
-        }))
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(() => ({
-            context: {
-                manifest: null,
-                getVersionedImplementationId: mockGetVersionedImplementationId,
-                resolveAppKeys: mockResolveAppKeys,
-                updateManifestEntry: vi
-                    .fn()
-                    .mockResolvedValue(["test-key", {}, { apps: {} }]),
-                addActionEntry: vi
-                    .fn()
-                    .mockResolvedValue(["test-key", {}, { apps: {} }]),
-                findActionEntry: vi.fn().mockResolvedValue({
-                    key: "test-key",
-                    entry: {},
-                    manifest: { apps: {} },
-                }),
-                hasActionEntry: vi.fn().mockResolvedValue(true),
-                listActionEntries: vi
-                    .fn()
-                    .mockResolvedValue([
-                    [
-                        "test-key",
-                        { key: "test-key", entry: {}, manifest: { apps: {} } },
-                    ],
-                ]),
-                deleteActionEntry: vi.fn().mockResolvedValue({ apps: {} }),
-                findManifestEntry: vi
-                    .fn()
-                    .mockResolvedValue([
-                    "test-key",
-                    { key: "test-key", entry: {}, manifest: { apps: {} } },
-                ]),
-                readManifestFromFile: vi.fn().mockResolvedValue({ apps: {} }),
-            },
-        }))
-            .addPlugin(listAppsPlugin)
-            .addPlugin(listActionsPlugin);
-    }
-    describe("schema validation", () => {
-        it("should pass validation with valid appKey", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            expect(result.data).toHaveLength(3);
-        });
-        it("should throw validation error for missing appKey", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({});
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid appKey type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({
-                    appKey: 123,
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for empty appKey", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({ appKey: "" });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid pageSize", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({ appKey: "slack", pageSize: 0 });
-            }).toThrow(ZapierValidationError);
-            expect(() => {
-                sdk.listActions({ appKey: "slack", pageSize: -5 });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid maxItems", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({ appKey: "slack", maxItems: 0 });
-            }).toThrow(ZapierValidationError);
-            expect(() => {
-                sdk.listActions({ appKey: "slack", maxItems: -10 });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid actionType", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({
-                    appKey: "slack",
-                    actionType: "invalid-type",
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should pass validation with all valid fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({
-                appKey: "slack",
-                actionType: "write",
-                pageSize: 10,
-                maxItems: 50,
-            });
-            expect(result.data).toHaveLength(2); // Only write actions
-            expect(result.data.every((action) => action.action_type === "write")).toBe(true);
-        });
-    });
-    describe("actionType enum validation", () => {
-        const validActionTypes = [
-            "read",
-            "read_bulk",
-            "write",
-            "run",
-            "search",
-            "search_or_write",
-            "search_and_write",
-            "filter",
-        ];
-        validActionTypes.forEach((actionType) => {
-            it(`should accept valid actionType: ${actionType}`, async () => {
-                const mockResponse = {
-                    results: [
-                        {
-                            slug: "slack",
-                            actions: [
-                                {
-                                    key: "test_action",
-                                    name: "Test Action",
-                                    description: "Test description",
-                                    type_of: actionType,
-                                    type: actionType,
-                                },
-                            ],
-                        },
-                    ],
-                    meta: { next_cursor: null },
-                };
-                mockApiClient.get = vi.fn().mockResolvedValue(mockResponse);
-                const sdk = createTestSdk();
-                const result = await sdk.listActions({
-                    appKey: "slack",
-                    actionType: actionType,
-                });
-                expect(result.data).toHaveLength(1);
-                expect(result.data[0].action_type).toBe(actionType);
-            });
-        });
-    });
-    describe("data transformation", () => {
-        it("should transform implementation actions to ActionItem format", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            const firstAction = result.data[0];
-            // Check all required ActionItem fields are present
-            expect(firstAction).toHaveProperty("key");
-            expect(firstAction).toHaveProperty("type", "action");
-            expect(firstAction).toHaveProperty("action_type");
-            expect(firstAction).toHaveProperty("title");
-            expect(firstAction).toHaveProperty("app_key", "slack");
-            expect(firstAction).toHaveProperty("description");
-            // Check that title is mapped from API name field
-            expect(firstAction.title).toBe("Search User by Email");
-            expect(firstAction.app_key).toBe("slack");
-            expect(firstAction.type).toBe("action");
-        });
-        it("should map type_of to action_type", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            expect(result.data[0].action_type).toBe("search"); // From type_of field
-            expect(result.data[1].action_type).toBe("write"); // From type_of field
-        });
-        it("should fall back to type field if type_of is missing", async () => {
-            const mockResponseWithoutTypeOf = {
-                results: [
-                    {
-                        slug: "slack",
-                        actions: [
-                            {
-                                key: "test_action",
-                                name: "Test Action",
-                                description: "Test description",
-                                type: "read", // Only type field, no type_of
-                            },
-                        ],
-                    },
-                ],
-                meta: { next_cursor: null },
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutTypeOf);
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            expect(result.data[0].action_type).toBe("read"); // Falls back to type field
-        });
-        it("should handle actions with read type", async () => {
-            const mockResponseWithoutType = {
-                results: [
-                    {
-                        slug: "slack",
-                        actions: [
-                            {
-                                key: "test_action",
-                                name: "Test Action",
-                                description: "Test description",
-                                type: "read", // Provide the required type field
-                            },
-                        ],
-                    },
-                ],
-                meta: { next_cursor: null },
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutType);
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            expect(result.data[0].action_type).toBe("read"); // Should match provided type
-        });
-    });
-    describe("filtering", () => {
-        it("should filter actions by actionType", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({
-                appKey: "slack",
-                actionType: "write",
-            });
-            expect(result.data).toHaveLength(2);
-            expect(result.data.every((action) => action.action_type === "write")).toBe(true);
-            expect(result.data.map((action) => action.key)).toEqual([
-                "send_message",
-                "create_channel",
-            ]);
-        });
-        it("should return empty array when no actions match filter", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({
-                appKey: "slack",
-                actionType: "filter", // No actions of this type in mock data
-            });
-            expect(result.data).toHaveLength(0);
-        });
-        it("should return all actions when no actionType filter provided", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            expect(result.data).toHaveLength(3); // All actions
-        });
-    });
-    describe("pagination", () => {
-        it("should handle maxItems limit", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({
-                appKey: "slack",
-                maxItems: 2,
-            });
-            expect(result.data).toHaveLength(2); // Limited to maxItems
-        });
-        it("should support async iteration over pages", async () => {
-            const sdk = createTestSdk();
-            const listActions = sdk.listActions({ appKey: "slack" });
-            const pages = [];
-            for await (const page of listActions) {
-                pages.push(page);
-                break; // Just get first page for testing
-            }
-            expect(pages).toHaveLength(1);
-            expect(pages[0].data).toHaveLength(3);
-            expect(pages[0].data[0].key).toBe("user_by_email");
-        });
-        it("should support async iteration over individual items", async () => {
-            const sdk = createTestSdk();
-            const listActions = sdk.listActions({
-                appKey: "slack",
-                maxItems: 2,
-            });
-            const items = [];
-            for await (const item of listActions.items()) {
-                items.push(item);
-            }
-            expect(items).toHaveLength(2);
-            expect(items[0].key).toBe("user_by_email");
-            expect(items[1].key).toBe("send_message");
-        });
-        it("should respect pageSize parameter", async () => {
-            const sdk = createTestSdk();
-            await sdk.listActions({
-                appKey: "slack",
-                pageSize: 10,
-            });
-            // Note: Since listActions doesn't actually use pagination internally,
-            // we just verify it accepts the parameter without error
-            expect(mockApiClient.get).toHaveBeenCalled();
-        });
-    });
-    describe("API integration", () => {
-        it("should call getApp to get implementation ID", async () => {
-            const sdk = createTestSdk();
-            await sdk.listActions({ appKey: "slack" });
-            expect(mockGetVersionedImplementationId).toHaveBeenCalledWith("slack");
-        });
-        it("should pass correct search parameters to implementations API", async () => {
-            const sdk = createTestSdk();
-            await sdk.listActions({ appKey: "slack" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/implementations/", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    global: "true",
-                    public_only: "true",
-                    selected_apis: "SlackCLIAPI@1.21.1",
-                }),
-            }));
-        });
-    });
-    describe("error handling", () => {
-        it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
-            mockGetVersionedImplementationId.mockResolvedValue(null);
-            const sdk = createTestSdk();
-            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierConfigurationError);
-        });
-        it("should throw ZapierConfigurationError when current_implementation_id is empty", async () => {
-            mockGetVersionedImplementationId.mockResolvedValue("");
-            const sdk = createTestSdk();
-            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierConfigurationError);
-        });
-        it("should handle authentication error (401)", async () => {
-            mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
-                if (options.customErrorHandler) {
-                    const error = options.customErrorHandler({ status: 401 });
-                    if (error) {
-                        throw error;
-                    }
-                }
-                throw new Error("Unauthorized");
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierAuthenticationError);
-        });
-        it("should handle forbidden error (403)", async () => {
-            mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
-                if (options.customErrorHandler) {
-                    const error = options.customErrorHandler({ status: 403 });
-                    if (error) {
-                        throw error;
-                    }
-                }
-                throw new Error("Forbidden");
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierAuthenticationError);
-        });
-        it("should return empty array when implementations API returns no results", async () => {
-            mockApiClient.get = vi
-                .fn()
-                .mockResolvedValue(mockEmptyImplementationsResponse);
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            expect(result.data).toHaveLength(0);
-        });
-        it("should handle implementation without actions", async () => {
-            const mockResponseWithoutActions = {
-                results: [
-                    {
-                        slug: "slack",
-                        // No actions property
-                    },
-                ],
-                meta: { next_cursor: null },
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutActions);
-            const sdk = createTestSdk();
-            const result = await sdk.listActions({ appKey: "slack" });
-            expect(result.data).toHaveLength(0);
-        });
-        it("should propagate getVersionedImplementationId errors", async () => {
-            mockGetVersionedImplementationId.mockRejectedValue(new Error("App not found"));
-            const sdk = createTestSdk();
-            await expect(sdk.listActions({ appKey: "nonexistent" })).rejects.toThrow("App not found");
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.listActions).toBeDefined();
-            expect(context.meta.listActions.inputSchema).toBeDefined();
-        });
-    });
-});

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

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import type { ActionItem } from "../../types/domain";
-import type { PaginatedSdkFunction } from "../../types/functions";
-import type { ZapierAuthenticationError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
-export declare const ListActionsSchema: z.ZodObject<{
-    appKey: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
-    };
-    actionType: z.ZodOptional<z.ZodEnum<{
-        search: "search";
-        filter: "filter";
-        read: "read";
-        read_bulk: "read_bulk";
-        run: "run";
-        search_and_write: "search_and_write";
-        search_or_write: "search_or_write";
-        write: "write";
-    }>>;
-    pageSize: z.ZodOptional<z.ZodNumber>;
-    maxItems: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-    _telemetry: z.ZodOptional<z.ZodObject<{
-        isNested: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ListActionsOptions = z.infer<typeof ListActionsSchema>;
-export interface ListActionsPage {
-    data: ActionItem[];
-    nextCursor?: string;
-}
-export type ListActionsError = ZapierAuthenticationError | ZapierValidationError | ZapierUnknownError;
-export interface ListActionsSdkFunction {
-    listActions: PaginatedSdkFunction<ListActionsOptions, ActionItem>;
-}
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listActions/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EACV,yBAAyB,EACzB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAI5B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;iBAqBoB,CAAC;AAGnD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAGnE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,MAAM,gBAAgB,GACxB,yBAAyB,GACzB,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,oBAAoB,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC;CACnE"}

package/dist/plugins/listActions/schemas.js

@@ -1,22 +0,0 @@
-import { z } from "zod";
-import { AppKeyPropertySchema, ActionTypePropertySchema, } from "../../types/properties";
-import { TelemetryMarkerSchema } from "../../utils/function-utils";
-// Pure Zod schema - no resolver metadata!
-export const ListActionsSchema = z
-    .object({
-    appKey: AppKeyPropertySchema.describe("App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"),
-    actionType: ActionTypePropertySchema.optional().describe("Filter actions by type"),
-    pageSize: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Number of actions per page"),
-    maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-    cursor: z.string().optional().describe("Cursor to start from"),
-})
-    .merge(TelemetryMarkerSchema)
-    .describe("List all actions for a specific app");

package/dist/plugins/listApps/index.d.ts

@@ -1,19 +0,0 @@
-import type { GetContextType, Plugin } from "../../types/plugin";
-import { ListAppsSchema, type ListAppsOptions, type ListAppsPage, type AppItem } from "./schemas";
-import type { ManifestPluginProvides } from "../manifest";
-import type { ApiPluginProvides } from "../api";
-import type { EventEmissionContext } from "../eventEmission";
-export interface ListAppsPluginProvides {
-    listApps: (options?: ListAppsOptions) => Promise<ListAppsPage> & AsyncIterable<ListAppsPage> & {
-        items(): AsyncIterable<AppItem>;
-    };
-    context: {
-        meta: {
-            listApps: {
-                inputSchema: typeof ListAppsSchema;
-            };
-        };
-    };
-}
-export declare const listAppsPlugin: Plugin<{}, GetContextType<ApiPluginProvides & ManifestPluginProvides> & EventEmissionContext, ListAppsPluginProvides>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/listApps/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listApps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjE,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EAEpB,KAAK,YAAY,EACjB,KAAK,OAAO,EACb,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAI7D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,YAAY,CAAC,GAC5D,aAAa,CAAC,YAAY,CAAC,GAAG;QAC5B,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;KACjC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,QAAQ,EAAE;gBACR,WAAW,EAAE,OAAO,cAAc,CAAC;aACpC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EACF,cAAc,CAAC,iBAAiB,GAAG,sBAAsB,CAAC,GACxD,oBAAoB,EACtB,sBAAsB,CA+EvB,CAAC"}