@zapier/zapier-sdk 0.34.1 → 0.36.0

package/dist/index.mjs

@@ -42,6 +42,7 @@ function isPositional(schema) {
 // src/constants.ts
 var ZAPIER_BASE_URL = process.env.ZAPIER_BASE_URL || "https://zapier.com";
 var MAX_PAGE_LIMIT = 1e4;
+var DEFAULT_PAGE_SIZE = 100;
 var DEFAULT_ACTION_TIMEOUT_MS = 18e4;
 function parseIntEnvVar(name) {
   const value = process.env[name];
@@ -810,6 +811,68 @@ async function* paginateBuffered(pageFunction, pageOptions) {
   }
 }
 var paginate = paginateBuffered;
+function concatPaginated({
+  sources,
+  dedupe,
+  pageSize = 100
+}) {
+  if (sources.length === 0) {
+    const empty = { data: [] };
+    return Object.assign(Promise.resolve(empty), {
+      [Symbol.asyncIterator]: async function* () {
+        yield empty;
+      }
+    });
+  }
+  let sourceIndex = 0;
+  let currentIterator = null;
+  const seen = /* @__PURE__ */ new Set();
+  const pageFunction = async (_options) => {
+    while (sourceIndex < sources.length) {
+      if (!currentIterator) {
+        const result = sources[sourceIndex]();
+        currentIterator = result[Symbol.asyncIterator]();
+      }
+      const next = await currentIterator.next();
+      if (next.done) {
+        sourceIndex++;
+        currentIterator = null;
+        continue;
+      }
+      let items = next.value.data;
+      if (dedupe) {
+        if (sourceIndex > 0) {
+          items = items.filter((item) => !seen.has(dedupe(item)));
+        }
+        for (const item of items) {
+          seen.add(dedupe(item));
+        }
+      }
+      const hasMoreInSource = next.value.nextCursor != null;
+      const hasMoreSources = sourceIndex < sources.length - 1;
+      return {
+        data: items,
+        nextCursor: hasMoreInSource || hasMoreSources ? "__has_more__" : void 0
+      };
+    }
+    return { data: [] };
+  };
+  const iterator = paginateBuffered(pageFunction, { pageSize });
+  const firstPagePromise = iterator.next().then((result) => {
+    if (result.done) {
+      return { data: [] };
+    }
+    return result.value;
+  });
+  return Object.assign(firstPagePromise, {
+    [Symbol.asyncIterator]: async function* () {
+      yield await firstPagePromise;
+      for await (const page of { [Symbol.asyncIterator]: () => iterator }) {
+        yield page;
+      }
+    }
+  });
+}
 
 // src/utils/validation.ts
 var validate = (schema, input) => {
@@ -960,7 +1023,7 @@ function createPageFunction(coreFn) {
   };
   return namedFunctions[functionName];
 }
-function createPaginatedFunction(coreFn, schema, telemetry, explicitFunctionName) {
+function createPaginatedFunction(coreFn, schema, telemetry, explicitFunctionName, defaultPageSize) {
   const pageFunction = createPageFunction(coreFn);
   const functionName = explicitFunctionName || coreFn.name;
   const validator = schema ? createValidator(schema) : null;
@@ -974,7 +1037,7 @@ function createPaginatedFunction(coreFn, schema, telemetry, explicitFunctionName
           ...normalizedOptions,
           ...validator ? validator(normalizedOptions) : normalizedOptions
         };
-        const pageSize = validatedOptions.pageSize || 100;
+        const pageSize = validatedOptions.pageSize ?? defaultPageSize;
         const optimizedOptions = {
           ...validatedOptions,
           pageSize
@@ -1148,7 +1211,9 @@ var listAppsPlugin = ({ context }) => {
       searchParams: {
         appKeys: implementationIds.join(","),
         ...options.search && { search: options.search },
-        pageSize: options.pageSize.toString(),
+        ...options.pageSize !== void 0 && {
+          pageSize: options.pageSize.toString()
+        },
         ...options.cursor && { offset: options.cursor }
       }
     });
@@ -1158,7 +1223,8 @@ var listAppsPlugin = ({ context }) => {
     listAppsPage,
     ListAppsSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listApps: listAppsDefinition,
@@ -1841,6 +1907,625 @@ var clientIdResolver = {
   })
 };
 
+// src/resolvers/tableId.ts
+var tableIdResolver = {
+  type: "dynamic",
+  fetch: (sdk) => {
+    return concatPaginated({
+      sources: [() => sdk.listTables({ owner: "me" }), () => sdk.listTables()],
+      dedupe: (table) => table.id
+    });
+  },
+  prompt: (tables) => ({
+    type: "list",
+    name: "tableId",
+    message: "Select a table:",
+    choices: tables.map((table) => ({
+      name: `${table.name} (${table.id})`,
+      value: table.id
+    }))
+  })
+};
+function formatFieldValue(v) {
+  if (v == null) return "";
+  if (typeof v === "object") {
+    try {
+      return JSON.stringify(v);
+    } catch {
+      return String(v);
+    }
+  }
+  return String(v);
+}
+function toNumericFieldId(id) {
+  if (typeof id === "number") return id;
+  const num = parseInt(id.replace(/^f/, ""), 10);
+  if (isNaN(num)) {
+    throw new ZapierValidationError(
+      `Invalid field ID: "${id}". Expected a numeric ID like "f6", "6", or 6.`
+    );
+  }
+  return num;
+}
+function transformTableItem(apiItem) {
+  return {
+    id: apiItem.id,
+    name: apiItem.name,
+    description: apiItem.description ?? void 0,
+    created_at: apiItem.created_at,
+    edited_at: apiItem.edited_at,
+    kind: apiItem.kind,
+    owner_account_id: String(apiItem.owner_account_id),
+    profile_id: String(apiItem.owner_zapier_customuser_id),
+    parent_table_id: apiItem.parent_table_id ?? void 0
+  };
+}
+function transformFieldItem(apiItem) {
+  return {
+    id: `f${apiItem.id}`,
+    type: apiItem.type,
+    name: apiItem.name,
+    created_at: apiItem.created_at,
+    edited_at: apiItem.edited_at,
+    options: apiItem.options,
+    config: apiItem.config
+  };
+}
+function transformRecordItem(apiItem) {
+  return {
+    id: apiItem.id,
+    data: apiItem.data,
+    created_at: apiItem.created_at,
+    edited_at: apiItem.edited_at
+  };
+}
+function formatRecordError(fieldId, err) {
+  const message = err.h || err.e || "validation error";
+  if (err.v !== void 0) {
+    return `Field ${fieldId}: ${message} (value: ${JSON.stringify(err.v)})`;
+  }
+  return `Field ${fieldId}: ${message}`;
+}
+function formatResponseError(err) {
+  const message = err.human_title || err.title || "Unknown error";
+  if (err.meta && Object.keys(err.meta).length > 0) {
+    const metaParts = Object.entries(err.meta).map(([key, val]) => `${key}: ${JSON.stringify(val)}`).join(", ");
+    return `${message} (${metaParts})`;
+  }
+  return message;
+}
+function throwOnRecordErrors(record) {
+  if (!record.errors) return;
+  const messages = [];
+  for (const [fieldId, error] of Object.entries(record.errors)) {
+    const err = error;
+    if (err.s === "error") {
+      messages.push(formatRecordError(fieldId, err));
+    }
+  }
+  if (messages.length > 0) {
+    throw new ZapierValidationError(
+      `Record ${record.id} has errors: ${messages.join("; ")}`
+    );
+  }
+}
+function throwOnResponseErrors(response) {
+  const errors = response.meta?.errors;
+  if (!errors || errors.length === 0) return;
+  const messages = errors.map(
+    (err) => formatResponseError(err)
+  );
+  throw new ZapierValidationError(messages.join("; "));
+}
+var KeyModeSchema = z.enum(["names", "ids"]).optional().default("names").describe(
+  'How to interpret field keys in record data. "names" (default) uses human-readable field names, "ids" uses raw field IDs (f1, f2).'
+);
+var FIELD_ID_PATTERN = /^f\d+$/;
+function isFieldId(key) {
+  return FIELD_ID_PATTERN.test(key);
+}
+var NESTED_COMPONENTS = {
+  labeled_string: /* @__PURE__ */ new Set(["value"]),
+  ai_formula: /* @__PURE__ */ new Set(["value"]),
+  link: /* @__PURE__ */ new Set(["link", "text"]),
+  linked_record: /* @__PURE__ */ new Set(["label", "source"])
+};
+async function getFieldMapping(api, tableId, keyMode) {
+  if (keyMode === "ids") {
+    return null;
+  }
+  const rawResponse = await api.get(`/tables/api/v1/tables/${tableId}/fields`, {
+    authRequired: true
+  });
+  const data = rawResponse.data;
+  const nameToId = /* @__PURE__ */ new Map();
+  const idToName = /* @__PURE__ */ new Map();
+  const idToType = /* @__PURE__ */ new Map();
+  for (const field of data) {
+    const id = `f${field.id}`;
+    if (!nameToId.has(field.name)) {
+      nameToId.set(field.name, id);
+    }
+    if (!idToName.has(id)) {
+      idToName.set(id, field.name);
+    }
+    idToType.set(id, field.type);
+  }
+  return { nameToId, idToName, idToType };
+}
+async function resolveFieldKeys({
+  api,
+  tableId,
+  fieldKeys
+}) {
+  const allAreIds = fieldKeys.every(
+    (key) => typeof key === "number" || /^(f?\d+)$/.test(key)
+  );
+  if (allAreIds) {
+    return fieldKeys.map(toNumericFieldId);
+  }
+  const mapping = await getFieldMapping(api, tableId, "names");
+  if (!mapping) {
+    return fieldKeys.map(toNumericFieldId);
+  }
+  return fieldKeys.map((key) => {
+    if (typeof key === "number") return key;
+    if (FIELD_ID_PATTERN.test(key)) return toNumericFieldId(key);
+    const id = mapping.nameToId.get(key);
+    if (!id) {
+      throw new ZapierValidationError(
+        `Unknown field name: "${key}". Use a valid field name or ID.`
+      );
+    }
+    return toNumericFieldId(id);
+  });
+}
+async function createFieldKeyTranslator({
+  api,
+  tableId,
+  keyMode
+}) {
+  const mapping = await getFieldMapping(api, tableId, keyMode);
+  return {
+    translateInput(data) {
+      if (!mapping) return data;
+      const result = {};
+      for (const [key, value] of Object.entries(data)) {
+        if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
+          result[key] = value;
+        } else if (mapping.nameToId.has(key)) {
+          result[mapping.nameToId.get(key)] = value;
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    },
+    translateOutput(data) {
+      if (!mapping) return data;
+      const result = {};
+      for (const [key, value] of Object.entries(data)) {
+        if (mapping.idToName.has(key)) {
+          result[mapping.idToName.get(key)] = value;
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    },
+    translateFieldKey(key) {
+      if (!mapping) return key;
+      if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
+        const fieldType = mapping.idToType.get(key);
+        if (fieldType) {
+          const components = NESTED_COMPONENTS[fieldType];
+          if (components?.size === 1) {
+            return `${key}__${[...components][0]}`;
+          }
+        }
+        return key;
+      }
+      if (mapping.nameToId.has(key)) {
+        const fieldId = mapping.nameToId.get(key);
+        const fieldType = mapping.idToType.get(fieldId);
+        if (fieldType) {
+          const components = NESTED_COMPONENTS[fieldType];
+          if (components?.size === 1) {
+            return `${fieldId}__${[...components][0]}`;
+          }
+        }
+        return fieldId;
+      }
+      const sepIndex = key.lastIndexOf("__");
+      if (sepIndex > 0) {
+        const prefix = key.slice(0, sepIndex);
+        const component = key.slice(sepIndex + 2);
+        let fieldId;
+        if (FIELD_ID_PATTERN.test(prefix) && mapping.idToName.has(prefix)) {
+          fieldId = prefix;
+        } else {
+          fieldId = mapping.nameToId.get(prefix);
+        }
+        if (fieldId) {
+          const fieldType = mapping.idToType.get(fieldId);
+          if (fieldType && NESTED_COMPONENTS[fieldType]?.has(component)) {
+            return `${fieldId}__${component}`;
+          }
+        }
+      }
+      return key;
+    }
+  };
+}
+
+// src/resolvers/tableRecordId.ts
+function summarizeRecord(record) {
+  const values = Object.values(record.data);
+  const preview = values.slice(0, 3).map((v) => formatFieldValue(v).replace(/\s+/g, " ").trim()).filter((s) => s.length > 0).join(", ");
+  const truncated = preview.length > 60 ? preview.slice(0, 57) + "..." : preview;
+  return truncated ? `${record.id} \u2014 ${truncated}` : record.id;
+}
+function fetchRecords(sdk, params) {
+  return sdk.listTableRecords({
+    tableId: params.tableId,
+    keyMode: "names"
+  });
+}
+function recordChoices(records) {
+  return records.map((record) => ({
+    name: summarizeRecord(record),
+    value: record.id
+  }));
+}
+var tableRecordIdResolver = {
+  type: "dynamic",
+  depends: ["tableId"],
+  fetch: fetchRecords,
+  prompt: (records) => ({
+    type: "list",
+    name: "recordId",
+    message: "Select a record:",
+    choices: recordChoices(records)
+  })
+};
+var tableRecordIdsResolver = {
+  type: "dynamic",
+  depends: ["tableId"],
+  fetch: fetchRecords,
+  prompt: (records) => ({
+    type: "checkbox",
+    name: "recordIds",
+    message: "Select records to delete:",
+    choices: recordChoices(records),
+    validate: (value) => Array.isArray(value) && value.length > 0 ? true : "Select at least one record"
+  })
+};
+
+// src/resolvers/tableFieldIds.ts
+var tableFieldIdsResolver = {
+  type: "dynamic",
+  depends: ["tableId"],
+  fetch: (sdk, params) => {
+    return sdk.listTableFields({ tableId: params.tableId });
+  },
+  prompt: (fields) => ({
+    type: "checkbox",
+    name: "fieldKeys",
+    message: "Select fields:",
+    choices: fields.map((field) => ({
+      name: `${field.name} (${field.id}, ${field.type})`,
+      value: field.id
+    })),
+    validate: (value) => Array.isArray(value) && value.length > 0 ? true : "Select at least one field"
+  })
+};
+
+// src/resolvers/tableName.ts
+var tableNameResolver = {
+  type: "static",
+  inputType: "text",
+  placeholder: "Enter a name for the table"
+};
+var FieldTypeSchema = z.enum([
+  "string",
+  "multiple_string",
+  "labeled_string",
+  "multiple_labeled_string",
+  "text",
+  "multiple_text",
+  "boolean",
+  "multiple_boolean",
+  "number",
+  "multiple_number",
+  "decimal",
+  "multiple_decimal",
+  "datetime",
+  "multiple_datetime",
+  "uuid",
+  "multiple_uuid",
+  "json",
+  "multiple_json",
+  "formula",
+  "button_trigger_zap",
+  "button_continue_zap",
+  "email",
+  "multiple_email",
+  "link",
+  "multiple_link",
+  "currency",
+  "phone_number",
+  "ai_formula",
+  "linked_record",
+  "multiple_linked_record"
+]);
+var FieldApiItemSchema = z.object({
+  id: z.number(),
+  type: FieldTypeSchema,
+  name: z.string(),
+  created_at: z.string().optional(),
+  edited_at: z.string().optional(),
+  options: z.record(z.string(), z.unknown()).optional(),
+  config: z.record(z.string(), z.unknown()).optional(),
+  is_order_field: z.boolean().optional(),
+  is_filter_field: z.boolean().optional(),
+  is_selected_field: z.boolean().optional()
+});
+var ListTableFieldsApiResponseSchema = z.object({
+  data: z.array(FieldApiItemSchema)
+});
+var FieldItemSchemaBase = z.object({
+  id: z.string(),
+  type: FieldTypeSchema,
+  name: z.string(),
+  created_at: z.string().optional(),
+  edited_at: z.string().optional(),
+  options: z.record(z.string(), z.unknown()).optional(),
+  config: z.record(z.string(), z.unknown()).optional()
+});
+var FieldItemSchema = withFormatter(FieldItemSchemaBase, {
+  format: (item) => ({
+    title: item.name,
+    id: item.id,
+    details: [{ text: `Type: ${item.type}`, style: "dim" }]
+  })
+});
+var ListTableFieldsOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fieldKeys: z.array(z.union([z.string(), z.number()])).optional().describe(
+    'Filter by specific fields. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+  )
+}).describe("List fields for a table");
+
+// src/resolvers/tableFields.ts
+var fieldTypeChoices = FieldTypeSchema.options.map((type) => ({
+  label: type,
+  value: type
+}));
+var singleFieldResolver = {
+  type: "fields",
+  fetch: async () => {
+    return [
+      {
+        type: "input_field",
+        key: "type",
+        title: "Field type",
+        is_required: true,
+        choices: fieldTypeChoices
+      },
+      {
+        type: "input_field",
+        key: "name",
+        title: "Field name",
+        is_required: true
+      }
+    ];
+  }
+};
+var tableFieldsResolver = {
+  type: "array",
+  fetch: async () => singleFieldResolver,
+  minItems: 1
+};
+
+// src/resolvers/tableRecords.ts
+function tableFieldValueType(fieldType) {
+  if (fieldType.startsWith("multiple_")) return "array";
+  switch (fieldType) {
+    case "number":
+    case "decimal":
+    case "currency":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return void 0;
+  }
+}
+function createSingleRecordResolver({
+  sdk,
+  tableId,
+  includeRecordId
+}) {
+  return {
+    type: "fields",
+    fetch: async () => {
+      const { data: fields } = await sdk.listTableFields({ tableId });
+      const inputFields = fields.map((field) => ({
+        type: "input_field",
+        key: field.id,
+        title: field.name,
+        is_required: false,
+        ...tableFieldValueType(field.type) && {
+          value_type: tableFieldValueType(field.type)
+        }
+      }));
+      if (includeRecordId) {
+        return [
+          {
+            type: "input_field",
+            key: "_record_id",
+            title: "Record",
+            is_required: true,
+            resolver: tableRecordIdResolver
+          },
+          ...inputFields
+        ];
+      }
+      return inputFields;
+    },
+    transform: (values) => {
+      if (includeRecordId) {
+        const { _record_id: id, ...data } = values;
+        return { id, data };
+      }
+      return { data: values };
+    }
+  };
+}
+var tableRecordsResolver = {
+  type: "array",
+  depends: ["tableId"],
+  fetch: async (sdk, params) => {
+    return createSingleRecordResolver({
+      sdk,
+      tableId: params.tableId
+    });
+  },
+  minItems: 1
+};
+var tableUpdateRecordsResolver = {
+  type: "array",
+  depends: ["tableId"],
+  fetch: async (sdk, params) => {
+    return createSingleRecordResolver({
+      sdk,
+      tableId: params.tableId,
+      includeRecordId: true
+    });
+  },
+  minItems: 1
+};
+
+// src/resolvers/tableFilters.ts
+var FILTER_OPERATORS = [
+  { label: "equals", value: "exact" },
+  { label: "not equals", value: "different" },
+  { label: "contains", value: "contains" },
+  { label: "contains (case-insensitive)", value: "icontains" },
+  { label: "starts with", value: "startswith" },
+  { label: "search", value: "search" },
+  { label: "greater than", value: "gt" },
+  { label: "greater than or equal", value: "gte" },
+  { label: "less than", value: "lt" },
+  { label: "less than or equal", value: "lte" },
+  { label: "in range", value: "range" },
+  { label: "in list", value: "in" },
+  { label: "is empty", value: "isnull" },
+  { label: "is within (date)", value: "is_within" }
+];
+function createSingleFilterResolver({
+  sdk,
+  tableId
+}) {
+  return {
+    type: "fields",
+    fetch: async () => {
+      const { data: fields } = await sdk.listTableFields({ tableId });
+      const fieldChoices = fields.flatMap((field) => {
+        const components = NESTED_COMPONENTS[field.type];
+        if (components && components.size > 1) {
+          return [...components].map((component) => ({
+            label: `${field.name}__${component} (${field.id}, ${field.type})`,
+            value: `${field.name}__${component}`
+          }));
+        }
+        return {
+          label: `${field.name} (${field.id}${components ? `, ${field.type}` : ""})`,
+          value: components ? `${field.name}__${[...components][0]}` : field.name
+        };
+      });
+      const fieldItems = [
+        {
+          type: "input_field",
+          key: "fieldKey",
+          title: "Field",
+          is_required: true,
+          choices: fieldChoices
+        },
+        {
+          type: "input_field",
+          key: "operator",
+          title: "Operator",
+          is_required: true,
+          choices: FILTER_OPERATORS
+        },
+        {
+          type: "input_field",
+          key: "value",
+          title: "Value",
+          is_required: false
+        }
+      ];
+      return fieldItems;
+    }
+  };
+}
+var tableFiltersResolver = {
+  type: "array",
+  depends: ["tableId"],
+  fetch: async (sdk, params) => {
+    return createSingleFilterResolver({
+      sdk,
+      tableId: params.tableId
+    });
+  },
+  minItems: 0
+};
+
+// src/resolvers/tableSort.ts
+var tableSortResolver = {
+  type: "fields",
+  depends: ["tableId"],
+  fetch: async (sdk, params) => {
+    const { data: fields } = await sdk.listTableFields({
+      tableId: params.tableId
+    });
+    const fieldChoices = fields.flatMap((field) => {
+      const components = NESTED_COMPONENTS[field.type];
+      if (components) {
+        return [...components].map((component) => ({
+          label: `${field.name}__${component} (${field.id}, ${field.type})`,
+          value: `${field.name}__${component}`
+        }));
+      }
+      return {
+        label: `${field.name} (${field.id})`,
+        value: field.name
+      };
+    });
+    const fieldItems = [
+      {
+        type: "input_field",
+        key: "fieldKey",
+        title: "Field",
+        is_required: true,
+        choices: fieldChoices
+      },
+      {
+        type: "input_field",
+        key: "direction",
+        title: "Direction",
+        is_required: true,
+        choices: [
+          { label: "Ascending", value: "asc" },
+          { label: "Descending", value: "desc" }
+        ]
+      }
+    ];
+    return fieldItems;
+  }
+};
+
 // src/plugins/listActions/index.ts
 var listActionsPlugin = ({ context }) => {
   const methodMeta = {
@@ -1920,7 +2605,8 @@ var listActionsPlugin = ({ context }) => {
     listActionsPage,
     ListActionsSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listActions: listActionsDefinition,
@@ -2277,7 +2963,8 @@ var listInputFieldsPlugin = ({ sdk, context }) => {
     listInputFieldsPage,
     ListInputFieldsSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listInputFields: listInputFieldsDefinition,
@@ -2363,9 +3050,10 @@ var ConnectionItemSchema = withFormatter(ConnectionItemSchema$1, {
 var listConnectionsPlugin = ({ context }) => {
   async function listConnectionsPage(options) {
     const { api, getVersionedImplementationId } = context;
-    const searchParams = {
-      page_size: options.pageSize.toString()
-    };
+    const searchParams = {};
+    if (options.pageSize !== void 0) {
+      searchParams.page_size = options.pageSize.toString();
+    }
     if (options.appKey) {
       const implementationId = await getVersionedImplementationId(
         options.appKey
@@ -2429,7 +3117,8 @@ var listConnectionsPlugin = ({ context }) => {
     listConnectionsPage,
     ListConnectionsQuerySchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listConnections: listConnectionsDefinition,
@@ -2507,9 +3196,10 @@ var ClientCredentialsCreatedItemSchema = withFormatter(
 var listClientCredentialsPlugin = ({ context }) => {
   async function listClientCredentialsPage(options) {
     const { api } = context;
-    const searchParams = {
-      pageSize: options.pageSize.toString()
-    };
+    const searchParams = {};
+    if (options.pageSize !== void 0) {
+      searchParams.pageSize = options.pageSize.toString();
+    }
     if (options.cursor) {
       searchParams.offset = options.cursor;
     }
@@ -2543,7 +3233,8 @@ var listClientCredentialsPlugin = ({ context }) => {
     listClientCredentialsPage,
     ListClientCredentialsQuerySchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listClientCredentials: listClientCredentialsDefinition,
@@ -2633,25 +3324,29 @@ var DeleteClientCredentialsSchema = z.object({
 var deleteClientCredentialsPlugin = ({ context }) => {
   async function deleteClientCredentials(options) {
     const { api } = context;
-    await api.delete(`/api/v0/client-credentials/${options.clientId}`, {
-      customErrorHandler: ({ status }) => {
-        if (status === 401) {
-          return new ZapierAuthenticationError(
-            `Authentication failed. Your token may not have permission to delete client credentials or may be expired. (HTTP ${status})`,
-            { statusCode: status }
-          );
-        }
-        if (status === 403) {
-          return new ZapierAuthenticationError(
-            `Access forbidden. Your token may not have the required scopes to delete client credentials. (HTTP ${status})`,
-            { statusCode: status }
-          );
-        }
-        return void 0;
-      },
-      authRequired: true,
-      requiredScopes: ["credentials"]
-    });
+    await api.delete(
+      `/api/v0/client-credentials/${options.clientId}`,
+      void 0,
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to delete client credentials or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to delete client credentials. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        },
+        authRequired: true,
+        requiredScopes: ["credentials"]
+      }
+    );
     return {
       success: true
     };
@@ -2958,6 +3653,7 @@ async function executeAction(actionOptions) {
     actionKey,
     actionType,
     executionOptions,
+    cursor,
     connectionId,
     timeoutMs
   } = actionOptions;
@@ -2971,6 +3667,9 @@ async function executeAction(actionOptions) {
   if (connectionId !== null && connectionId !== void 0) {
     runRequestData.authentication_id = connectionId;
   }
+  if (cursor) {
+    runRequestData.page = cursor;
+  }
   const runRequest = {
     data: runRequestData
   };
@@ -2990,19 +3689,52 @@ async function executeAction(actionOptions) {
     resultExtractor: (result) => result.data
   });
 }
+var CONTEXT_CACHE_TTL_MS = 6e4;
+var CONTEXT_CACHE_MAX_SIZE = 500;
 var runActionPlugin = ({ sdk, context }) => {
-  async function runActionPage(options) {
-    const { api } = context;
-    const {
-      appKey,
-      actionKey,
-      actionType,
-      connectionId,
-      authenticationId,
-      inputs = {},
-      timeoutMs
-    } = options;
-    const resolvedConnectionId = connectionId ?? authenticationId;
+  const runActionContextCache = /* @__PURE__ */ new Map();
+  function evictIfNeeded() {
+    if (runActionContextCache.size < CONTEXT_CACHE_MAX_SIZE) return;
+    const now = Date.now();
+    let oldestKey;
+    let oldestExpiry = Infinity;
+    let evictedAny = false;
+    for (const [key, entry] of runActionContextCache) {
+      if (now >= entry.expiresAt) {
+        runActionContextCache.delete(key);
+        evictedAny = true;
+      } else if (entry.expiresAt < oldestExpiry) {
+        oldestExpiry = entry.expiresAt;
+        oldestKey = key;
+      }
+    }
+    if (!evictedAny && oldestKey) {
+      runActionContextCache.delete(oldestKey);
+    }
+  }
+  function getRunActionContext(options) {
+    const { appKey, actionKey, actionType } = options;
+    const contextKey = `${appKey}:${actionKey}:${actionType}`;
+    const cached = runActionContextCache.get(contextKey);
+    if (cached && Date.now() < cached.expiresAt) {
+      return cached.promise;
+    }
+    const pendingContext = resolveRunActionContext(options).catch((error) => {
+      const current = runActionContextCache.get(contextKey);
+      if (current?.promise === pendingContext) {
+        runActionContextCache.delete(contextKey);
+      }
+      throw error;
+    });
+    evictIfNeeded();
+    runActionContextCache.set(contextKey, {
+      promise: pendingContext,
+      expiresAt: Date.now() + CONTEXT_CACHE_TTL_MS
+    });
+    return pendingContext;
+  }
+  async function resolveRunActionContext(options) {
+    const { appKey, actionKey, actionType } = options;
     const selectedApi = await context.getVersionedImplementationId(appKey);
     if (!selectedApi) {
       throw new ZapierConfigurationError(
@@ -3010,11 +3742,6 @@ var runActionPlugin = ({ sdk, context }) => {
         { configType: "current_implementation_id" }
       );
     }
-    setMethodMetadata({
-      selectedApi,
-      operationType: actionType,
-      operationKey: actionKey
-    });
     const actionData = await sdk.getAction({
       appKey,
       actionKey,
@@ -3025,7 +3752,27 @@ var runActionPlugin = ({ sdk, context }) => {
         `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`
       );
     }
-    const actionId = actionData.data.id;
+    return { selectedApi, actionId: actionData.data.id };
+  }
+  async function runActionPage(options) {
+    const { api } = context;
+    const {
+      appKey,
+      actionKey,
+      actionType,
+      connectionId,
+      authenticationId,
+      inputs = {},
+      cursor,
+      timeoutMs
+    } = options;
+    const resolvedConnectionId = connectionId ?? authenticationId;
+    const { selectedApi, actionId } = await getRunActionContext(options);
+    setMethodMetadata({
+      selectedApi,
+      operationType: actionType,
+      operationKey: actionKey
+    });
     const result = await executeAction({
       api,
       selectedApi,
@@ -3035,6 +3782,7 @@ var runActionPlugin = ({ sdk, context }) => {
       actionKey,
       actionType,
       executionOptions: { inputs },
+      cursor,
       connectionId: resolvedConnectionId,
       timeoutMs
     });
@@ -3049,8 +3797,7 @@ var runActionPlugin = ({ sdk, context }) => {
     }
     return {
       data: result.results || [],
-      nextCursor: void 0
-      // No pagination implemented yet
+      nextCursor: result.next_page
     };
   }
   const methodName = stripPageSuffix(runActionPage.name);
@@ -4488,6 +5235,11 @@ var pathConfig = {
   "/zapier": {
     authHeader: "Authorization",
     pathPrefix: "/api/v0/sdk/zapier"
+  },
+  // e.g. /tables -> https://sdkapi.zapier.com/api/v0/sdk/tables/...
+  "/tables": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/tables"
   }
 };
 var ZapierApiClient = class {
@@ -4555,8 +5307,11 @@ var ZapierApiClient = class {
     this.put = async (path, data, options = {}) => {
       return this.fetchJson("PUT", path, data, options);
     };
-    this.delete = async (path, options = {}) => {
-      return this.fetchJson("DELETE", path, void 0, options);
+    this.patch = async (path, data, options = {}) => {
+      return this.fetchJson("PATCH", path, data, options);
+    };
+    this.delete = async (path, data, options = {}) => {
+      return this.fetchJson("DELETE", path, data, options);
     };
     this.poll = async (path, options = {}) => {
       return pollUntilComplete({
@@ -4960,155 +5715,1237 @@ async function batch(tasks, options = {}) {
   await Promise.all(workers);
   return results;
 }
+var TableApiItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  created_at: z.string(),
+  edited_at: z.string(),
+  kind: z.enum(["table", "virtual_table"]),
+  owner_account_id: z.number(),
+  owner_user_id: z.number().nullable().optional(),
+  owner_zapier_customuser_id: z.number(),
+  parent_table_id: z.string().nullable().optional()
+});
+var ListTablesApiResponseSchema = z.object({
+  data: z.array(TableApiItemSchema),
+  links: z.object({
+    next: z.string().nullable().optional()
+  }).optional()
+});
+var TableItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  created_at: z.string(),
+  edited_at: z.string(),
+  kind: z.enum(["table", "virtual_table"]),
+  owner_account_id: z.string(),
+  profile_id: z.string(),
+  parent_table_id: z.string().optional()
+});
+var ListTablesOptionsSchema = z.object({
+  tableIds: z.array(z.string()).optional().describe("Filter by specific table IDs"),
+  kind: z.enum(["table", "virtual_table", "both"]).optional().describe("Filter by table type"),
+  search: z.string().optional().describe("Search term to filter tables by name"),
+  owner: z.string().optional().describe(
+    'Filter by table owner. Use "me" for the current user, or a numeric user ID.'
+  ),
+  pageSize: z.number().min(1).optional().describe("Number of tables per page"),
+  maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Cursor to start from")
+}).describe("List tables available to the authenticated user");
 
-// src/plugins/registry/index.ts
-var registryPlugin = ({ sdk, context }) => {
-  const metaKeys = Object.keys(context.meta || {});
-  const categoryDefinitions = {
-    account: {
-      title: "Account"
-    },
-    app: {
-      title: "App",
-      titlePlural: "Apps"
-    },
-    connection: {
-      title: "Connection"
-    },
-    action: {
-      title: "Action"
-    },
-    "client-credentials": {
-      title: "Client Credentials",
-      titlePlural: "Client Credentials"
-    },
-    http: {
-      title: "HTTP Request"
-    },
-    utility: {
-      title: "Utility",
-      titlePlural: "Utilities"
-    },
-    other: {
-      title: "Other"
+// src/plugins/tables/listTables/index.ts
+function extractNextCursor(links) {
+  if (!links?.next) {
+    return void 0;
+  }
+  try {
+    const url = new URL(links.next);
+    const offset = url.searchParams.get("offset");
+    return offset || void 0;
+  } catch {
+    return void 0;
+  }
+}
+var listTablesPlugin = ({ context }) => {
+  async function listTablesPage(options) {
+    const { api } = context;
+    const searchParams = {};
+    if (options.pageSize !== void 0) {
+      searchParams.limit = options.pageSize.toString();
     }
-  };
-  const functions = metaKeys.filter((key) => {
-    const property = sdk[key];
-    if (typeof property === "function") {
-      return true;
+    if (options?.tableIds && options.tableIds.length > 0) {
+      searchParams.ids = options.tableIds.join(",");
     }
-    const [rootKey] = key.split(".");
-    const rootProperty = sdk[rootKey];
-    if (typeof rootProperty === "object" && rootProperty !== null) {
-      return true;
+    if (options?.kind) {
+      searchParams.kind = options.kind;
     }
-    return false;
-  }).map((key) => {
-    const meta = context.meta[key];
-    return {
-      name: key,
-      description: meta.description,
-      type: meta.type,
-      itemType: meta.itemType,
-      returnType: meta.returnType,
-      inputSchema: meta.inputSchema,
-      inputParameters: meta.inputParameters,
-      outputSchema: meta.outputSchema,
-      categories: meta.categories || [],
-      resolvers: meta.resolvers,
-      packages: meta.packages,
-      // Auto-infer confirm: "delete" from type: "delete" (all deletes should confirm)
-      confirm: meta.confirm ?? (meta.type === "delete" ? "delete" : void 0),
-      deprecation: meta.deprecation,
-      deprecatedParameters: meta.deprecatedParameters,
-      aliases: meta.aliases,
-      supportsJsonOutput: meta.supportsJsonOutput ?? true
-    };
-  }).sort((a, b) => a.name.localeCompare(b.name));
-  const knownCategories = Object.keys(categoryDefinitions);
-  const registryCache = /* @__PURE__ */ new Map();
-  function getRegistry(options) {
-    const packageFilter = options?.package;
-    const cacheKey = packageFilter || "__all__";
-    if (registryCache.has(cacheKey)) {
-      return registryCache.get(cacheKey);
+    if (options?.search) {
+      searchParams.q = options.search;
     }
-    const filteredFunctions = packageFilter ? functions.filter(
-      (f) => (
-        // Include if packages is undefined (belongs to all packages) or includes the specified package
-        !f.packages || f.packages.includes(packageFilter)
-      )
-    ) : functions;
-    const filteredCategories = knownCategories.sort((a, b) => {
-      if (a === "other") return 1;
-      if (b === "other") return -1;
-      const titleA = categoryDefinitions[a].title;
-      const titleB = categoryDefinitions[b].title;
-      return titleA.localeCompare(titleB);
-    }).map((categoryKey) => {
-      const categoryFunctions = filteredFunctions.filter(
-        (f) => f.categories.includes(categoryKey) || // If the category is "other" and the function is not in any other category, include it
-        categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
-      ).map((f) => f.name).sort();
-      const definition = categoryDefinitions[categoryKey];
-      const title = definition.title;
-      return {
-        key: categoryKey,
-        title,
-        titlePlural: definition.titlePlural ?? `${title}s`,
-        functions: categoryFunctions
-      };
-    }).filter((category) => category.functions.length > 0);
-    const result = {
-      functions: filteredFunctions,
-      categories: filteredCategories
+    if (options?.owner) {
+      let ownerId = options.owner;
+      if (ownerId === "me") {
+        const profile = await api.get("/zapier/api/v4/profile/", {
+          authRequired: true
+        });
+        ownerId = String(profile.id);
+      }
+      searchParams.owner_customuser_id = ownerId;
+    }
+    if (options.cursor) {
+      searchParams.offset = options.cursor;
+    }
+    const rawResponse = await api.get("/tables/api/v1/tables", {
+      searchParams,
+      customErrorHandler: ({ status }) => {
+        if (status === 401) {
+          return new ZapierAuthenticationError(
+            `Authentication failed. Your token may not have permission to list tables or may be expired. (HTTP ${status})`,
+            { statusCode: status }
+          );
+        }
+        if (status === 403) {
+          return new ZapierAuthenticationError(
+            `Access forbidden. Your token may not have the required scopes to list tables. (HTTP ${status})`,
+            { statusCode: status }
+          );
+        }
+        return void 0;
+      },
+      authRequired: true
+    });
+    const response = ListTablesApiResponseSchema.parse(rawResponse);
+    return {
+      data: response.data.map(transformTableItem),
+      nextCursor: extractNextCursor(response.links)
     };
-    registryCache.set(cacheKey, result);
-    return result;
   }
+  const methodName = stripPageSuffix(listTablesPage.name);
+  const listTablesDefinition = createPaginatedFunction(
+    listTablesPage,
+    ListTablesOptionsSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName,
+    DEFAULT_PAGE_SIZE
+  );
   return {
-    getRegistry
+    listTables: listTablesDefinition,
+    context: {
+      meta: {
+        listTables: {
+          categories: ["table"],
+          type: "list",
+          itemType: "Table",
+          inputSchema: ListTablesOptionsSchema,
+          outputSchema: TableItemSchema
+        }
+      }
+    }
   };
 };
+var GetTableApiResponseSchema = z.object({
+  data: TableApiItemSchema
+});
+var GetTableOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table to retrieve")
+}).describe("Get detailed information about a specific table");
 
-// src/plugins/deprecated/authentications.ts
-var listAuthenticationsPlugin = ({ sdk }) => ({
-  listAuthentications: sdk.listConnections,
-  context: {
-    meta: {
-      listAuthentications: {
-        packages: ["cli", "mcp"],
-        categories: ["connection", "deprecated"],
-        type: "list",
-        itemType: "Connection",
-        inputSchema: ListConnectionsQuerySchema,
-        outputSchema: ConnectionItemSchema
+// src/plugins/tables/getTable/index.ts
+var getTablePlugin = ({ context }) => {
+  async function getTable(options) {
+    const { api } = context;
+    const rawResponse = await api.get(
+      `/tables/api/v1/tables/${options.tableId}`,
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access this table or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to access this table. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 404) {
+            return new Error(`Table not found: ${options.tableId}`);
+          }
+          return void 0;
+        },
+        authRequired: true
       }
-    }
+    );
+    const response = GetTableApiResponseSchema.parse(rawResponse);
+    return {
+      data: transformTableItem(response.data)
+    };
   }
-});
-var getAuthenticationPlugin = ({ sdk }) => ({
-  getAuthentication: sdk.getConnection,
-  context: {
-    meta: {
-      getAuthentication: {
-        packages: ["cli", "mcp"],
-        categories: ["connection", "deprecated"],
-        type: "item",
-        itemType: "Connection",
-        inputSchema: GetConnectionParamSchema,
-        outputSchema: ConnectionItemSchema
+  const getTableDefinition = createFunction(
+    getTable,
+    GetTableOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      getTable.name
+    )
+  );
+  return {
+    getTable: getTableDefinition,
+    context: {
+      meta: {
+        getTable: {
+          categories: ["table"],
+          type: "item",
+          itemType: "Table",
+          inputSchema: GetTableOptionsSchema,
+          outputSchema: TableItemSchema,
+          resolvers: {
+            tableId: tableIdResolver
+          }
+        }
       }
     }
-  }
+  };
+};
+var CreateTableApiResponseSchema = z.object({
+  data: TableApiItemSchema
 });
-var findFirstAuthenticationPlugin = ({ sdk }) => ({
-  findFirstAuthentication: sdk.findFirstConnection,
-  context: {
-    meta: {
-      findFirstAuthentication: {
-        packages: ["cli", "mcp"],
+var CreateTableOptionsSchema = z.object({
+  name: z.string().min(1).describe("The name for the new table"),
+  description: z.string().optional().describe("An optional description of the table")
+}).describe("Create a new table");
+
+// src/plugins/tables/createTable/index.ts
+var createTablePlugin = ({ context }) => {
+  async function createTable(options) {
+    const { api } = context;
+    const rawResponse = await api.post(
+      "/tables/api/v1/tables",
+      {
+        name: options.name,
+        description: options.description
+      },
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to create tables or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to create tables. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    const response = CreateTableApiResponseSchema.parse(rawResponse);
+    return {
+      data: transformTableItem(response.data)
+    };
+  }
+  const createTableDefinition = createFunction(
+    createTable,
+    CreateTableOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      createTable.name
+    )
+  );
+  return {
+    createTable: createTableDefinition,
+    context: {
+      meta: {
+        createTable: {
+          categories: ["table"],
+          type: "create",
+          itemType: "Table",
+          inputSchema: CreateTableOptionsSchema,
+          outputSchema: TableItemSchema,
+          resolvers: {
+            name: tableNameResolver
+          }
+        }
+      }
+    }
+  };
+};
+var DeleteTableOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table to delete")
+}).describe("Delete a table by its ID");
+
+// src/plugins/tables/deleteTable/index.ts
+var deleteTablePlugin = ({ context }) => {
+  async function deleteTable(options) {
+    const { api } = context;
+    await api.delete(`/tables/api/v1/tables/${options.tableId}`, void 0, {
+      customErrorHandler: ({ status }) => {
+        if (status === 401) {
+          return new ZapierAuthenticationError(
+            `Authentication failed. Your token may not have permission to delete tables or may be expired. (HTTP ${status})`,
+            { statusCode: status }
+          );
+        }
+        if (status === 403) {
+          return new ZapierAuthenticationError(
+            `Access forbidden. Your token may not have the required scopes to delete tables. (HTTP ${status})`,
+            { statusCode: status }
+          );
+        }
+        return void 0;
+      },
+      authRequired: true
+    });
+    return {
+      success: true
+    };
+  }
+  const deleteTableDefinition = createFunction(
+    deleteTable,
+    DeleteTableOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      deleteTable.name
+    )
+  );
+  return {
+    deleteTable: deleteTableDefinition,
+    context: {
+      meta: {
+        deleteTable: {
+          categories: ["table"],
+          type: "delete",
+          itemType: "Table",
+          inputSchema: DeleteTableOptionsSchema,
+          resolvers: {
+            tableId: tableIdResolver
+          },
+          confirm: "delete"
+        }
+      }
+    }
+  };
+};
+
+// src/plugins/tables/listTableFields/index.ts
+var listTableFieldsPlugin = ({ context }) => {
+  async function listTableFields(options) {
+    const { api } = context;
+    const searchParams = {};
+    if (options.fieldKeys && options.fieldKeys.length > 0) {
+      const numericIds = await resolveFieldKeys({
+        api,
+        tableId: options.tableId,
+        fieldKeys: options.fieldKeys
+      });
+      searchParams.field_ids = numericIds.join(",");
+    }
+    const rawResponse = await api.get(
+      `/tables/api/v1/tables/${options.tableId}/fields`,
+      {
+        searchParams: Object.keys(searchParams).length > 0 ? searchParams : void 0,
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access this table or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to access this table. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 404) {
+            return new Error(`Table not found: ${options.tableId}`);
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    const response = ListTableFieldsApiResponseSchema.parse(rawResponse);
+    return {
+      data: response.data.map(transformFieldItem)
+    };
+  }
+  const listTableFieldsDefinition = createFunction(
+    listTableFields,
+    ListTableFieldsOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      listTableFields.name
+    )
+  );
+  return {
+    listTableFields: listTableFieldsDefinition,
+    context: {
+      meta: {
+        listTableFields: {
+          categories: ["table"],
+          type: "list",
+          itemType: "Field",
+          inputSchema: ListTableFieldsOptionsSchema,
+          outputSchema: FieldItemSchema,
+          resolvers: {
+            tableId: tableIdResolver
+          }
+        }
+      }
+    }
+  };
+};
+var FieldChangesetItemSchema = z.object({
+  new: FieldApiItemSchema,
+  old: FieldApiItemSchema.nullable(),
+  kind: z.enum(["created", "updated", "deleted"])
+});
+var CreateTableFieldsApiResponseSchema = z.object({
+  data: z.array(FieldChangesetItemSchema),
+  meta: z.object({
+    did_change: z.boolean()
+  }).optional()
+});
+var NewFieldSchema = z.object({
+  type: FieldTypeSchema.describe("The data type of the field"),
+  name: z.string().min(1).describe("The display name of the field"),
+  options: z.record(z.string(), z.unknown()).optional().describe("Data configuration options for the field"),
+  config: z.record(z.string(), z.unknown()).optional().describe("Display configuration for the field")
+});
+var CreateTableFieldsOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fields: z.array(NewFieldSchema).min(1).describe("Array of field definitions to create")
+}).describe("Create one or more fields in a table");
+
+// src/plugins/tables/createTableFields/index.ts
+var createTableFieldsPlugin = ({ context }) => {
+  async function createTableFields(options) {
+    const { api } = context;
+    const rawResponse = await api.post(
+      `/tables/api/v1/tables/${options.tableId}/fields`,
+      {
+        new_fields: options.fields
+      },
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to create fields or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to create fields. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    const response = CreateTableFieldsApiResponseSchema.parse(rawResponse);
+    return {
+      data: response.data.map((changeset) => transformFieldItem(changeset.new))
+    };
+  }
+  const createTableFieldsDefinition = createFunction(
+    createTableFields,
+    CreateTableFieldsOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      createTableFields.name
+    )
+  );
+  return {
+    createTableFields: createTableFieldsDefinition,
+    context: {
+      meta: {
+        createTableFields: {
+          categories: ["table"],
+          type: "create",
+          itemType: "Field",
+          inputSchema: CreateTableFieldsOptionsSchema,
+          outputSchema: FieldItemSchema,
+          resolvers: {
+            tableId: tableIdResolver,
+            fields: tableFieldsResolver
+          }
+        }
+      }
+    }
+  };
+};
+var DeleteTableFieldsOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fieldKeys: z.array(z.union([z.string(), z.number()])).min(1).describe(
+    'Fields to delete. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+  )
+}).describe("Delete one or more fields from a table");
+
+// src/plugins/tables/deleteTableFields/index.ts
+var deleteTableFieldsPlugin = ({ context }) => {
+  async function deleteTableFields(options) {
+    const { api } = context;
+    const numericFieldIds = await resolveFieldKeys({
+      api,
+      tableId: options.tableId,
+      fieldKeys: options.fieldKeys
+    });
+    await api.delete(
+      `/tables/api/v1/tables/${options.tableId}/fields`,
+      { field_ids: numericFieldIds },
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to delete fields or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to delete fields. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    return {
+      success: true
+    };
+  }
+  const deleteTableFieldsDefinition = createFunction(
+    deleteTableFields,
+    DeleteTableFieldsOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      deleteTableFields.name
+    )
+  );
+  return {
+    deleteTableFields: deleteTableFieldsDefinition,
+    context: {
+      meta: {
+        deleteTableFields: {
+          categories: ["table"],
+          type: "delete",
+          itemType: "Field",
+          inputSchema: DeleteTableFieldsOptionsSchema,
+          resolvers: {
+            tableId: tableIdResolver,
+            fieldKeys: tableFieldIdsResolver
+          },
+          confirm: "delete"
+        }
+      }
+    }
+  };
+};
+var RecordApiItemSchema = z.object({
+  id: z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
+  data: z.record(z.string(), z.unknown()),
+  created_at: z.string(),
+  edited_at: z.string(),
+  schema_revision_id: z.number(),
+  errors: z.record(z.string(), z.unknown()).nullable().optional(),
+  orig_data: z.record(z.string(), z.unknown()).nullable().optional(),
+  is_source_record: z.boolean().nullable().optional()
+});
+var RecordItemSchemaBase = z.object({
+  id: z.string(),
+  data: z.record(z.string(), z.unknown()),
+  created_at: z.string(),
+  edited_at: z.string()
+});
+var RecordItemSchema = withFormatter(RecordItemSchemaBase, {
+  format: (item) => ({
+    title: `Record ${item.id}`,
+    id: item.id,
+    data: item.data,
+    details: []
+  })
+});
+var GetTableRecordApiResponseSchema = z.object({
+  data: RecordApiItemSchema
+});
+var GetTableRecordOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordId: z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record"),
+  keyMode: KeyModeSchema
+}).describe("Get a single record from a table by ID");
+
+// src/formatters/tableRecord.ts
+var tableRecordFormatter = {
+  fetch: async (sdk, params, item, context) => {
+    if (context) return context;
+    const hasFieldIds = Object.keys(item.data).some(isFieldId);
+    if (!hasFieldIds) return {};
+    const { data: fields } = await sdk.listTableFields({
+      tableId: params.tableId
+    });
+    return Object.fromEntries(fields.map((f) => [f.id, f.name]));
+  },
+  format: (item, fieldLabels) => ({
+    title: `Record ${item.id}`,
+    id: item.id,
+    details: Object.entries(item.data).map(([k, v]) => ({
+      label: fieldLabels?.[k] ?? k,
+      text: formatFieldValue(v),
+      style: "normal"
+    }))
+  })
+};
+
+// src/plugins/tables/getTableRecord/index.ts
+var getTableRecordPlugin = ({ context }) => {
+  async function getTableRecord(options) {
+    const { api } = context;
+    const rawResponse = await api.get(
+      `/tables/api/v1/tables/${options.tableId}/records/${options.recordId}`,
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access this record or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to access this record. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 404) {
+            return new Error(`Record not found: ${options.recordId}`);
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    const response = GetTableRecordApiResponseSchema.parse(rawResponse);
+    const translator = await createFieldKeyTranslator({
+      api,
+      tableId: options.tableId,
+      keyMode: options.keyMode
+    });
+    return {
+      data: {
+        ...transformRecordItem(response.data),
+        data: translator.translateOutput(response.data.data)
+      }
+    };
+  }
+  const getTableRecordDefinition = createFunction(
+    getTableRecord,
+    GetTableRecordOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      getTableRecord.name
+    )
+  );
+  return {
+    getTableRecord: getTableRecordDefinition,
+    context: {
+      meta: {
+        getTableRecord: {
+          categories: ["table"],
+          type: "item",
+          itemType: "Record",
+          inputSchema: GetTableRecordOptionsSchema,
+          outputSchema: RecordItemSchema,
+          resolvers: {
+            tableId: tableIdResolver,
+            recordId: tableRecordIdResolver
+          },
+          formatter: tableRecordFormatter
+        }
+      }
+    }
+  };
+};
+var ListTableRecordsApiResponseSchema = z.object({
+  data: z.array(RecordApiItemSchema),
+  meta: z.object({
+    pagination: z.object({
+      start_cursor: z.string().nullable().optional(),
+      end_cursor: z.string().nullable().optional(),
+      has_more: z.boolean().optional(),
+      has_less: z.boolean().optional()
+    }).optional()
+  }).optional()
+});
+var FilterOperatorSchema = z.enum([
+  "exact",
+  "different",
+  "contains",
+  "icontains",
+  "gte",
+  "gt",
+  "lt",
+  "lte",
+  "range",
+  "in",
+  "isnull",
+  "startswith",
+  "search",
+  "is_within"
+]);
+var FilterConditionSchema = z.object({
+  fieldKey: z.string().describe("The field key to filter on (e.g. f1, f2)"),
+  operator: FilterOperatorSchema.describe("The comparison operator"),
+  value: z.unknown().optional().describe("The value to compare against")
+});
+var SortDirectionSchema = z.enum(["asc", "desc"]);
+var SortConditionSchema = z.object({
+  fieldKey: z.string().describe("The field key to sort by"),
+  direction: SortDirectionSchema.optional().default("asc").describe("Sort direction")
+});
+var ListTableRecordsOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  filters: z.array(FilterConditionSchema).optional().describe("Filter conditions for the query"),
+  sort: SortConditionSchema.optional().describe("Sort records by a field"),
+  pageSize: z.number().min(1).max(1e3).optional().describe("Number of records per page (max 1000)"),
+  maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Cursor to start from"),
+  keyMode: KeyModeSchema
+}).describe("List records in a table with optional filtering and sorting");
+
+// src/plugins/tables/listTableRecords/index.ts
+function extractNextCursor2(meta) {
+  if (!meta?.pagination?.has_more || !meta.pagination.end_cursor) {
+    return void 0;
+  }
+  return meta.pagination.end_cursor;
+}
+var listTableRecordsPlugin = ({ context }) => {
+  async function listTableRecordsPage(options) {
+    const { api } = context;
+    const translator = await createFieldKeyTranslator({
+      api,
+      tableId: options.tableId,
+      keyMode: options.keyMode
+    });
+    const body = {};
+    if (options.pageSize !== void 0) {
+      body.limit = options.pageSize;
+    }
+    if (options.filters) {
+      body.filters = options.filters.map((f) => ({
+        key: translator.translateFieldKey(f.fieldKey),
+        operator: f.operator,
+        value: f.value
+      }));
+    }
+    if (options.sort) {
+      body.orders = [
+        {
+          key: translator.translateFieldKey(options.sort.fieldKey),
+          direction: options.sort.direction
+        }
+      ];
+    }
+    if (options.cursor) {
+      body.cursor_query = {
+        query_type: "window",
+        start_cursor: options.cursor
+      };
+    }
+    const rawResponse = await api.post(
+      `/tables/api/v1/tables/${options.tableId}/records/query`,
+      body,
+      {
+        searchParams: { allow_nested_queries: "true" },
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access this table or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to access this table. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 404) {
+            return new Error(`Table not found: ${options.tableId}`);
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    throwOnResponseErrors(rawResponse);
+    const response = ListTableRecordsApiResponseSchema.parse(rawResponse);
+    return {
+      data: response.data.map((item) => ({
+        ...transformRecordItem(item),
+        data: translator.translateOutput(item.data)
+      })),
+      nextCursor: extractNextCursor2(response.meta)
+    };
+  }
+  const methodName = stripPageSuffix(listTableRecordsPage.name);
+  const listTableRecordsDefinition = createPaginatedFunction(
+    listTableRecordsPage,
+    ListTableRecordsOptionsSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName,
+    DEFAULT_PAGE_SIZE
+  );
+  return {
+    listTableRecords: listTableRecordsDefinition,
+    context: {
+      meta: {
+        listTableRecords: {
+          categories: ["table"],
+          type: "list",
+          itemType: "Record",
+          inputSchema: ListTableRecordsOptionsSchema,
+          outputSchema: RecordItemSchema,
+          resolvers: {
+            tableId: tableIdResolver,
+            filters: tableFiltersResolver,
+            sort: tableSortResolver
+          },
+          formatter: tableRecordFormatter
+        }
+      }
+    }
+  };
+};
+var RecordChangesetSchema = z.object({
+  change_id: z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: z.array(z.number()).nullable(),
+  record_id: z.string()
+});
+var CreateTableRecordsApiResponseSchema = z.object({
+  data: z.array(RecordChangesetSchema)
+});
+var NewRecordSchema = z.object({
+  data: z.record(z.string(), z.unknown()).describe("The field values for the record, keyed by field ID")
+});
+var CreateTableRecordsOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  records: z.array(NewRecordSchema).min(1).max(100).describe("Array of records to create (max 100)"),
+  keyMode: KeyModeSchema
+}).describe("Create one or more records in a table");
+
+// src/plugins/tables/createTableRecords/index.ts
+var createTableRecordsPlugin = ({ context }) => {
+  async function createTableRecords(options) {
+    const { api } = context;
+    const translator = await createFieldKeyTranslator({
+      api,
+      tableId: options.tableId,
+      keyMode: options.keyMode
+    });
+    const rawResponse = await api.post(
+      `/tables/api/v1/tables/${options.tableId}/records`,
+      {
+        new_records: options.records.map((record) => ({
+          data: translator.translateInput(record.data)
+        }))
+      },
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to create records or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to create records. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 404) {
+            return new Error(`Table not found: ${options.tableId}`);
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    throwOnResponseErrors(rawResponse);
+    const response = CreateTableRecordsApiResponseSchema.parse(rawResponse);
+    for (const changeset of response.data) {
+      throwOnRecordErrors(changeset.new);
+    }
+    return {
+      data: response.data.map((changeset) => ({
+        ...transformRecordItem(changeset.new),
+        data: translator.translateOutput(changeset.new.data)
+      }))
+    };
+  }
+  const createTableRecordsDefinition = createFunction(
+    createTableRecords,
+    CreateTableRecordsOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      createTableRecords.name
+    )
+  );
+  return {
+    createTableRecords: createTableRecordsDefinition,
+    context: {
+      meta: {
+        createTableRecords: {
+          categories: ["table"],
+          type: "create",
+          itemType: "Record",
+          inputSchema: CreateTableRecordsOptionsSchema,
+          outputSchema: RecordItemSchema,
+          resolvers: {
+            tableId: tableIdResolver,
+            records: tableRecordsResolver
+          },
+          formatter: tableRecordFormatter
+        }
+      }
+    }
+  };
+};
+var DeleteTableRecordsOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordIds: z.array(
+    z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")
+  ).min(1).max(100).describe("Array of record IDs to delete (max 100)")
+}).describe("Delete one or more records from a table");
+
+// src/plugins/tables/deleteTableRecords/index.ts
+var deleteTableRecordsPlugin = ({ context }) => {
+  async function deleteTableRecords(options) {
+    const { api } = context;
+    await api.delete(
+      `/tables/api/v1/tables/${options.tableId}/records`,
+      { record_ids: options.recordIds },
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to delete records or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to delete records. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    return {
+      success: true
+    };
+  }
+  const deleteTableRecordsDefinition = createFunction(
+    deleteTableRecords,
+    DeleteTableRecordsOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      deleteTableRecords.name
+    )
+  );
+  return {
+    deleteTableRecords: deleteTableRecordsDefinition,
+    context: {
+      meta: {
+        deleteTableRecords: {
+          categories: ["table"],
+          type: "delete",
+          itemType: "Record",
+          inputSchema: DeleteTableRecordsOptionsSchema,
+          resolvers: {
+            tableId: tableIdResolver,
+            recordIds: tableRecordIdsResolver
+          },
+          confirm: "delete"
+        }
+      }
+    }
+  };
+};
+var RecordChangesetSchema2 = z.object({
+  change_id: z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: z.array(z.number()).nullable(),
+  record_id: z.string()
+});
+var UpdateTableRecordsApiResponseSchema = z.object({
+  data: z.array(RecordChangesetSchema2)
+});
+var UpdateRecordSchema = z.object({
+  id: z.string().describe("The record ID to update"),
+  data: z.record(z.string(), z.unknown()).describe("The field values to update, keyed by field key")
+});
+var UpdateTableRecordsOptionsSchema = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  records: z.array(UpdateRecordSchema).min(1).max(100).describe("Array of records to update (max 100)"),
+  keyMode: KeyModeSchema
+}).describe("Update one or more records in a table");
+
+// src/plugins/tables/updateTableRecords/index.ts
+var updateTableRecordsPlugin = ({ context }) => {
+  async function updateTableRecords(options) {
+    const { api } = context;
+    const translator = await createFieldKeyTranslator({
+      api,
+      tableId: options.tableId,
+      keyMode: options.keyMode
+    });
+    const rawResponse = await api.patch(
+      `/tables/api/v1/tables/${options.tableId}/records`,
+      {
+        updated_records: options.records.map((record) => ({
+          id: record.id,
+          data: translator.translateInput(record.data)
+        }))
+      },
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to update records or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to update records. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 404) {
+            return new Error(`Table not found: ${options.tableId}`);
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    throwOnResponseErrors(rawResponse);
+    const response = UpdateTableRecordsApiResponseSchema.parse(rawResponse);
+    for (const changeset of response.data) {
+      throwOnRecordErrors(changeset.new);
+    }
+    return {
+      data: response.data.map((changeset) => ({
+        ...transformRecordItem(changeset.new),
+        data: translator.translateOutput(changeset.new.data)
+      }))
+    };
+  }
+  const updateTableRecordsDefinition = createFunction(
+    updateTableRecords,
+    UpdateTableRecordsOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      updateTableRecords.name
+    )
+  );
+  return {
+    updateTableRecords: updateTableRecordsDefinition,
+    context: {
+      meta: {
+        updateTableRecords: {
+          categories: ["table"],
+          type: "update",
+          itemType: "Record",
+          inputSchema: UpdateTableRecordsOptionsSchema,
+          outputSchema: RecordItemSchema,
+          resolvers: {
+            tableId: tableIdResolver,
+            records: tableUpdateRecordsResolver
+          },
+          formatter: tableRecordFormatter
+        }
+      }
+    }
+  };
+};
+
+// src/plugins/registry/index.ts
+var registryPlugin = ({ sdk, context }) => {
+  const metaKeys = Object.keys(context.meta || {});
+  const categoryDefinitions = {
+    account: {
+      title: "Account"
+    },
+    app: {
+      title: "App",
+      titlePlural: "Apps"
+    },
+    connection: {
+      title: "Connection"
+    },
+    action: {
+      title: "Action"
+    },
+    "client-credentials": {
+      title: "Client Credentials",
+      titlePlural: "Client Credentials"
+    },
+    table: {
+      title: "Table"
+    },
+    http: {
+      title: "HTTP Request"
+    },
+    utility: {
+      title: "Utility",
+      titlePlural: "Utilities"
+    },
+    other: {
+      title: "Other"
+    }
+  };
+  const functions = metaKeys.filter((key) => {
+    const property = sdk[key];
+    if (typeof property === "function") {
+      return true;
+    }
+    const [rootKey] = key.split(".");
+    const rootProperty = sdk[rootKey];
+    if (typeof rootProperty === "object" && rootProperty !== null) {
+      return true;
+    }
+    return false;
+  }).map((key) => {
+    const meta = context.meta[key];
+    return {
+      name: key,
+      description: meta.description,
+      type: meta.type,
+      itemType: meta.itemType,
+      returnType: meta.returnType,
+      inputSchema: meta.inputSchema,
+      inputParameters: meta.inputParameters,
+      outputSchema: meta.outputSchema,
+      categories: meta.categories || [],
+      resolvers: meta.resolvers,
+      formatter: meta.formatter,
+      packages: meta.packages,
+      // Auto-infer confirm: "delete" from type: "delete" (all deletes should confirm)
+      confirm: meta.confirm ?? (meta.type === "delete" ? "delete" : void 0),
+      deprecation: meta.deprecation,
+      deprecatedParameters: meta.deprecatedParameters,
+      aliases: meta.aliases,
+      supportsJsonOutput: meta.supportsJsonOutput ?? true
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const knownCategories = Object.keys(categoryDefinitions);
+  const registryCache = /* @__PURE__ */ new Map();
+  function getRegistry(options) {
+    const packageFilter = options?.package;
+    const cacheKey = packageFilter || "__all__";
+    if (registryCache.has(cacheKey)) {
+      return registryCache.get(cacheKey);
+    }
+    const filteredFunctions = packageFilter ? functions.filter(
+      (f) => (
+        // Include if packages is undefined (belongs to all packages) or includes the specified package
+        !f.packages || f.packages.includes(packageFilter)
+      )
+    ) : functions;
+    const filteredCategories = knownCategories.sort((a, b) => {
+      if (a === "other") return 1;
+      if (b === "other") return -1;
+      const titleA = categoryDefinitions[a].title;
+      const titleB = categoryDefinitions[b].title;
+      return titleA.localeCompare(titleB);
+    }).map((categoryKey) => {
+      const categoryFunctions = filteredFunctions.filter(
+        (f) => f.categories.includes(categoryKey) || // If the category is "other" and the function is not in any other category, include it
+        categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
+      ).map((f) => f.name).sort();
+      const definition = categoryDefinitions[categoryKey];
+      const title = definition.title;
+      return {
+        key: categoryKey,
+        title,
+        titlePlural: definition.titlePlural ?? `${title}s`,
+        functions: categoryFunctions
+      };
+    }).filter((category) => category.functions.length > 0);
+    const result = {
+      functions: filteredFunctions,
+      categories: filteredCategories
+    };
+    registryCache.set(cacheKey, result);
+    return result;
+  }
+  return {
+    getRegistry
+  };
+};
+
+// src/plugins/deprecated/authentications.ts
+var listAuthenticationsPlugin = ({ sdk }) => ({
+  listAuthentications: sdk.listConnections,
+  context: {
+    meta: {
+      listAuthentications: {
+        packages: ["cli", "mcp"],
+        categories: ["connection", "deprecated"],
+        type: "list",
+        itemType: "Connection",
+        inputSchema: ListConnectionsQuerySchema,
+        outputSchema: ConnectionItemSchema
+      }
+    }
+  }
+});
+var getAuthenticationPlugin = ({ sdk }) => ({
+  getAuthentication: sdk.getConnection,
+  context: {
+    meta: {
+      getAuthentication: {
+        packages: ["cli", "mcp"],
+        categories: ["connection", "deprecated"],
+        type: "item",
+        itemType: "Connection",
+        inputSchema: GetConnectionParamSchema,
+        outputSchema: ConnectionItemSchema
+      }
+    }
+  }
+});
+var findFirstAuthenticationPlugin = ({ sdk }) => ({
+  findFirstAuthentication: sdk.findFirstConnection,
+  context: {
+    meta: {
+      findFirstAuthentication: {
+        packages: ["cli", "mcp"],
         categories: ["connection", "deprecated"],
         type: "item",
         itemType: "Connection",
@@ -5373,7 +7210,8 @@ var listInputFieldChoicesPlugin = ({ context, sdk }) => {
     listInputFieldChoicesPage,
     ListInputFieldChoicesSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listInputFieldChoices: listInputFieldChoicesDefinition,
@@ -5558,7 +7396,7 @@ function getCpuTime() {
 }
 
 // src/plugins/eventEmission/builders.ts
-var SDK_VERSION = "0.34.1";
+var SDK_VERSION = "0.36.0";
 function createBaseEvent(context = {}) {
   return {
     event_id: generateEventId(),
@@ -6051,7 +7889,7 @@ function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} })
   };
 }
 function createZapierSdkWithoutRegistry(options = {}) {
-  return createSdk(options).addPlugin(eventEmissionPlugin).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(getInputFieldsSchemaPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listConnectionsPlugin).addPlugin(getConnectionPlugin).addPlugin(findFirstConnectionPlugin).addPlugin(findUniqueConnectionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(listClientCredentialsPlugin).addPlugin(createClientCredentialsPlugin).addPlugin(deleteClientCredentialsPlugin).addPlugin(fetchPlugin).addPlugin(requestPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
+  return createSdk(options).addPlugin(eventEmissionPlugin).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(getInputFieldsSchemaPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listConnectionsPlugin).addPlugin(getConnectionPlugin).addPlugin(findFirstConnectionPlugin).addPlugin(findUniqueConnectionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(listClientCredentialsPlugin).addPlugin(createClientCredentialsPlugin).addPlugin(deleteClientCredentialsPlugin).addPlugin(fetchPlugin).addPlugin(requestPlugin).addPlugin(listTablesPlugin).addPlugin(getTablePlugin).addPlugin(deleteTablePlugin).addPlugin(createTablePlugin).addPlugin(listTableFieldsPlugin).addPlugin(createTableFieldsPlugin).addPlugin(deleteTableFieldsPlugin).addPlugin(getTableRecordPlugin).addPlugin(listTableRecordsPlugin).addPlugin(createTableRecordsPlugin).addPlugin(deleteTableRecordsPlugin).addPlugin(updateTableRecordsPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
 }
 function createZapierSdk(options = {}) {
   return createZapierSdkWithoutRegistry(options).addPlugin(registryPlugin);
@@ -6085,4 +7923,4 @@ var BaseSdkOptionsSchema = z.object({
   // Use credentials instead
 });
 
-export { ActionKeyPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, ClientCredentialsObjectSchema, ConnectionIdPropertySchema, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DebugPropertySchema, InputsPropertySchema, LimitPropertySchema, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, ZAPIER_BASE_URL, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierResourceNotFoundError, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, connectionIdGenericResolver, connectionIdResolver, createBaseEvent, createClientCredentialsPlugin, createFunction, createSdk, createZapierSdk, createZapierSdkWithoutRegistry, deleteClientCredentialsPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionPlugin, getAppPlugin, getBaseUrlFromCredentials, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTokenFromCliLogin, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCredentialsFunction, isCredentialsObject, isPkceCredentials, isPositional, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listInputFieldsPlugin, logDeprecation, manifestPlugin, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runWithTelemetryContext, toSnakeCase, toTitleCase };
+export { ActionKeyPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, ClientCredentialsObjectSchema, ConnectionIdPropertySchema, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_PAGE_SIZE, DebugPropertySchema, InputsPropertySchema, LimitPropertySchema, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, ZAPIER_BASE_URL, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierResourceNotFoundError, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, connectionIdGenericResolver, connectionIdResolver, createBaseEvent, createClientCredentialsPlugin, createFunction, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierSdk, createZapierSdkWithoutRegistry, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionPlugin, getAppPlugin, getBaseUrlFromCredentials, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCredentialsFunction, isCredentialsObject, isPkceCredentials, isPositional, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listInputFieldsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation, manifestPlugin, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, updateTableRecordsPlugin };