@zapier/zapier-sdk 0.34.1 → 0.36.0

package/dist/index.cjs

@@ -64,6 +64,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];
@@ -832,6 +833,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) => {
@@ -982,7 +1045,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;
@@ -996,7 +1059,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
@@ -1170,7 +1233,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 }
       }
     });
@@ -1180,7 +1245,8 @@ var listAppsPlugin = ({ context }) => {
     listAppsPage,
     ListAppsSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listApps: listAppsDefinition,
@@ -1863,6 +1929,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 = zod.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 = zod.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 = zod.z.object({
+  id: zod.z.number(),
+  type: FieldTypeSchema,
+  name: zod.z.string(),
+  created_at: zod.z.string().optional(),
+  edited_at: zod.z.string().optional(),
+  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  is_order_field: zod.z.boolean().optional(),
+  is_filter_field: zod.z.boolean().optional(),
+  is_selected_field: zod.z.boolean().optional()
+});
+var ListTableFieldsApiResponseSchema = zod.z.object({
+  data: zod.z.array(FieldApiItemSchema)
+});
+var FieldItemSchemaBase = zod.z.object({
+  id: zod.z.string(),
+  type: FieldTypeSchema,
+  name: zod.z.string(),
+  created_at: zod.z.string().optional(),
+  edited_at: zod.z.string().optional(),
+  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var FieldItemSchema = withFormatter(FieldItemSchemaBase, {
+  format: (item) => ({
+    title: item.name,
+    id: item.id,
+    details: [{ text: `Type: ${item.type}`, style: "dim" }]
+  })
+});
+var ListTableFieldsOptionsSchema = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fieldKeys: zod.z.array(zod.z.union([zod.z.string(), zod.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 = {
@@ -1942,7 +2627,8 @@ var listActionsPlugin = ({ context }) => {
     listActionsPage,
     ListActionsSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listActions: listActionsDefinition,
@@ -2299,7 +2985,8 @@ var listInputFieldsPlugin = ({ sdk, context }) => {
     listInputFieldsPage,
     ListInputFieldsSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listInputFields: listInputFieldsDefinition,
@@ -2385,9 +3072,10 @@ var ConnectionItemSchema = withFormatter(connections.ConnectionItemSchema, {
 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
@@ -2451,7 +3139,8 @@ var listConnectionsPlugin = ({ context }) => {
     listConnectionsPage,
     ListConnectionsQuerySchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listConnections: listConnectionsDefinition,
@@ -2529,9 +3218,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;
     }
@@ -2565,7 +3255,8 @@ var listClientCredentialsPlugin = ({ context }) => {
     listClientCredentialsPage,
     ListClientCredentialsQuerySchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listClientCredentials: listClientCredentialsDefinition,
@@ -2655,25 +3346,29 @@ var DeleteClientCredentialsSchema = zod.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
     };
@@ -2980,6 +3675,7 @@ async function executeAction(actionOptions) {
     actionKey,
     actionType,
     executionOptions,
+    cursor,
     connectionId,
     timeoutMs
   } = actionOptions;
@@ -2993,6 +3689,9 @@ async function executeAction(actionOptions) {
   if (connectionId !== null && connectionId !== void 0) {
     runRequestData.authentication_id = connectionId;
   }
+  if (cursor) {
+    runRequestData.page = cursor;
+  }
   const runRequest = {
     data: runRequestData
   };
@@ -3012,19 +3711,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(
@@ -3032,11 +3764,6 @@ var runActionPlugin = ({ sdk, context }) => {
         { configType: "current_implementation_id" }
       );
     }
-    setMethodMetadata({
-      selectedApi,
-      operationType: actionType,
-      operationKey: actionKey
-    });
     const actionData = await sdk.getAction({
       appKey,
       actionKey,
@@ -3047,7 +3774,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,
@@ -3057,6 +3804,7 @@ var runActionPlugin = ({ sdk, context }) => {
       actionKey,
       actionType,
       executionOptions: { inputs },
+      cursor,
       connectionId: resolvedConnectionId,
       timeoutMs
     });
@@ -3071,8 +3819,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);
@@ -4510,6 +5257,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 {
@@ -4577,8 +5329,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({
@@ -4982,155 +5737,1237 @@ async function batch(tasks, options = {}) {
   await Promise.all(workers);
   return results;
 }
+var TableApiItemSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string().nullable().optional(),
+  created_at: zod.z.string(),
+  edited_at: zod.z.string(),
+  kind: zod.z.enum(["table", "virtual_table"]),
+  owner_account_id: zod.z.number(),
+  owner_user_id: zod.z.number().nullable().optional(),
+  owner_zapier_customuser_id: zod.z.number(),
+  parent_table_id: zod.z.string().nullable().optional()
+});
+var ListTablesApiResponseSchema = zod.z.object({
+  data: zod.z.array(TableApiItemSchema),
+  links: zod.z.object({
+    next: zod.z.string().nullable().optional()
+  }).optional()
+});
+var TableItemSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  created_at: zod.z.string(),
+  edited_at: zod.z.string(),
+  kind: zod.z.enum(["table", "virtual_table"]),
+  owner_account_id: zod.z.string(),
+  profile_id: zod.z.string(),
+  parent_table_id: zod.z.string().optional()
+});
+var ListTablesOptionsSchema = zod.z.object({
+  tableIds: zod.z.array(zod.z.string()).optional().describe("Filter by specific table IDs"),
+  kind: zod.z.enum(["table", "virtual_table", "both"]).optional().describe("Filter by table type"),
+  search: zod.z.string().optional().describe("Search term to filter tables by name"),
+  owner: zod.z.string().optional().describe(
+    'Filter by table owner. Use "me" for the current user, or a numeric user ID.'
+  ),
+  pageSize: zod.z.number().min(1).optional().describe("Number of tables per page"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: zod.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 = zod.z.object({
+  data: TableApiItemSchema
+});
+var GetTableOptionsSchema = zod.z.object({
+  tableId: zod.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 = zod.z.object({
+  data: TableApiItemSchema
 });
-var findFirstAuthenticationPlugin = ({ sdk }) => ({
-  findFirstAuthentication: sdk.findFirstConnection,
-  context: {
-    meta: {
-      findFirstAuthentication: {
-        packages: ["cli", "mcp"],
+var CreateTableOptionsSchema = zod.z.object({
+  name: zod.z.string().min(1).describe("The name for the new table"),
+  description: zod.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 = zod.z.object({
+  tableId: zod.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 = zod.z.object({
+  new: FieldApiItemSchema,
+  old: FieldApiItemSchema.nullable(),
+  kind: zod.z.enum(["created", "updated", "deleted"])
+});
+var CreateTableFieldsApiResponseSchema = zod.z.object({
+  data: zod.z.array(FieldChangesetItemSchema),
+  meta: zod.z.object({
+    did_change: zod.z.boolean()
+  }).optional()
+});
+var NewFieldSchema = zod.z.object({
+  type: FieldTypeSchema.describe("The data type of the field"),
+  name: zod.z.string().min(1).describe("The display name of the field"),
+  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Data configuration options for the field"),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Display configuration for the field")
+});
+var CreateTableFieldsOptionsSchema = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fields: zod.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 = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fieldKeys: zod.z.array(zod.z.union([zod.z.string(), zod.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 = zod.z.object({
+  id: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()),
+  created_at: zod.z.string(),
+  edited_at: zod.z.string(),
+  schema_revision_id: zod.z.number(),
+  errors: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
+  orig_data: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
+  is_source_record: zod.z.boolean().nullable().optional()
+});
+var RecordItemSchemaBase = zod.z.object({
+  id: zod.z.string(),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()),
+  created_at: zod.z.string(),
+  edited_at: zod.z.string()
+});
+var RecordItemSchema = withFormatter(RecordItemSchemaBase, {
+  format: (item) => ({
+    title: `Record ${item.id}`,
+    id: item.id,
+    data: item.data,
+    details: []
+  })
+});
+var GetTableRecordApiResponseSchema = zod.z.object({
+  data: RecordApiItemSchema
+});
+var GetTableRecordOptionsSchema = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordId: zod.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 = zod.z.object({
+  data: zod.z.array(RecordApiItemSchema),
+  meta: zod.z.object({
+    pagination: zod.z.object({
+      start_cursor: zod.z.string().nullable().optional(),
+      end_cursor: zod.z.string().nullable().optional(),
+      has_more: zod.z.boolean().optional(),
+      has_less: zod.z.boolean().optional()
+    }).optional()
+  }).optional()
+});
+var FilterOperatorSchema = zod.z.enum([
+  "exact",
+  "different",
+  "contains",
+  "icontains",
+  "gte",
+  "gt",
+  "lt",
+  "lte",
+  "range",
+  "in",
+  "isnull",
+  "startswith",
+  "search",
+  "is_within"
+]);
+var FilterConditionSchema = zod.z.object({
+  fieldKey: zod.z.string().describe("The field key to filter on (e.g. f1, f2)"),
+  operator: FilterOperatorSchema.describe("The comparison operator"),
+  value: zod.z.unknown().optional().describe("The value to compare against")
+});
+var SortDirectionSchema = zod.z.enum(["asc", "desc"]);
+var SortConditionSchema = zod.z.object({
+  fieldKey: zod.z.string().describe("The field key to sort by"),
+  direction: SortDirectionSchema.optional().default("asc").describe("Sort direction")
+});
+var ListTableRecordsOptionsSchema = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  filters: zod.z.array(FilterConditionSchema).optional().describe("Filter conditions for the query"),
+  sort: SortConditionSchema.optional().describe("Sort records by a field"),
+  pageSize: zod.z.number().min(1).max(1e3).optional().describe("Number of records per page (max 1000)"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: zod.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 = zod.z.object({
+  change_id: zod.z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: zod.z.array(zod.z.number()).nullable(),
+  record_id: zod.z.string()
+});
+var CreateTableRecordsApiResponseSchema = zod.z.object({
+  data: zod.z.array(RecordChangesetSchema)
+});
+var NewRecordSchema = zod.z.object({
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe("The field values for the record, keyed by field ID")
+});
+var CreateTableRecordsOptionsSchema = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  records: zod.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 = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordIds: zod.z.array(
+    zod.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 = zod.z.object({
+  change_id: zod.z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: zod.z.array(zod.z.number()).nullable(),
+  record_id: zod.z.string()
+});
+var UpdateTableRecordsApiResponseSchema = zod.z.object({
+  data: zod.z.array(RecordChangesetSchema2)
+});
+var UpdateRecordSchema = zod.z.object({
+  id: zod.z.string().describe("The record ID to update"),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe("The field values to update, keyed by field key")
+});
+var UpdateTableRecordsOptionsSchema = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  records: zod.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",
@@ -5395,7 +7232,8 @@ var listInputFieldChoicesPlugin = ({ context, sdk }) => {
     listInputFieldChoicesPage,
     ListInputFieldChoicesSchema,
     createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
+    methodName,
+    DEFAULT_PAGE_SIZE
   );
   return {
     listInputFieldChoices: listInputFieldChoicesDefinition,
@@ -5580,7 +7418,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(),
@@ -6073,7 +7911,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);
@@ -6113,6 +7951,8 @@ exports.ActionTypePropertySchema = ActionTypePropertySchema;
 exports.AppKeyPropertySchema = AppKeyPropertySchema;
 exports.AuthenticationIdPropertySchema = AuthenticationIdPropertySchema;
 exports.BaseSdkOptionsSchema = BaseSdkOptionsSchema;
+exports.CONTEXT_CACHE_MAX_SIZE = CONTEXT_CACHE_MAX_SIZE;
+exports.CONTEXT_CACHE_TTL_MS = CONTEXT_CACHE_TTL_MS;
 exports.ClientCredentialsObjectSchema = ClientCredentialsObjectSchema;
 exports.ConnectionIdPropertySchema = ConnectionIdPropertySchema;
 exports.CredentialsFunctionSchema = CredentialsFunctionSchema;
@@ -6120,6 +7960,7 @@ exports.CredentialsObjectSchema = CredentialsObjectSchema;
 exports.CredentialsSchema = CredentialsSchema;
 exports.DEFAULT_ACTION_TIMEOUT_MS = DEFAULT_ACTION_TIMEOUT_MS;
 exports.DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_PATH;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
 exports.DebugPropertySchema = DebugPropertySchema;
 exports.InputsPropertySchema = InputsPropertySchema;
 exports.LimitPropertySchema = LimitPropertySchema;
@@ -6169,9 +8010,15 @@ exports.createBaseEvent = createBaseEvent;
 exports.createClientCredentialsPlugin = createClientCredentialsPlugin;
 exports.createFunction = createFunction;
 exports.createSdk = createSdk;
+exports.createTableFieldsPlugin = createTableFieldsPlugin;
+exports.createTablePlugin = createTablePlugin;
+exports.createTableRecordsPlugin = createTableRecordsPlugin;
 exports.createZapierSdk = createZapierSdk;
 exports.createZapierSdkWithoutRegistry = createZapierSdkWithoutRegistry;
 exports.deleteClientCredentialsPlugin = deleteClientCredentialsPlugin;
+exports.deleteTableFieldsPlugin = deleteTableFieldsPlugin;
+exports.deleteTablePlugin = deleteTablePlugin;
+exports.deleteTableRecordsPlugin = deleteTableRecordsPlugin;
 exports.fetchPlugin = fetchPlugin;
 exports.findFirstConnectionPlugin = findFirstConnectionPlugin;
 exports.findManifestEntry = findManifestEntry;
@@ -6192,6 +8039,8 @@ exports.getPlatformVersions = getPlatformVersions;
 exports.getPreferredManifestEntryKey = getPreferredManifestEntryKey;
 exports.getProfilePlugin = getProfilePlugin;
 exports.getReleaseId = getReleaseId;
+exports.getTablePlugin = getTablePlugin;
+exports.getTableRecordPlugin = getTableRecordPlugin;
 exports.getTokenFromCliLogin = getTokenFromCliLogin;
 exports.injectCliLogin = injectCliLogin;
 exports.inputFieldKeyResolver = inputFieldKeyResolver;
@@ -6211,6 +8060,9 @@ exports.listAppsPlugin = listAppsPlugin;
 exports.listClientCredentialsPlugin = listClientCredentialsPlugin;
 exports.listConnectionsPlugin = listConnectionsPlugin;
 exports.listInputFieldsPlugin = listInputFieldsPlugin;
+exports.listTableFieldsPlugin = listTableFieldsPlugin;
+exports.listTableRecordsPlugin = listTableRecordsPlugin;
+exports.listTablesPlugin = listTablesPlugin;
 exports.logDeprecation = logDeprecation;
 exports.manifestPlugin = manifestPlugin;
 exports.readManifestFromFile = readManifestFromFile;
@@ -6222,5 +8074,16 @@ exports.resolveCredentials = resolveCredentials;
 exports.resolveCredentialsFromEnv = resolveCredentialsFromEnv;
 exports.runActionPlugin = runActionPlugin;
 exports.runWithTelemetryContext = runWithTelemetryContext;
+exports.tableFieldIdsResolver = tableFieldIdsResolver;
+exports.tableFieldsResolver = tableFieldsResolver;
+exports.tableFiltersResolver = tableFiltersResolver;
+exports.tableIdResolver = tableIdResolver;
+exports.tableNameResolver = tableNameResolver;
+exports.tableRecordIdResolver = tableRecordIdResolver;
+exports.tableRecordIdsResolver = tableRecordIdsResolver;
+exports.tableRecordsResolver = tableRecordsResolver;
+exports.tableSortResolver = tableSortResolver;
+exports.tableUpdateRecordsResolver = tableUpdateRecordsResolver;
 exports.toSnakeCase = toSnakeCase;
 exports.toTitleCase = toTitleCase;
+exports.updateTableRecordsPlugin = updateTableRecordsPlugin;