@zapier/zapier-sdk 0.4.1 → 0.5.1

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

@@ -0,0 +1,564 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierAuthenticationError, } from "../../types/errors";
+import { listAuthenticationsPlugin } from "./index";
+import { createSdk } from "../../sdk";
+const mockAuthenticationsResponse = {
+    results: [
+        {
+            id: 123,
+            date: "2021-01-01",
+            account_id: 456,
+            selected_api: "SlackCLIAPI@1.21.1",
+            is_invite_only: false,
+            is_private: false,
+            shared_with_all: false,
+            is_stale: "false",
+            marked_stale_at: null,
+            label: "My Slack Workspace",
+            title: "My Slack Workspace",
+        },
+        {
+            id: 789,
+            date: "2021-02-01",
+            account_id: 456,
+            selected_api: "GitHubAPI@2.1.0",
+            is_invite_only: false,
+            is_private: false,
+            shared_with_all: true,
+            is_stale: "true",
+            marked_stale_at: "2021-06-01",
+            label: "GitHub Integration",
+            title: "GitHub Integration",
+        },
+    ],
+    count: 2,
+    next: null,
+    previous: null,
+};
+const mockSlackApp = {
+    data: {
+        id: 1,
+        key: "slack",
+        title: "Slack",
+        hex_color: "#000000",
+        age_in_days: "100",
+        api_docs_url: "https://slack.com/api-docs",
+        app_profile_url: "https://slack.com",
+        banner: "https://slack.com/banner.png",
+        categories: [],
+        canonical_id: "slack",
+        zap_usage_count: 100,
+        zap_usage_count_last_updated: "2021-01-01",
+        zap_usage_count_last_updated_by: "user1",
+        zap_usage_count_last_updated_by_id: 123,
+        current_implementation_id: "SlackCLIAPI@1.21.1",
+    },
+};
+describe("listAuthentications plugin", () => {
+    let mockApiClient;
+    let mockGetApp;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = {
+            get: vi.fn().mockResolvedValue(mockAuthenticationsResponse),
+        };
+        mockGetApp = vi.fn().mockResolvedValue(mockSlackApp);
+    });
+    function createTestSdk() {
+        return createSdk({ getApp: mockGetApp }, // Provide getApp in SDK
+        { api: mockApiClient, meta: {} }).addPlugin(listAuthenticationsPlugin);
+    }
+    describe("schema validation", () => {
+        it("should pass validation with empty options", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            expect(result.data).toHaveLength(2);
+        });
+        it("should handle undefined options", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications();
+            expect(result.data).toHaveLength(2);
+            expect(result.data[0]).toMatchObject({
+                id: 123,
+            });
+        });
+        it("should throw validation error for invalid appKey type", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listAuthentications({
+                    appKey: 123,
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid search type", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listAuthentications({
+                    search: 123,
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid title type", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listAuthentications({
+                    title: 123,
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid account_id type", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listAuthentications({
+                    account_id: 123,
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid owner type", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listAuthentications({
+                    owner: 123,
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid pageSize", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listAuthentications({
+                    pageSize: 0, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+            expect(() => {
+                sdk.listAuthentications({
+                    pageSize: -5, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid maxItems", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listAuthentications({
+                    maxItems: 0, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+            expect(() => {
+                sdk.listAuthentications({
+                    maxItems: -10, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all valid fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({
+                appKey: "slack",
+                search: "workspace",
+                title: "My Slack Workspace",
+                account_id: "acc_123",
+                owner: "me",
+                pageSize: 10,
+                maxItems: 50,
+            });
+            expect(result.data).toBeDefined();
+        });
+    });
+    describe("data mapping", () => {
+        it("should map is_stale to is_expired and marked_stale_at to expired_at", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            expect(result.data[0].is_expired).toBe("false");
+            expect(result.data[0].expired_at).toBe(null);
+            expect(result.data[1].is_expired).toBe("true");
+            expect(result.data[1].expired_at).toBe("2021-06-01");
+        });
+        it("should coerce title from label when title is missing", async () => {
+            const responseWithoutTitle = {
+                ...mockAuthenticationsResponse,
+                results: [
+                    {
+                        ...mockAuthenticationsResponse.results[0],
+                        title: undefined,
+                        label: "Label Only Auth",
+                    },
+                ],
+            };
+            mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutTitle);
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            expect(result.data[0].title).toBe("Label Only Auth");
+        });
+        it("should handle authentications with neither title nor label", async () => {
+            const responseWithoutTitleOrLabel = {
+                ...mockAuthenticationsResponse,
+                results: [
+                    {
+                        ...mockAuthenticationsResponse.results[0],
+                        title: undefined,
+                        label: undefined,
+                    },
+                ],
+            };
+            mockApiClient.get = vi
+                .fn()
+                .mockResolvedValue(responseWithoutTitleOrLabel);
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            expect(result.data[0].title).toBeUndefined();
+        });
+    });
+    describe("filtering", () => {
+        it("should filter by exact title match", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({
+                title: "My Slack Workspace",
+            });
+            // Should filter to exact match
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0].title).toBe("My Slack Workspace");
+        });
+        it("should use search parameter when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ search: "workspace" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    search: "workspace",
+                }),
+            }));
+        });
+        it("should use title as search when search not provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ title: "My Slack Workspace" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    search: "My Slack Workspace",
+                }),
+            }));
+        });
+        it("should prefer search over title when both provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({
+                search: "explicit search",
+                title: "My Title",
+            });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    search: "explicit search",
+                }),
+            }));
+        });
+        it("should pass account_id filter to API", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ account_id: "acc_123" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    account_id: "acc_123",
+                }),
+            }));
+        });
+        it("should pass owner filter to API", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ owner: "me" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    owner: "me",
+                }),
+            }));
+        });
+    });
+    describe("pagination", () => {
+        it("should handle pagination with maxItems by collecting all items", async () => {
+            // Mock multiple pages - first page has 2 items, second page has 1 item
+            mockApiClient.get = vi
+                .fn()
+                .mockResolvedValueOnce({
+                results: mockAuthenticationsResponse.results,
+                count: 3,
+                next: "http://example.com/api/v4/authentications/?offset=2",
+            })
+                .mockResolvedValueOnce({
+                results: [
+                    {
+                        id: 999,
+                        date: "2021-03-01",
+                        account_id: 456,
+                        selected_api: "DropboxAPI@3.0.0",
+                        is_invite_only: false,
+                        is_private: false,
+                        shared_with_all: false,
+                        is_stale: "false",
+                        marked_stale_at: null,
+                        title: "Dropbox Integration",
+                    },
+                ],
+                count: 3,
+                next: null,
+            });
+            const sdk = createTestSdk();
+            // Collect all items using the items() iterator
+            const items = [];
+            for await (const item of sdk
+                .listAuthentications({ maxItems: 3 })
+                .items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(3); // Should stop at maxItems
+            expect(mockApiClient.get).toHaveBeenCalledTimes(2); // Should fetch both pages
+        });
+        it("should return first page when awaited", async () => {
+            mockApiClient.get = vi.fn().mockResolvedValue({
+                results: mockAuthenticationsResponse.results,
+                count: 2,
+                next: null, // No more pages to prevent automatic fetching
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            // Await returns first page only
+            expect(result.data).toHaveLength(2);
+            expect(mockApiClient.get).toHaveBeenCalledTimes(1);
+        });
+        it("should support async iteration over pages", async () => {
+            mockApiClient.get = vi
+                .fn()
+                .mockResolvedValueOnce({
+                results: mockAuthenticationsResponse.results.slice(0, 1),
+                count: 2,
+                next: "http://example.com/api/v4/authentications/?offset=1",
+            })
+                .mockResolvedValueOnce({
+                results: mockAuthenticationsResponse.results.slice(1, 2),
+                count: 2,
+                next: null,
+            });
+            const sdk = createTestSdk();
+            const pages = [];
+            for await (const page of sdk.listAuthentications({ pageSize: 1 })) {
+                pages.push(page);
+                if (pages.length >= 2)
+                    break;
+            }
+            expect(pages).toHaveLength(2);
+            expect(pages[0].data).toHaveLength(1);
+            expect(pages[1].data).toHaveLength(1);
+            expect(pages[0].data[0].id).toBe(123);
+            expect(pages[1].data[0].id).toBe(789);
+        });
+        it("should support async iteration over individual items", async () => {
+            const sdk = createTestSdk();
+            const items = [];
+            for await (const item of sdk
+                .listAuthentications({ maxItems: 2 })
+                .items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(2);
+            expect(items[0].id).toBe(123);
+            expect(items[1].id).toBe(789);
+        });
+        it("should set appropriate pageSize for API calls", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ pageSize: 1 });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    limit: "1",
+                }),
+            }));
+        });
+    });
+    describe("API integration", () => {
+        it("should call the correct API endpoint", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({});
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.any(Object));
+        });
+        it("should pass pageSize as limit parameter", async () => {
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ pageSize: 25 });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    limit: "25",
+                }),
+            }));
+        });
+        it("should handle cursor-based pagination internally", async () => {
+            mockApiClient.get = vi
+                .fn()
+                .mockResolvedValueOnce({
+                results: mockAuthenticationsResponse.results.slice(0, 1),
+                count: 2,
+                next: "http://example.com/api/v4/authentications/?offset=1",
+            })
+                .mockResolvedValueOnce({
+                results: mockAuthenticationsResponse.results.slice(1, 2),
+                count: 2,
+                next: null,
+            });
+            const sdk = createTestSdk();
+            // Test that the function can handle multiple pages
+            let pageCount = 0;
+            for await (const _page of sdk.listAuthentications({ pageSize: 1 })) {
+                pageCount++;
+                if (pageCount >= 2)
+                    break;
+            }
+            expect(pageCount).toBe(2);
+            expect(mockApiClient.get).toHaveBeenCalledTimes(2);
+            // The second call should include the offset from the cursor
+            expect(mockApiClient.get).toHaveBeenNthCalledWith(2, "/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    offset: "1",
+                }),
+            }));
+        });
+    });
+    describe("error handling", () => {
+        it("should throw ZapierAuthenticationError for 401 responses", async () => {
+            const customErrorHandler = vi
+                .fn()
+                .mockReturnValue(new ZapierAuthenticationError("Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP 401)", { statusCode: 401 }));
+            mockApiClient.get = vi.fn().mockImplementation(() => {
+                const error = customErrorHandler({ status: 401 });
+                throw error;
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listAuthentications({})).rejects.toThrow(ZapierAuthenticationError);
+        });
+        it("should throw ZapierAuthenticationError for 403 responses", async () => {
+            const customErrorHandler = vi
+                .fn()
+                .mockReturnValue(new ZapierAuthenticationError("Access forbidden. Your token may not have the required scopes to list authentications. (HTTP 403)", { statusCode: 403 }));
+            mockApiClient.get = vi.fn().mockImplementation(() => {
+                const error = customErrorHandler({ status: 403 });
+                throw error;
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listAuthentications({})).rejects.toThrow(ZapierAuthenticationError);
+        });
+        it("should handle empty results", async () => {
+            const emptyResponse = {
+                results: [],
+                count: 0,
+                next: null,
+            };
+            mockApiClient.get = vi.fn().mockResolvedValue(emptyResponse);
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            expect(result.data).toHaveLength(0);
+            expect(Array.isArray(result.data)).toBe(true);
+        });
+        it("should handle missing results field", async () => {
+            const responseWithoutResults = {
+                count: 0,
+                next: null,
+            };
+            mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutResults);
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            expect(result.data).toHaveLength(0);
+            expect(Array.isArray(result.data)).toBe(true);
+        });
+    });
+    describe("app key integration", () => {
+        it("should handle app without current_implementation_id", async () => {
+            const appWithoutImplementation = {
+                data: {
+                    id: 123,
+                    key: "slack",
+                    title: "Slack",
+                    current_implementation_id: undefined,
+                },
+            };
+            mockGetApp.mockResolvedValue(appWithoutImplementation);
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ appKey: "slack" });
+            // Should not add versionless_selected_api parameter
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.not.objectContaining({
+                    versionless_selected_api: expect.any(String),
+                }),
+            }));
+        });
+        it("should extract versionless API from versioned implementation ID", async () => {
+            const appWithVersionedApi = {
+                data: {
+                    id: 123,
+                    key: "slack",
+                    title: "Slack",
+                    current_implementation_id: "SlackCLIAPI@2.1.3",
+                },
+            };
+            mockGetApp.mockResolvedValue(appWithVersionedApi);
+            const sdk = createTestSdk();
+            await sdk.listAuthentications({ appKey: "slack" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/authentications/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    versionless_selected_api: "SlackCLIAPI",
+                }),
+            }));
+        });
+    });
+    describe("response transformation", () => {
+        it("should preserve all original authentication fields", async () => {
+            const authWithAllFields = {
+                results: [
+                    {
+                        id: 123,
+                        date: "2021-01-01",
+                        lastchanged: "2021-01-02",
+                        account_id: 456,
+                        customuser_id: 789,
+                        selected_api: "SlackCLIAPI@1.21.1",
+                        destination_selected_api: "SlackDestAPI@1.0.0",
+                        is_invite_only: true,
+                        is_private: true,
+                        shared_with_all: false,
+                        is_stale: "true",
+                        is_shared: "false",
+                        marked_stale_at: "2021-06-01",
+                        label: "Auth Label",
+                        title: "Auth Title",
+                        identifier: "auth-identifier",
+                        url: "https://example.com",
+                        groups: "group1,group2",
+                        members: "user1,user2",
+                        permissions: { read: true, write: false },
+                    },
+                ],
+                count: 1,
+            };
+            mockApiClient.get = vi.fn().mockResolvedValue(authWithAllFields);
+            const sdk = createTestSdk();
+            const result = await sdk.listAuthentications({});
+            const auth = result.data[0];
+            // Verify original fields are preserved
+            expect(auth.id).toBe(123);
+            expect(auth.date).toBe("2021-01-01");
+            expect(auth.lastchanged).toBe("2021-01-02");
+            expect(auth.account_id).toBe(456);
+            expect(auth.user_id).toBe(789);
+            expect(auth.implementation_id).toBe("SlackCLIAPI@1.21.1");
+            expect(auth.destination_selected_api).toBe("SlackDestAPI@1.0.0");
+            expect(auth.is_invite_only).toBe(true);
+            expect(auth.is_private).toBe(true);
+            expect(auth.shared_with_all).toBe(false);
+            expect(auth.is_shared).toBe("false");
+            expect(auth.label).toBe("Auth Label");
+            expect(auth.title).toBe("Auth Title");
+            expect(auth.identifier).toBe("auth-identifier");
+            expect(auth.url).toBe("https://example.com");
+            expect(auth.groups).toBe("group1,group2");
+            expect(auth.members).toBe("user1,user2");
+            expect(auth.permissions).toEqual({ read: true, write: false });
+            // Verify mapped fields
+            expect(auth.is_expired).toBe("true");
+            expect(auth.expired_at).toBe("2021-06-01");
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.listAuthentications).toBeDefined();
+            expect(context.meta.listAuthentications.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import type { PaginatedSdkFunction } from "../../types/functions";
+import type { AuthenticationItem } from "../../types/domain";
+export declare const ListAuthenticationsSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    search?: string | undefined;
+    account_id?: string | undefined;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    appKey?: string | undefined;
+    owner?: string | undefined;
+}, {
+    title?: string | undefined;
+    search?: string | undefined;
+    account_id?: string | undefined;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    appKey?: string | undefined;
+    owner?: string | undefined;
+}>;
+export type ListAuthenticationsOptions = z.infer<typeof ListAuthenticationsSchema>;
+export interface ListAuthenticationsPage {
+    data: AuthenticationItem[];
+    nextCursor?: string;
+}
+export type ListAuthenticationsError = import("../../types/errors").ZapierAuthenticationError | import("../../types/errors").ZapierApiError | import("../../types/errors").ZapierAppNotFoundError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierUnknownError;
+export interface ListAuthenticationsSdkFunction {
+    listAuthentications: PaginatedSdkFunction<ListAuthenticationsOptions, AuthenticationItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listAuthentications/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;EA0B+B,CAAC;AAGtE,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,yBAAyB,CACjC,CAAC;AAGF,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,kBAAkB,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,MAAM,wBAAwB,GAChC,OAAO,oBAAoB,EAAE,yBAAyB,GACtD,OAAO,oBAAoB,EAAE,cAAc,GAC3C,OAAO,oBAAoB,EAAE,sBAAsB,GACnD,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,8BAA8B;IAC7C,mBAAmB,EAAE,oBAAoB,CACvC,0BAA0B,EAC1B,kBAAkB,CACnB,CAAC;CACH"}

package/dist/plugins/listAuthentications/schemas.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { AppKeyPropertySchema } from "../../types/properties";
+// Pure Zod schema - no resolver metadata!
+export const ListAuthenticationsSchema = z
+    .object({
+    appKey: AppKeyPropertySchema.optional().describe("App key of authentications to list (e.g., 'SlackCLIAPI')"),
+    search: z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+    account_id: z.string().optional().describe("Filter by account ID"),
+    owner: z.string().optional().describe("Filter by owner"),
+    pageSize: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Number of authentications per page"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+})
+    .describe("List available authentications with optional filtering");

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

@@ -0,0 +1,28 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import type { InputFieldItem } from "../../types/domain";
+import { ListInputFieldsSchema, type ListInputFieldsOptions } from "./schemas";
+import type { GetAppPluginProvides } from "../getApp";
+export interface ListInputFieldsPluginProvides {
+    listInputFields: (options?: ListInputFieldsOptions) => Promise<{
+        data: InputFieldItem[];
+    }> & AsyncIterable<{
+        data: InputFieldItem[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<InputFieldItem>;
+    };
+    context: {
+        meta: {
+            listInputFields: {
+                inputSchema: typeof ListInputFieldsSchema;
+            };
+        };
+    };
+}
+export declare const listInputFieldsPlugin: Plugin<GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
+{
+    api: ApiClient;
+}, // requires api in context
+ListInputFieldsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFields/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EACL,qBAAqB,EACrB,KAAK,sBAAsB,EAE5B,MAAM,WAAW,CAAC;AAGnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAkGtD,MAAM,WAAW,6BAA6B;IAC5C,eAAe,EAAE,CAAC,OAAO,CAAC,EAAE,sBAAsB,KAAK,OAAO,CAAC;QAC7D,IAAI,EAAE,cAAc,EAAE,CAAC;KACxB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,cAAc,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAC/D,KAAK,IAAI,aAAa,CAAC,cAAc,CAAC,CAAC;KACxC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,eAAe,EAAE;gBACf,WAAW,EAAE,OAAO,qBAAqB,CAAC;aAC3C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,UAAU,CAAC,oBAAoB,CAAC,EAAE,yBAAyB;AAC3D;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,6BAA6B,CA2E9B,CAAC"}