@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/temporary-internal-core/handlers/listApps.d.ts

@@ -1,67 +0,0 @@
-/**
- * Handler for listApps operation
- *
- * This handler will become an SDK API endpoint handler.
- * It encapsulates the business logic for listing apps, including:
- * - Search augmentation (merging search results with specified apps)
- * - API calls to internal services
- * - Response transformation
- * - Pagination with latest_only support
- *
- * Note: App key resolution (slugs → implementation IDs) happens in the SDK plugin.
- * The handler receives pre-resolved implementation IDs and performs search augmentation.
- */
-import type { Handler, HandlerDeps } from "../types";
-import { type ListAppsHandlerRequest, type ListAppsResponse } from "../schemas/apps";
-/**
- * Simple HTTP client interface for calling internal APIs
- *
- * Why pass this as a dependency instead of importing directly?
- *
- * 1. **Different implementations in different contexts:**
- *    - In the SDK: Uses the ApiClient wrapper (adds auth, error handling, etc.)
- *    - In the SDK API: Would use internal HTTP client or direct service calls
- *
- * 2. **Testability:**
- *    - Can mock httpClient in tests without complex setup
- *    - Can verify API calls and responses in isolation
- *
- * 3. **No hard coupling:**
- *    - Handler doesn't know/care how HTTP calls are made
- *    - Makes migration to SDK API easier (just swap implementation)
- */
-export interface HttpClient {
-    get<T = unknown>(path: string, options?: {
-        searchParams?: Record<string, string>;
-    }): Promise<T>;
-}
-/**
- * Dependencies required by the listApps handler
- *
- * Passed as a parameter (dependency injection) rather than imported directly
- * to allow different implementations in different environments:
- * - SDK plugin injects: { httpClient: api } (SDK's ApiClient)
- * - SDK API would inject: { httpClient: internalHttpClient } (direct internal calls)
- * - Tests inject: { httpClient: mockHttpClient } (mocked responses)
- *
- * Extends HandlerDeps to ensure compatibility with the Handler interface.
- */
-export interface ListAppsHandlerDeps extends HandlerDeps {
-    httpClient: HttpClient;
-}
-/**
- * Handles listApps operation
- *
- * Conforms to the Handler<TRequest, TResponse, TDeps> interface contract.
- * Validates and normalizes the request at the handler boundary before processing.
- *
- * Accepts flexible input types (via schema):
- * - implementationIds: string (comma-separated) or string[]
- * - pageSize: string or number
- *
- * @param request - The request with pre-resolved implementation IDs (handler performs search augmentation)
- * @param deps - Dependencies injected by the caller (see ListAppsHandlerDeps for why we use DI)
- * @returns Paginated list of apps with normalized data
- */
-export declare const handleListApps: Handler<ListAppsHandlerRequest, ListAppsResponse, ListAppsHandlerDeps>;
-//# sourceMappingURL=listApps.d.ts.map

package/dist/temporary-internal-core/handlers/listApps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"listApps.d.ts","sourceRoot":"","sources":["../../../src/temporary-internal-core/handlers/listApps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AAkBzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,CAAC,GAAG,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GAClD,OAAO,CAAC,CAAC,CAAC,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,UAAU,EAAE,UAAU,CAAC;CACxB;AA2ED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,CAClC,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,CA+EpB,CAAC"}

package/dist/temporary-internal-core/handlers/listApps.js

@@ -1,134 +0,0 @@
-/**
- * Handler for listApps operation
- *
- * This handler will become an SDK API endpoint handler.
- * It encapsulates the business logic for listing apps, including:
- * - Search augmentation (merging search results with specified apps)
- * - API calls to internal services
- * - Response transformation
- * - Pagination with latest_only support
- *
- * Note: App key resolution (slugs → implementation IDs) happens in the SDK plugin.
- * The handler receives pre-resolved implementation IDs and performs search augmentation.
- */
-import { ListAppsHandlerRequestSchema, } from "../schemas/apps";
-import { splitVersionedKey } from "../utils/string-utils";
-import { transformImplementationMetaToAppItem, extractPaginationCursor, } from "../utils/transformations";
-// ============================================================================
-// Constants
-// ============================================================================
-const DEFAULT_PAGE_SIZE = 20;
-// ============================================================================
-// Business Logic Helpers
-// ============================================================================
-/**
- * Augments implementation IDs with search results
- *
- * Calls the search endpoint and merges results with existing implementation IDs,
- * deduplicating by implementation name (without version) and preferring public versions.
- */
-async function augmentWithSearchResults({ searchTerm, implementationIds, httpClient, }) {
-    const searchResponse = await httpClient.get("/zapier/api/v4/implementations-meta/search/", {
-        searchParams: { term: searchTerm },
-    });
-    // Deduplicate by implementation name, preferring public versions
-    // This ensures that when a user has access to both a private version (e.g., 1.0.17)
-    // and a public version (e.g., 1.1.0), we use the public one for search results
-    const byImplementationName = new Map();
-    for (const result of searchResponse.results) {
-        const [implementationName] = splitVersionedKey(result.id);
-        const isPublic = result.visibility === "public";
-        const existing = byImplementationName.get(implementationName);
-        // Take this result if we don't have one yet, or if this one is public and existing is not
-        if (!existing || (isPublic && !existing.isPublic)) {
-            byImplementationName.set(implementationName, { result, isPublic });
-        }
-    }
-    const searchResults = Array.from(byImplementationName.values()).map((entry) => transformImplementationMetaToAppItem(entry.result));
-    const implementationNameSet = new Set(implementationIds.map((id) => {
-        const [name] = splitVersionedKey(id);
-        return name;
-    }));
-    const additionalIds = [];
-    for (const result of searchResults) {
-        const [implementationName] = splitVersionedKey(result.key);
-        if (!implementationNameSet.has(implementationName)) {
-            implementationNameSet.add(implementationName);
-            // Use the full implementation_id from the result
-            additionalIds.push(result.implementation_id);
-        }
-    }
-    return [...implementationIds, ...additionalIds];
-}
-// ============================================================================
-// Main Handler
-// ============================================================================
-/**
- * Handles listApps operation
- *
- * Conforms to the Handler<TRequest, TResponse, TDeps> interface contract.
- * Validates and normalizes the request at the handler boundary before processing.
- *
- * Accepts flexible input types (via schema):
- * - implementationIds: string (comma-separated) or string[]
- * - pageSize: string or number
- *
- * @param request - The request with pre-resolved implementation IDs (handler performs search augmentation)
- * @param deps - Dependencies injected by the caller (see ListAppsHandlerDeps for why we use DI)
- * @returns Paginated list of apps with normalized data
- */
-export const handleListApps = async ({ request, deps }) => {
-    // Validate and normalize request at handler boundary
-    // Schema automatically normalizes:
-    // - implementationIds: string → string[]
-    // - pageSize: string → number
-    const validatedRequest = ListAppsHandlerRequestSchema.parse(request);
-    const { httpClient } = deps;
-    let { implementationIds } = validatedRequest;
-    const pageSize = validatedRequest.pageSize ?? DEFAULT_PAGE_SIZE;
-    if (validatedRequest.search) {
-        implementationIds = await augmentWithSearchResults({
-            searchTerm: validatedRequest.search,
-            implementationIds,
-            httpClient,
-        });
-    }
-    if (implementationIds.length === 0) {
-        // If search was provided but found nothing, return empty (bug fix)
-        if (validatedRequest.search) {
-            return {
-                data: [],
-                nextCursor: undefined,
-            };
-        }
-        const searchParams = {
-            latest_only: "true",
-            selected_apis: "",
-            limit: pageSize.toString(),
-        };
-        if (validatedRequest.cursor) {
-            searchParams.offset = validatedRequest.cursor;
-        }
-        const implementationsResponse = await httpClient.get("/zapier/api/v4/implementations-meta/lookup/", {
-            searchParams,
-        });
-        return {
-            data: implementationsResponse.results.map(transformImplementationMetaToAppItem),
-            nextCursor: extractPaginationCursor(implementationsResponse),
-        };
-    }
-    const searchParams = {
-        selected_apis: implementationIds.join(","),
-        limit: pageSize.toString(),
-    };
-    if (validatedRequest.cursor) {
-        searchParams.offset = validatedRequest.cursor;
-    }
-    const implementationsResponse = await httpClient.get("/zapier/api/v4/implementations-meta/lookup/", {
-        searchParams,
-    });
-    return {
-        data: implementationsResponse.results.map(transformImplementationMetaToAppItem),
-        nextCursor: extractPaginationCursor(implementationsResponse),
-    };
-};

package/dist/temporary-internal-core/handlers/listApps.test.d.ts

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

package/dist/temporary-internal-core/handlers/listApps.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"listApps.test.d.ts","sourceRoot":"","sources":["../../../src/temporary-internal-core/handlers/listApps.test.ts"],"names":[],"mappings":""}

package/dist/temporary-internal-core/handlers/listApps.test.js

@@ -1,367 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { handleListApps, } from "./listApps";
-import { ListAppsResponseSchema, } from "../schemas/apps";
-describe("handleListApps", () => {
-    const mockImplementation = (id, name, visibility = "public") => ({
-        id,
-        name,
-        slug: name.toLowerCase().replace(/\s+/g, "-"),
-        description: `${name} description`,
-        primary_color: "#000000",
-        categories: [{ id: 1, name: "test", slug: "test" }],
-        visibility,
-    });
-    describe("pageSize handling", () => {
-        it("should use default pageSize of 20 when not provided", async () => {
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue({
-                    count: 0,
-                    results: [],
-                }),
-            };
-            await handleListApps({
-                request: {
-                    implementationIds: [],
-                    search: undefined,
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    limit: "20",
-                }),
-            }));
-        });
-        it("should use custom pageSize when provided", async () => {
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue({
-                    count: 0,
-                    results: [],
-                }),
-            };
-            await handleListApps({
-                request: {
-                    implementationIds: [],
-                    search: undefined,
-                    pageSize: 50,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    limit: "50",
-                }),
-            }));
-        });
-    });
-    describe("empty implementation IDs handling", () => {
-        it("should fetch all apps when no implementationIds and no search", async () => {
-            const mockResponse = {
-                count: 2,
-                results: [
-                    mockImplementation("SlackCLIAPI@1.0.0", "Slack"),
-                    mockImplementation("GitHubCLIAPI@1.0.0", "GitHub"),
-                ],
-            };
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue(mockResponse),
-            };
-            const result = await handleListApps({
-                request: {
-                    implementationIds: [],
-                    search: undefined,
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            expect(result.data).toHaveLength(2);
-            expect(mockHttpClient.get).toHaveBeenCalledWith("/zapier/api/v4/implementations-meta/lookup/", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    latest_only: "true",
-                    selected_apis: "",
-                }),
-            }));
-        });
-        it("should return empty when search finds nothing (bug fix)", async () => {
-            const mockSearchResponse = {
-                count: 0,
-                results: [],
-            };
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue(mockSearchResponse),
-            };
-            const result = await handleListApps({
-                request: {
-                    implementationIds: [],
-                    search: "NonexistentApp",
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            // Should only call search endpoint
-            expect(mockHttpClient.get).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient.get).toHaveBeenCalledWith("/zapier/api/v4/implementations-meta/search/", expect.objectContaining({
-                searchParams: { term: "NonexistentApp" },
-            }));
-            // Should return empty (bug fix - not all apps)
-            expect(result.data).toHaveLength(0);
-            expect(result.nextCursor).toBeUndefined();
-        });
-    });
-    describe("search augmentation", () => {
-        it("should augment results with search when search term provided", async () => {
-            const mockSearchResponse = {
-                count: 1,
-                results: [mockImplementation("SlackCLIAPI@1.0.0", "Slack")],
-            };
-            const mockLookupResponse = {
-                count: 2,
-                results: [
-                    mockImplementation("GitHubCLIAPI@1.0.0", "GitHub"),
-                    mockImplementation("SlackCLIAPI@1.0.0", "Slack"),
-                ],
-                next: null,
-            };
-            const mockHttpClient = {
-                get: vi
-                    .fn()
-                    .mockResolvedValueOnce(mockSearchResponse) // First call: search
-                    .mockResolvedValueOnce(mockLookupResponse), // Second call: lookup
-            };
-            const result = await handleListApps({
-                request: {
-                    implementationIds: ["GitHubCLIAPI@1.0.0"],
-                    search: "Slack",
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            // Should call both search and lookup
-            expect(mockHttpClient.get).toHaveBeenCalledTimes(2);
-            expect(mockHttpClient.get).toHaveBeenNthCalledWith(1, "/zapier/api/v4/implementations-meta/search/", expect.objectContaining({
-                searchParams: { term: "Slack" },
-            }));
-            expect(mockHttpClient.get).toHaveBeenNthCalledWith(2, "/zapier/api/v4/implementations-meta/lookup/", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    selected_apis: "GitHubCLIAPI@1.0.0,SlackCLIAPI@1.0.0",
-                }),
-            }));
-            expect(result.data).toHaveLength(2);
-        });
-        it("should not duplicate apps when search returns apps already in implementationIds", async () => {
-            const mockSearchResponse = {
-                count: 1,
-                results: [mockImplementation("SlackCLIAPI@1.0.0", "Slack")],
-            };
-            const mockLookupResponse = {
-                count: 1,
-                results: [mockImplementation("SlackCLIAPI@1.0.0", "Slack")],
-                next: null,
-            };
-            const mockHttpClient = {
-                get: vi
-                    .fn()
-                    .mockResolvedValueOnce(mockSearchResponse)
-                    .mockResolvedValueOnce(mockLookupResponse),
-            };
-            await handleListApps({
-                request: {
-                    implementationIds: ["SlackCLIAPI@1.0.0"],
-                    search: "Slack",
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            // Should call search and lookup but deduplicate IDs
-            expect(mockHttpClient.get).toHaveBeenCalledTimes(2);
-            expect(mockHttpClient.get).toHaveBeenNthCalledWith(2, "/zapier/api/v4/implementations-meta/lookup/", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    selected_apis: "SlackCLIAPI@1.0.0",
-                }),
-            }));
-        });
-        it("should prefer public version when search returns multiple versions of same app", async () => {
-            // Simulates a user having access to both private (1.0.17) and public (1.1.0) versions
-            const mockSearchResponse = {
-                count: 2,
-                results: [
-                    mockImplementation("LumAppsCLIAPI@1.0.17", "LumApps (1.0.17)", "private"),
-                    mockImplementation("LumAppsCLIAPI@1.1.0", "LumApps", "public"),
-                ],
-            };
-            const mockLookupResponse = {
-                count: 1,
-                results: [
-                    mockImplementation("LumAppsCLIAPI@1.1.0", "LumApps", "public"),
-                ],
-                next: null,
-            };
-            const mockHttpClient = {
-                get: vi
-                    .fn()
-                    .mockResolvedValueOnce(mockSearchResponse)
-                    .mockResolvedValueOnce(mockLookupResponse),
-            };
-            await handleListApps({
-                request: {
-                    implementationIds: [],
-                    search: "lumapps",
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            // Should request the public version (1.1.0), not the private one (1.0.17)
-            expect(mockHttpClient.get).toHaveBeenNthCalledWith(2, "/zapier/api/v4/implementations-meta/lookup/", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    selected_apis: "LumAppsCLIAPI@1.1.0",
-                }),
-            }));
-        });
-    });
-    describe("specific implementation IDs", () => {
-        it("should fetch specific apps when implementationIds provided", async () => {
-            const mockResponse = {
-                count: 2,
-                results: [
-                    mockImplementation("SlackCLIAPI@1.0.0", "Slack"),
-                    mockImplementation("GitHubCLIAPI@1.0.0", "GitHub"),
-                ],
-            };
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue(mockResponse),
-            };
-            const result = await handleListApps({
-                request: {
-                    implementationIds: ["SlackCLIAPI@1.0.0", "GitHubCLIAPI@1.0.0"],
-                    search: undefined,
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            expect(result.data).toHaveLength(2);
-            expect(mockHttpClient.get).toHaveBeenCalledWith("/zapier/api/v4/implementations-meta/lookup/", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    selected_apis: "SlackCLIAPI@1.0.0,GitHubCLIAPI@1.0.0",
-                }),
-            }));
-        });
-    });
-    describe("pagination", () => {
-        it("should pass cursor to API when provided", async () => {
-            const mockResponse = {
-                count: 0,
-                results: [],
-            };
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue(mockResponse),
-            };
-            await handleListApps({
-                request: {
-                    implementationIds: ["SlackCLIAPI@1.0.0"],
-                    search: undefined,
-                    pageSize: undefined,
-                    cursor: "page-2-cursor",
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    offset: "page-2-cursor",
-                }),
-            }));
-        });
-        it("should extract nextCursor from response", async () => {
-            const mockResponse = {
-                count: 1,
-                results: [mockImplementation("SlackCLIAPI@1.0.0", "Slack")],
-                next: "https://api.zapier.com/v4/implementations-meta/lookup/?offset=next-page",
-            };
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue(mockResponse),
-            };
-            const result = await handleListApps({
-                request: {
-                    implementationIds: [],
-                    search: undefined,
-                    pageSize: undefined,
-                    cursor: undefined,
-                },
-                deps: { httpClient: mockHttpClient },
-            });
-            expect(result.nextCursor).toBe("next-page");
-        });
-    });
-    describe("request validation", () => {
-        it("should reject request with invalid implementationIds type", async () => {
-            const mockHttpClient = {
-                get: vi.fn(),
-            };
-            const invalidRequest = {
-                implementationIds: "not-an-array",
-                search: undefined,
-                pageSize: undefined,
-                cursor: undefined,
-            };
-            const deps = {
-                httpClient: mockHttpClient,
-            };
-            await expect(handleListApps({ request: invalidRequest, deps })).rejects.toThrow();
-        });
-        it("should reject request with negative pageSize", async () => {
-            const mockHttpClient = {
-                get: vi.fn(),
-            };
-            const invalidRequest = {
-                implementationIds: [],
-                search: undefined,
-                pageSize: -1,
-                cursor: undefined,
-            };
-            const deps = {
-                httpClient: mockHttpClient,
-            };
-            await expect(handleListApps({ request: invalidRequest, deps })).rejects.toThrow();
-        });
-    });
-    describe("response validation", () => {
-        it("should return response matching ListAppsResponseSchema", async () => {
-            const mockHttpClient = {
-                get: vi.fn().mockResolvedValue({
-                    count: 1,
-                    results: [
-                        {
-                            id: "SlackCLIAPI@1.0.0",
-                            name: "SlackCLIAPI",
-                            slug: "slack",
-                            description: "Slack app",
-                            primary_color: "#000000",
-                        },
-                    ],
-                }),
-            };
-            const request = {
-                implementationIds: [],
-                search: undefined,
-                pageSize: 20,
-                cursor: undefined,
-            };
-            const deps = {
-                httpClient: mockHttpClient,
-            };
-            const result = await handleListApps({ request, deps });
-            expect(() => ListAppsResponseSchema.parse(result)).not.toThrow();
-            expect(result).toHaveProperty("data");
-            expect(Array.isArray(result.data)).toBe(true);
-            expect(result).toHaveProperty("nextCursor");
-        });
-    });
-});

package/dist/temporary-internal-core/index.d.ts

@@ -1,18 +0,0 @@
-/**
- * temporary-internal-core
- *
- * Temporary internal directory for SDK core API extraction.
- * This will be extracted and moved to @sdkapi/ as @zapier/zapier-sdk-core.
- *
- * Purpose:
- * - Single source of truth for SDK API schemas
- * - Zod schemas for request/response shapes
- * - API endpoint contracts
- * - Lives inside zapier-sdk during extraction/migration (bundles when published)
- * - Will be extracted to separate package
- */
-export type { HandlerDeps, Handler, ValidatedHandler } from "./types";
-export * from "./schemas/apps";
-export * from "./schemas/implementations";
-export { handleListApps, type ListAppsHandlerDeps } from "./handlers/listApps";
-//# sourceMappingURL=index.d.ts.map

package/dist/temporary-internal-core/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/temporary-internal-core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGtE,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAG1C,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/temporary-internal-core/index.js

@@ -1,18 +0,0 @@
-/**
- * temporary-internal-core
- *
- * Temporary internal directory for SDK core API extraction.
- * This will be extracted and moved to @sdkapi/ as @zapier/zapier-sdk-core.
- *
- * Purpose:
- * - Single source of truth for SDK API schemas
- * - Zod schemas for request/response shapes
- * - API endpoint contracts
- * - Lives inside zapier-sdk during extraction/migration (bundles when published)
- * - Will be extracted to separate package
- */
-// Schemas
-export * from "./schemas/apps";
-export * from "./schemas/implementations";
-// Handlers
-export { handleListApps } from "./handlers/listApps";