@zapier/zapier-sdk 0.48.0 → 0.49.0

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

@@ -17,8 +17,8 @@ export declare const appsPlugin: (sdk: {
                         method: import("zod").ZodOptional<import("zod").ZodEnum<{
                             POST: "POST";
                             GET: "GET";
-                            DELETE: "DELETE";
                             PUT: "PUT";
+                            DELETE: "DELETE";
                             PATCH: "PATCH";
                             HEAD: "HEAD";
                             OPTIONS: "OPTIONS";

package/dist/plugins/deprecated/inputFields.d.ts

@@ -0,0 +1,468 @@
+/**
+ * Deprecated input-field method aliases.
+ *
+ * The action input-field methods are renamed (`listActionInputFields`,
+ * `listActionInputFieldChoices`, `getActionInputFieldsSchema`) to
+ * disambiguate from the trigger-side variants. The unprefixed names
+ * stay exported here as deprecated aliases that delegate to the
+ * renamed implementations, so existing callers keep working. They're
+ * marked `categories: ["deprecated"]` so generated docs and CLI help
+ * hide them.
+ *
+ * @deprecated Use the action-prefixed equivalents:
+ * - listInputFields -> listActionInputFields
+ * - listInputFieldChoices -> listActionInputFieldChoices
+ * - getInputFieldsSchema -> getActionInputFieldsSchema
+ */
+/**
+ * @deprecated Use listActionInputFields instead.
+ */
+export declare const listInputFieldsDeprecatedPlugin: (sdk: {
+    listActionInputFields: (options?: (({
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../..").PaginatedSdkResult<{
+        key: string;
+        type: "input_field";
+        default_value: string;
+        depends_on: string[];
+        description: string;
+        invalidates_input_fields: boolean;
+        is_required: boolean;
+        placeholder: string;
+        title: string;
+        value_type: string;
+        format?: string | undefined;
+        items?: {
+            type: string;
+        } | undefined;
+    } | {
+        key: string;
+        type: "info_field";
+        description: string;
+        title?: string | undefined;
+    } | import("../..").FieldsetItem>;
+} & {
+    context: {
+        meta: {
+            listActionInputFields: import("../..").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("../..").PluginMeta>;
+    };
+}) => {
+    listInputFields: (options?: (({
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../..").PaginatedSdkResult<{
+        key: string;
+        type: "input_field";
+        default_value: string;
+        depends_on: string[];
+        description: string;
+        invalidates_input_fields: boolean;
+        is_required: boolean;
+        placeholder: string;
+        title: string;
+        value_type: string;
+        format?: string | undefined;
+        items?: {
+            type: string;
+        } | undefined;
+    } | {
+        key: string;
+        type: "info_field";
+        description: string;
+        title?: string | undefined;
+    } | import("../..").FieldsetItem>;
+    context: {
+        meta: {
+            listInputFields: {
+                categories: string[];
+                type: "list";
+                itemType: string;
+                inputSchema: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    app: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    actionType: import("zod").ZodEnum<{
+                        filter: "filter";
+                        read: "read";
+                        read_bulk: "read_bulk";
+                        run: "run";
+                        search: "search";
+                        search_and_write: "search_and_write";
+                        search_or_write: "search_or_write";
+                        write: "write";
+                    }>;
+                    action: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                    connectionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    authenticationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    maxItems: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    appKey: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    actionType: import("zod").ZodEnum<{
+                        filter: "filter";
+                        read: "read";
+                        read_bulk: "read_bulk";
+                        run: "run";
+                        search: "search";
+                        search_and_write: "search_and_write";
+                        search_or_write: "search_or_write";
+                        write: "write";
+                    }>;
+                    actionKey: import("zod").ZodString;
+                    connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                    connectionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    authenticationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    maxItems: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>]>;
+                outputSchema: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    key: import("zod").ZodString;
+                    type: import("zod").ZodLiteral<"input_field">;
+                    default_value: import("zod").ZodString;
+                    depends_on: import("zod").ZodArray<import("zod").ZodString>;
+                    description: import("zod").ZodString;
+                    invalidates_input_fields: import("zod").ZodBoolean;
+                    is_required: import("zod").ZodBoolean;
+                    placeholder: import("zod").ZodString;
+                    title: import("zod").ZodString;
+                    value_type: import("zod").ZodString;
+                    format: import("zod").ZodOptional<import("zod").ZodString>;
+                    items: import("zod").ZodOptional<import("zod").ZodObject<{
+                        type: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    key: import("zod").ZodString;
+                    type: import("zod").ZodLiteral<"info_field">;
+                    description: import("zod").ZodString;
+                    title: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodType<import("../..").FieldsetItem, unknown, import("zod/v4/core").$ZodTypeInternals<import("../..").FieldsetItem, unknown>>]>;
+                defaultPageSize: number;
+            };
+        };
+    };
+};
+export type ListInputFieldsDeprecatedPluginProvides = ReturnType<typeof listInputFieldsDeprecatedPlugin>;
+/**
+ * @deprecated Use listActionInputFieldChoices instead.
+ */
+export declare const listInputFieldChoicesDeprecatedPlugin: (sdk: {
+    listActionInputFieldChoices: (options?: (({
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        inputField: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        inputFieldKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../..").PaginatedSdkResult<{
+        key?: string | undefined;
+        label?: string | undefined;
+        sample?: string | undefined;
+        value?: string | undefined;
+    }>;
+} & {
+    context: {
+        meta: {
+            listActionInputFieldChoices: import("../..").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("../..").PluginMeta>;
+    };
+}) => {
+    listInputFieldChoices: (options?: (({
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        inputField: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        inputFieldKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        page?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../..").PaginatedSdkResult<{
+        key?: string | undefined;
+        label?: string | undefined;
+        sample?: string | undefined;
+        value?: string | undefined;
+    }>;
+    context: {
+        meta: {
+            listInputFieldChoices: {
+                categories: string[];
+                type: "list";
+                itemType: string;
+                inputSchema: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    app: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    actionType: import("zod").ZodEnum<{
+                        filter: "filter";
+                        read: "read";
+                        read_bulk: "read_bulk";
+                        run: "run";
+                        search: "search";
+                        search_and_write: "search_and_write";
+                        search_or_write: "search_or_write";
+                        write: "write";
+                    }>;
+                    action: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    inputField: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                    connectionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    authenticationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    page: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    maxItems: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    appKey: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    actionType: import("zod").ZodEnum<{
+                        filter: "filter";
+                        read: "read";
+                        read_bulk: "read_bulk";
+                        run: "run";
+                        search: "search";
+                        search_and_write: "search_and_write";
+                        search_or_write: "search_or_write";
+                        write: "write";
+                    }>;
+                    actionKey: import("zod").ZodString;
+                    inputFieldKey: import("zod").ZodString;
+                    connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                    connectionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    authenticationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    page: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    pageSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    maxItems: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>]>;
+                outputSchema: import("zod").ZodObject<{
+                    key: import("zod").ZodOptional<import("zod").ZodString>;
+                    label: import("zod").ZodOptional<import("zod").ZodString>;
+                    sample: import("zod").ZodOptional<import("zod").ZodString>;
+                    value: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                defaultPageSize: number;
+            };
+        };
+    };
+};
+export type ListInputFieldChoicesDeprecatedPluginProvides = ReturnType<typeof listInputFieldChoicesDeprecatedPlugin>;
+/**
+ * @deprecated Use getActionInputFieldsSchema instead.
+ */
+export declare const getInputFieldsSchemaDeprecatedPlugin: (sdk: {
+    getActionInputFieldsSchema: (options?: {
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    } | undefined) => Promise<{
+        data: Record<string, unknown>;
+    }>;
+} & {
+    context: {
+        meta: {
+            getActionInputFieldsSchema: import("../..").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        meta: Record<string, import("../..").PluginMeta>;
+    };
+}) => {
+    getInputFieldsSchema: (options?: {
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+    } | undefined) => Promise<{
+        data: Record<string, unknown>;
+    }>;
+    context: {
+        meta: {
+            getInputFieldsSchema: {
+                categories: string[];
+                type: "function";
+                inputSchema: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    app: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    actionType: import("zod").ZodEnum<{
+                        filter: "filter";
+                        read: "read";
+                        read_bulk: "read_bulk";
+                        run: "run";
+                        search: "search";
+                        search_and_write: "search_and_write";
+                        search_or_write: "search_or_write";
+                        write: "write";
+                    }>;
+                    action: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                    connectionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    authenticationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    appKey: import("zod").ZodString & {
+                        _def: import("zod/v4/core").$ZodStringDef & import("../..").PositionalMetadata;
+                    };
+                    actionType: import("zod").ZodEnum<{
+                        filter: "filter";
+                        read: "read";
+                        read_bulk: "read_bulk";
+                        run: "run";
+                        search: "search";
+                        search_and_write: "search_and_write";
+                        search_or_write: "search_or_write";
+                        write: "write";
+                    }>;
+                    actionKey: import("zod").ZodString;
+                    connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                    connectionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    authenticationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                }, import("zod/v4/core").$strip>]>;
+            };
+        };
+    };
+};
+export type GetInputFieldsSchemaDeprecatedPluginProvides = ReturnType<typeof getInputFieldsSchemaDeprecatedPlugin>;
+//# sourceMappingURL=inputFields.d.ts.map

package/dist/plugins/deprecated/inputFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputFields.d.ts","sourceRoot":"","sources":["../../../src/plugins/deprecated/inputFields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAeH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB3C,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAAG,UAAU,CAC9D,OAAO,+BAA+B,CACvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBjD,CAAC;AAEF,MAAM,MAAM,6CAA6C,GAAG,UAAU,CACpE,OAAO,qCAAqC,CAC7C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAahD,CAAC;AAEF,MAAM,MAAM,4CAA4C,GAAG,UAAU,CACnE,OAAO,oCAAoC,CAC5C,CAAC"}

package/dist/plugins/deprecated/inputFields.js

@@ -0,0 +1,73 @@
+/**
+ * Deprecated input-field method aliases.
+ *
+ * The action input-field methods are renamed (`listActionInputFields`,
+ * `listActionInputFieldChoices`, `getActionInputFieldsSchema`) to
+ * disambiguate from the trigger-side variants. The unprefixed names
+ * stay exported here as deprecated aliases that delegate to the
+ * renamed implementations, so existing callers keep working. They're
+ * marked `categories: ["deprecated"]` so generated docs and CLI help
+ * hide them.
+ *
+ * @deprecated Use the action-prefixed equivalents:
+ * - listInputFields -> listActionInputFields
+ * - listInputFieldChoices -> listActionInputFieldChoices
+ * - getInputFieldsSchema -> getActionInputFieldsSchema
+ */
+import { definePlugin } from "../../utils/plugin-utils";
+import { ListActionInputFieldsInputSchema } from "../listActionInputFields/schemas";
+import { ListActionInputFieldChoicesInputSchema, InputFieldChoiceItemSchema, } from "../listActionInputFieldChoices/schemas";
+import { GetActionInputFieldsSchemaInputSchema } from "../getActionInputFieldsSchema/schemas";
+import { RootFieldItemSchema } from "../../schemas/Field";
+import { DEFAULT_PAGE_SIZE } from "../../constants";
+/**
+ * @deprecated Use listActionInputFields instead.
+ */
+export const listInputFieldsDeprecatedPlugin = definePlugin((sdk) => ({
+    listInputFields: sdk.listActionInputFields,
+    context: {
+        meta: {
+            listInputFields: {
+                categories: ["action", "deprecated"],
+                type: "list",
+                itemType: "RootField",
+                inputSchema: ListActionInputFieldsInputSchema,
+                outputSchema: RootFieldItemSchema,
+                defaultPageSize: DEFAULT_PAGE_SIZE,
+            },
+        },
+    },
+}));
+/**
+ * @deprecated Use listActionInputFieldChoices instead.
+ */
+export const listInputFieldChoicesDeprecatedPlugin = definePlugin((sdk) => ({
+    listInputFieldChoices: sdk.listActionInputFieldChoices,
+    context: {
+        meta: {
+            listInputFieldChoices: {
+                categories: ["action", "deprecated"],
+                type: "list",
+                itemType: "InputFieldChoiceItem",
+                inputSchema: ListActionInputFieldChoicesInputSchema,
+                outputSchema: InputFieldChoiceItemSchema,
+                defaultPageSize: DEFAULT_PAGE_SIZE,
+            },
+        },
+    },
+}));
+/**
+ * @deprecated Use getActionInputFieldsSchema instead.
+ */
+export const getInputFieldsSchemaDeprecatedPlugin = definePlugin((sdk) => ({
+    getInputFieldsSchema: sdk.getActionInputFieldsSchema,
+    context: {
+        meta: {
+            getInputFieldsSchema: {
+                categories: ["action", "deprecated"],
+                type: "function",
+                inputSchema: GetActionInputFieldsSchemaInputSchema,
+            },
+        },
+    },
+}));

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

@@ -43,8 +43,8 @@ export declare const fetchPlugin: (sdk: {
                         method: z.ZodOptional<z.ZodEnum<{
                             POST: "POST";
                             GET: "GET";
-                            DELETE: "DELETE";
                             PUT: "PUT";
+                            DELETE: "DELETE";
                             PATCH: "PATCH";
                             HEAD: "HEAD";
                             OPTIONS: "OPTIONS";

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

@@ -11,8 +11,8 @@ export declare const FetchInitSchema: z.ZodOptional<z.ZodObject<{
     method: z.ZodOptional<z.ZodEnum<{
         POST: "POST";
         GET: "GET";
-        DELETE: "DELETE";
         PUT: "PUT";
+        DELETE: "DELETE";
         PATCH: "PATCH";
         HEAD: "HEAD";
         OPTIONS: "OPTIONS";

package/dist/plugins/{getInputFieldsSchema → getActionInputFieldsSchema}/index.d.ts

@@ -1,7 +1,7 @@
 import type { ApiClient } from "../../api";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
 import type { ConnectionsPluginProvides } from "../connections";
-export declare const getInputFieldsSchemaPlugin: (sdk: {
+export declare const getActionInputFieldsSchemaPlugin: (sdk: {
     getAction: (options?: {
         app: string;
         actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
@@ -42,7 +42,7 @@ export declare const getInputFieldsSchemaPlugin: (sdk: {
         meta: Record<string, import("../..").PluginMeta>;
     };
 }) => {
-    getInputFieldsSchema: (options?: {
+    getActionInputFieldsSchema: (options?: {
         app: string;
         actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
         action: string;
@@ -64,9 +64,9 @@ export declare const getInputFieldsSchemaPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            getInputFieldsSchema: import("../..").PluginMeta;
+            getActionInputFieldsSchema: import("../..").PluginMeta;
         };
     };
 };
-export type GetInputFieldsSchemaPluginProvides = ReturnType<typeof getInputFieldsSchemaPlugin>;
+export type GetActionInputFieldsSchemaPluginProvides = ReturnType<typeof getActionInputFieldsSchemaPlugin>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getActionInputFieldsSchema/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAI3C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAUxE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAIhE,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAG9B;QACP,GAAG,EAAE,SAAS,CAAC;QACf,4BAA4B,EAAE,4BAA4B,CAAC;KAC5D,GAAG,yBAAyB,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;cAmBpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;CAoDhD,CAAC;AAEF,MAAM,MAAM,wCAAwC,GAAG,UAAU,CAC/D,OAAO,gCAAgC,CACxC,CAAC"}

package/dist/plugins/{getInputFieldsSchema → getActionInputFieldsSchema}/index.js

@@ -1,17 +1,17 @@
 import { definePlugin } from "../../utils/plugin-utils";
 import { createPluginMethod } from "../../utils/plugin-utils";
-import { GetInputFieldsSchemaInputSchema } from "./schemas";
+import { GetActionInputFieldsSchemaInputSchema } from "./schemas";
 import { ZapierConfigurationError } from "../../types/errors";
 import { appKeyResolver, actionTypeResolver, actionKeyResolver, connectionIdResolver, inputsAllOptionalResolver, } from "../../resolvers";
 import { fetchImplementationNeeds } from "../../services/implementations";
 import { resolveConnectionId } from "../../utils/domain-utils";
 import { setMethodMetadata } from "../../utils/telemetry-context";
-export const getInputFieldsSchemaPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "getInputFieldsSchema",
+export const getActionInputFieldsSchemaPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    name: "getActionInputFieldsSchema",
     categories: ["action"],
     type: "item",
     itemType: "InputSchema",
-    inputSchema: GetInputFieldsSchemaInputSchema,
+    inputSchema: GetActionInputFieldsSchemaInputSchema,
     resolvers: {
         app: appKeyResolver,
         actionType: actionTypeResolver,