@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/plugins/manifest/index.js

@@ -1,395 +0,0 @@
-import { readFile, writeFile, resolve } from "../../utils/file-utils";
-import { ManifestSchema, DEFAULT_CONFIG_PATH } from "./schemas";
-import { definePlugin } from "kitcore";
-import { normalizeImplementationMetaToAppItem, splitVersionedKey, isSnakeCasedSlug, dashifySnakeCasedSlug, toAppLocator, isResolvedAppLocator, } from "../../utils/domain-utils";
-import { paginate } from "kitcore";
-import { extractCursorFromUrl } from "../../utils/pagination";
-import { toArrayFromAsync } from "../../utils/array-utils";
-/**
- * Parse manifest content from a string
- */
-function parseManifestContent(content, source) {
-    try {
-        const parsed = JSON.parse(content);
-        if (parsed == null || typeof parsed !== "object") {
-            return null;
-        }
-        const result = ManifestSchema.safeParse(parsed);
-        if (result.success) {
-            return result.data;
-        }
-        console.warn(`⚠️ Invalid manifest format in ${source}: ${result.error}`);
-        return null;
-    }
-    catch (error) {
-        console.warn(`⚠️ Failed to parse manifest from ${source}:`, error);
-        return null;
-    }
-}
-/**
- * Read manifest from a file path asynchronously
- * Supports local files (Node.js) and browser environments (fallback to global filesystem)
- */
-export async function readManifestFromFile(filePath) {
-    try {
-        // Resolve relative paths relative to current working directory
-        const resolvedPath = await resolve(filePath);
-        const content = await readFile(resolvedPath);
-        return parseManifestContent(content, resolvedPath);
-    }
-    catch (error) {
-        // Silently return null for "file not found" errors (expected for first-time users)
-        const isFileNotFound = (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT") ||
-            (error instanceof Error && error.message.includes("File not found"));
-        if (!isFileNotFound) {
-            console.warn(`⚠️ Failed to read manifest from ${filePath}`);
-        }
-        return null;
-    }
-}
-/**
- * Write manifest to a file path asynchronously
- * Supports local files (Node.js) and browser environments (fallback to global filesystem)
- */
-async function writeManifestToFile(manifest, filePath) {
-    const resolvedPath = await resolve(filePath);
-    await writeFile(resolvedPath, JSON.stringify(manifest, null, 2));
-}
-/**
- * Get the preferred key for storing an app in the manifest
- * Extracted from plugin to make it easier to test
- */
-export async function getPreferredManifestEntryKey({ appKey, api, }) {
-    const locator = toAppLocator(appKey);
-    // If we have a slug, prefer it
-    if (locator.slug) {
-        return locator.slug;
-    }
-    // If we have implementation name, look up the latest to get the slug
-    if (locator.implementationName) {
-        try {
-            // API call to get app metadata by implementation name using selected_apis parameter
-            const implementationsEnvelope = await api.get(`/zapier/api/v4/implementations-meta/lookup/`, {
-                searchParams: {
-                    selected_apis: locator.implementationName,
-                },
-            });
-            if (implementationsEnvelope.results.length > 0 &&
-                implementationsEnvelope.results[0].slug) {
-                return implementationsEnvelope.results[0].slug;
-            }
-        }
-        catch {
-            // Fall back to implementation name if lookup fails
-        }
-        return locator.implementationName;
-    }
-    // Fall back to original key if we can't determine anything better
-    return locator.lookupAppKey;
-}
-async function listAppsForSlugsPage({ slugs, cursor, api, }) {
-    const searchParams = {};
-    if (slugs.length > 0) {
-        searchParams.slugs = slugs.join(",");
-    }
-    if (cursor) {
-        searchParams.offset = cursor;
-    }
-    const implementationsEnvelope = await api.get("/zapier/api/v4/implementations-meta/lookup/", {
-        searchParams,
-    });
-    return {
-        data: implementationsEnvelope.results.map(normalizeImplementationMetaToAppItem),
-        nextCursor: implementationsEnvelope.next
-            ? extractCursorFromUrl(implementationsEnvelope.next)
-            : undefined,
-    };
-}
-/**
- * Find a manifest entry by any app key (implementation name, slug, etc.).
- */
-export function findManifestEntry({ appKey, manifest, }) {
-    if (!manifest.apps) {
-        return null;
-    }
-    const [appKeyWithoutVersion] = splitVersionedKey(appKey);
-    // Direct match by key
-    if (manifest.apps[appKeyWithoutVersion]) {
-        return [appKeyWithoutVersion, manifest.apps[appKeyWithoutVersion]];
-    }
-    // Handle snake-cased slugs (convert to dashed)
-    if (isSnakeCasedSlug(appKey)) {
-        const slug = dashifySnakeCasedSlug(appKey);
-        if (manifest.apps[slug]) {
-            return [slug, manifest.apps[slug]];
-        }
-    }
-    // Search by implementation name in manifest values
-    for (const [key, entry] of Object.entries(manifest.apps)) {
-        if (entry.implementationName === appKeyWithoutVersion) {
-            return [key, entry];
-        }
-    }
-    // No match found
-    return null;
-}
-/**
- * Turn any app keys (slugs, implementation names, etc.) into app locators, which are objects that will be guaranteed to
- * have implementation names. Note that this function will not actually guarantee that implementation names are valid!
- * It will attempt to find the app key in the manifest, or if it's a slug, actually do an API call, or otherwise just
- * assume it's an implementation name that will be used for an API call.
- */
-async function resolveAppKeys({ appKeys, api, manifest, }) {
-    // Step 1: Convert all app keys to locators
-    const locators = appKeys.map(toAppLocator);
-    // Step 2: Map to resolved/unresolved via manifest
-    const locatorsWithManifest = locators.map((locator) => {
-        const manifestEntryResult = findManifestEntry({
-            appKey: locator.lookupAppKey,
-            manifest,
-        });
-        if (manifestEntryResult) {
-            const [, manifestEntry] = manifestEntryResult;
-            // Use manifest entry to resolve implementation name
-            const resolvedVersion = locator.version || manifestEntry.version;
-            const resolvedLocator = {
-                ...locator,
-                implementationName: manifestEntry.implementationName,
-                version: resolvedVersion,
-            };
-            return resolvedLocator;
-        }
-        // If these have an implementationName, they're already resolved.
-        return locator;
-    });
-    // Step 3: Separate resolved from unresolved
-    const unresolvedLocators = locatorsWithManifest.filter((locator) => !isResolvedAppLocator(locator));
-    // Step 4: Resolve slugs via API
-    const slugsToResolve = unresolvedLocators
-        .map((locator) => locator.slug)
-        .filter((slug) => !!slug)
-        .filter((slug, index, array) => array.indexOf(slug) === index); // dedupe
-    if (slugsToResolve.length === 0) {
-        return locatorsWithManifest.filter(isResolvedAppLocator);
-    }
-    const iterator = paginate(listAppsForSlugsPage, {
-        slugs: slugsToResolve,
-        api,
-    });
-    const pages = await toArrayFromAsync(iterator);
-    const apps = pages.flatMap((page) => page.data);
-    const slugToAppData = new Map();
-    for (const app of apps) {
-        if (app.slug) {
-            slugToAppData.set(app.slug, app);
-        }
-    }
-    const slugResolvedLocators = locatorsWithManifest.map((locator) => {
-        if (isResolvedAppLocator(locator)) {
-            return locator;
-        }
-        if (locator.slug) {
-            const appData = slugToAppData.get(locator.slug);
-            if (appData) {
-                // After resolving from API, check if we have a manifest entry for this implementation name
-                const manifestEntryByImplementationName = findManifestEntry({
-                    appKey: appData.key, // appData.key is the implementation name
-                    manifest,
-                });
-                let version = locator.version;
-                if (!version) {
-                    // Prefer manifest version if available, otherwise use API version
-                    version = manifestEntryByImplementationName
-                        ? manifestEntryByImplementationName[1].version || appData.version
-                        : appData.version;
-                }
-                return {
-                    ...locator,
-                    implementationName: appData.key,
-                    version,
-                };
-            }
-        }
-        return locator;
-    });
-    // Return all resolved locators.
-    return slugResolvedLocators.filter(isResolvedAppLocator);
-}
-export { DEFAULT_CONFIG_PATH } from "./schemas";
-export const manifestPlugin = definePlugin((sdk) => {
-    const { api, options } = sdk.context;
-    const { manifestPath = DEFAULT_CONFIG_PATH, manifest } = options || {};
-    let resolvedManifest;
-    async function resolveManifest() {
-        // If manifest is provided directly, use it
-        if (manifest) {
-            return manifest;
-        }
-        // If manifestPath is provided, load from file
-        if (manifestPath) {
-            return await readManifestFromFile(manifestPath);
-        }
-        return null;
-    }
-    const getResolvedManifest = async () => {
-        if (typeof resolvedManifest === "undefined") {
-            resolvedManifest = (await resolveManifest()) ?? null;
-        }
-        return resolvedManifest;
-    };
-    const getVersionedImplementationId = async (appKey) => {
-        const resolvedApps = await resolveAppKeys({
-            appKeys: [appKey],
-            api,
-            manifest: (await getResolvedManifest()) ?? { apps: {} },
-        });
-        const resolvedApp = resolvedApps[0];
-        if (!resolvedApp)
-            return null;
-        return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
-    };
-    const updateManifestEntry = async (options) => {
-        const { appKey, entry, configPath = DEFAULT_CONFIG_PATH, skipWrite = false, manifest: inputManifest, } = options;
-        // Use provided manifest or read from file
-        const manifest = inputManifest ||
-            (await readManifestFromFile(configPath)) || { apps: {} };
-        // Try to find existing entry by direct key first
-        let existingEntry = findManifestEntry({
-            appKey,
-            manifest,
-        });
-        // If not found directly, try to resolve the app key and search by implementation name
-        if (!existingEntry) {
-            try {
-                const resolvedApps = await resolveAppKeys({
-                    appKeys: [appKey],
-                    api,
-                    manifest,
-                });
-                if (resolvedApps.length > 0) {
-                    const resolvedImplementationName = resolvedApps[0].implementationName;
-                    // Try to find entry using the resolved implementation name
-                    existingEntry = findManifestEntry({
-                        appKey: resolvedImplementationName,
-                        manifest,
-                    });
-                }
-            }
-            catch {
-                // If resolution fails, continue with original logic
-            }
-        }
-        let manifestKey;
-        if (existingEntry) {
-            // Use existing key to maintain consistency with types files
-            manifestKey = existingEntry[0];
-        }
-        else {
-            // Get preferred key for new entries
-            manifestKey = await getPreferredManifestEntryKey({
-                appKey,
-                api,
-            });
-        }
-        const updatedManifest = {
-            ...manifest,
-            apps: {
-                ...manifest.apps,
-                [manifestKey]: entry,
-            },
-        };
-        // Conditionally write to file
-        if (!skipWrite) {
-            await writeManifestToFile(updatedManifest, configPath);
-            // Clear the cached manifest so it gets reloaded with the new data
-            resolvedManifest = undefined;
-        }
-        return {
-            key: manifestKey,
-            entry,
-            manifest: updatedManifest,
-        };
-    };
-    const addActionEntry = async (options) => {
-        const { name, entry, configPath = DEFAULT_CONFIG_PATH, skipWrite = false, manifest: inputManifest, } = options;
-        // Use provided manifest or read from file
-        const manifest = inputManifest ||
-            (await readManifestFromFile(configPath)) || { apps: {} };
-        // Ensure actions exists
-        const actions = manifest.actions || {};
-        // Validate uniqueness - if action with this name already exists, throw error
-        if (actions[name] && !skipWrite) {
-            throw new Error(`Action "${name}" already exists. Please choose a different name or remove the existing action first.`);
-        }
-        const updatedManifest = {
-            ...manifest,
-            actions: {
-                ...actions,
-                [name]: entry,
-            },
-        };
-        // Conditionally write to file
-        if (!skipWrite) {
-            await writeManifestToFile(updatedManifest, configPath);
-            // Clear the cached manifest so it gets reloaded with the new data
-            resolvedManifest = undefined;
-        }
-        return {
-            name,
-            entry,
-            manifest: updatedManifest,
-        };
-    };
-    const findActionEntry = ({ name, manifest, }) => {
-        return manifest.actions?.[name] || null;
-    };
-    const listActionEntries = async ({ configPath = DEFAULT_CONFIG_PATH, } = {}) => {
-        const manifest = (await readManifestFromFile(configPath)) || { apps: {} };
-        return Object.entries(manifest.actions || {});
-    };
-    const deleteActionEntry = async ({ name, configPath = DEFAULT_CONFIG_PATH, skipWrite = false, }) => {
-        const manifest = (await readManifestFromFile(configPath)) || { apps: {} };
-        if (!manifest.actions?.[name]) {
-            throw new Error(`Action "${name}" does not exist.`);
-        }
-        const { [name]: removed, ...remainingActions } = manifest.actions;
-        const updatedManifest = {
-            ...manifest,
-            actions: remainingActions,
-        };
-        if (!skipWrite) {
-            await writeManifestToFile(updatedManifest, configPath);
-            resolvedManifest = undefined;
-        }
-        return updatedManifest;
-    };
-    const hasActionEntry = ({ name, manifest, }) => {
-        return !!manifest.actions?.[name];
-    };
-    return {
-        context: {
-            getResolvedManifest,
-            getVersionedImplementationId,
-            resolveAppKeys: async ({ appKeys }) => resolveAppKeys({
-                appKeys,
-                api,
-                manifest: (await getResolvedManifest()) ?? { apps: {} },
-            }),
-            updateManifestEntry,
-            addActionEntry,
-            findActionEntry,
-            listActionEntries,
-            deleteActionEntry,
-            hasActionEntry,
-            findManifestEntry,
-            readManifestFromFile,
-            getManifestConnections: async () => {
-                const manifest = await getResolvedManifest();
-                return manifest?.connections ?? null;
-            },
-        },
-    };
-});

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

@@ -1,88 +0,0 @@
-import { z } from "zod";
-import type { ResolvedAppLocator } from "../../utils/domain-utils";
-import type { AppItem } from "../../types/domain";
-import { type ConnectionsMap } from "../../types/connections";
-export declare const DEFAULT_CONFIG_PATH: ".zapierrc";
-export type ManifestEntry = {
-    implementationName: string;
-    version?: string;
-};
-export type GetVersionedImplementationId = (appKey: string) => Promise<string | null>;
-export type GetImplementation = (appKey: string) => Promise<AppItem | null>;
-/**
- * Action entry for storing saved action configurations
- * The key in the actions record IS the user-provided name
- */
-export declare const ActionEntrySchema: z.ZodObject<{
-    appKey: z.ZodString;
-    actionKey: z.ZodString;
-    actionType: z.ZodString;
-    connectionId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    createdAt: z.ZodString;
-}, z.core.$strip>;
-export type ActionEntry = z.infer<typeof ActionEntrySchema>;
-export type Manifest = {
-    apps?: Record<string, ManifestEntry>;
-    actions?: Record<string, ActionEntry>;
-    canIncludeSharedConnections?: boolean;
-    canIncludeSharedTables?: boolean;
-    canDeleteTables?: boolean;
-    connections?: ConnectionsMap;
-};
-export type ResolveAppKeys = ({ appKeys, }: {
-    appKeys: string[];
-}) => Promise<ResolvedAppLocator[]>;
-/**
- * Manifest schema for version locking and saved action configurations
- */
-export declare const ManifestSchema: z.ZodObject<{
-    apps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        implementationName: z.ZodString;
-        version: z.ZodString;
-    }, z.core.$strip>>>;
-    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        appKey: z.ZodString;
-        actionKey: z.ZodString;
-        actionType: z.ZodString;
-        connectionId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-        authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        createdAt: z.ZodString;
-    }, z.core.$strip>>>;
-    canIncludeSharedConnections: z.ZodOptional<z.ZodBoolean>;
-    canIncludeSharedTables: z.ZodOptional<z.ZodBoolean>;
-    canDeleteTables: z.ZodOptional<z.ZodBoolean>;
-    connections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        connectionId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export declare const ManifestPluginOptionsSchema: z.ZodObject<{
-    manifestPath: z.ZodOptional<z.ZodString>;
-    manifest: z.ZodOptional<z.ZodObject<{
-        apps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            implementationName: z.ZodString;
-            version: z.ZodString;
-        }, z.core.$strip>>>;
-        actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            appKey: z.ZodString;
-            actionKey: z.ZodString;
-            actionType: z.ZodString;
-            connectionId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-            authenticationId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-            inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            createdAt: z.ZodString;
-        }, z.core.$strip>>>;
-        canIncludeSharedConnections: z.ZodOptional<z.ZodBoolean>;
-        canIncludeSharedTables: z.ZodOptional<z.ZodBoolean>;
-        canDeleteTables: z.ZodOptional<z.ZodBoolean>;
-        connections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            connectionId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAKlD,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,yBAAyB,CAAC;AAEjC,eAAO,MAAM,mBAAmB,EAAG,WAAoB,CAAC;AAExD,MAAM,MAAM,aAAa,GAAG;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CACzC,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE5B,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;iBAqB5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACtC,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,cAAc,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,EAC5B,OAAO,GACR,EAAE;IACD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,KAAK,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;iBAkCxB,CAAC;AAEJ,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;iBAGtC,CAAC"}

package/dist/plugins/manifest/schemas.js

@@ -1,61 +0,0 @@
-import { z } from "zod";
-import { ConnectionIdPropertySchema, AuthenticationIdPropertySchema, } from "../../types/properties";
-import { ConnectionsMapSchema, } from "../../types/connections";
-export const DEFAULT_CONFIG_PATH = ".zapierrc";
-/**
- * Action entry for storing saved action configurations
- * The key in the actions record IS the user-provided name
- */
-export const ActionEntrySchema = z.object({
-    appKey: z.string().describe("App key (slug or implementation name)"),
-    actionKey: z.string().describe("Action key identifier"),
-    actionType: z
-        .string()
-        .describe("Action type (e.g., 'read', 'write', 'search')"),
-    connectionId: ConnectionIdPropertySchema.nullable().optional(),
-    /** @deprecated Use connection instead */
-    authenticationId: AuthenticationIdPropertySchema.nullable()
-        .optional()
-        .meta({ deprecated: true }),
-    inputs: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("Resolved input values"),
-    schema: z
-        .record(z.string(), z.unknown())
-        .describe("Complete JSON Schema from getInputFieldsSchema (includes $schema, type, properties, required, etc.)"),
-    createdAt: z.string().describe("ISO 8601 timestamp when created"),
-});
-/**
- * Manifest schema for version locking and saved action configurations
- */
-export const ManifestSchema = z
-    .object({
-    apps: z
-        .record(z.string(), z.object({
-        implementationName: z
-            .string()
-            .describe("Base implementation name without version (e.g., 'SlackCLIAPI')"),
-        version: z.string().describe("Version string (e.g., '1.21.1')"),
-    }))
-        .optional(),
-    actions: z
-        .record(z.string(), ActionEntrySchema)
-        .optional()
-        .describe("Saved action configurations with their schemas"),
-    canIncludeSharedConnections: z
-        .boolean()
-        .optional()
-        .describe("Allow listing shared connections"),
-    canIncludeSharedTables: z
-        .boolean()
-        .optional()
-        .describe("Allow listing shared tables"),
-    canDeleteTables: z.boolean().optional().describe("Allow deleting tables"),
-    connections: ConnectionsMapSchema.optional().describe("Named connections map. Keys are connection names, values contain a connectionId."),
-})
-    .describe("Manifest for app version locking, action configurations, and named connections");
-export const ManifestPluginOptionsSchema = z.object({
-    manifestPath: z.string().optional().describe("Path to manifest file"),
-    manifest: ManifestSchema.optional().describe("Direct manifest object"),
-});

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

@@ -1,17 +0,0 @@
-/**
- * @deprecated `getRegistry` is now built into every sdk produced by
- * `buildSdk`. Adding this plugin is a no-op. Remove the
- * `.addPlugin(registryPlugin)` call.
- */
-export declare const registryPlugin: (sdk: {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {};
-/**
- * @deprecated Empty since the plugin no longer provides anything; the
- * `getRegistry` method is now built into every sdk via `WithAddPlugin`.
- * Kept as an export for any code that still references the type.
- */
-export type RegistryPluginProvides = ReturnType<typeof registryPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/registry/index.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;QAKzB,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/plugins/registry/index.js

@@ -1,11 +0,0 @@
-import { definePlugin } from "kitcore";
-import { logDeprecation } from "../../utils/logging";
-/**
- * @deprecated `getRegistry` is now built into every sdk produced by
- * `buildSdk`. Adding this plugin is a no-op. Remove the
- * `.addPlugin(registryPlugin)` call.
- */
-export const registryPlugin = definePlugin((_sdk) => {
-    logDeprecation("registryPlugin is deprecated and a no-op; getRegistry is now built into every sdk. Remove .addPlugin(registryPlugin).");
-    return {};
-});

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

@@ -1,70 +0,0 @@
-/**
- * @deprecated Use `sdk.fetch(url, init?)` instead. This plugin now delegates
- * to the fetch plugin and is kept only for backward compatibility. It is
- * hidden from the CLI/MCP registries.
- */
-export declare const requestPlugin: (sdk: {
-    fetch: (url: string | URL, init?: import("../fetch").ZapierFetchInitOptions) => Promise<Response>;
-    context: {
-        meta: {
-            fetch: {
-                description: string;
-                packages: string[];
-                categories: {
-                    key: string;
-                    title: string;
-                }[];
-                returnType: string;
-                inputParameters: ({
-                    name: string;
-                    schema: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<URL, URL>]>;
-                } | {
-                    name: string;
-                    schema: import("zod").ZodOptional<import("zod").ZodObject<{
-                        method: import("zod").ZodOptional<import("zod").ZodEnum<{
-                            POST: "POST";
-                            GET: "GET";
-                            DELETE: "DELETE";
-                            PUT: "PUT";
-                            PATCH: "PATCH";
-                            HEAD: "HEAD";
-                            OPTIONS: "OPTIONS";
-                        }>>;
-                        headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
-                        body: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<FormData, FormData>, import("zod").ZodCustom<URLSearchParams, URLSearchParams>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>]>>;
-                        connectionId: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
-                        connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
-                        authenticationId: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
-                        callbackUrl: import("zod").ZodOptional<import("zod").ZodString>;
-                        maxTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                    }, import("zod/v4/core").$strip>>;
-                })[];
-            };
-        };
-    };
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    request: (options?: {
-        url: string;
-        method?: "POST" | "GET" | "DELETE" | "PUT" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
-        body?: any;
-        connection?: string | number | undefined;
-        connectionId?: string | number | undefined;
-        authenticationId?: string | number | undefined;
-        callbackUrl?: string | undefined;
-        headers?: [string, string][] | Record<string, string> | Headers | undefined;
-    } | undefined) => Promise<Response>;
-} & {
-    context: {
-        meta: {
-            request: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type RequestPluginProvides = ReturnType<typeof requestPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/index.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCzB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}