@zapier/zapier-sdk 0.34.0 → 0.35.0

package/dist/index.mjs

@@ -810,6 +810,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) => {
@@ -1841,6 +1903,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 = {
@@ -2633,25 +3314,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
     };
@@ -4488,6 +5173,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 +5245,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,19 +5653,1093 @@ 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: {
+// 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 = {
+      limit: options.pageSize.toString()
+    };
+    if (options?.tableIds && options.tableIds.length > 0) {
+      searchParams.ids = options.tableIds.join(",");
+    }
+    if (options?.kind) {
+      searchParams.kind = options.kind;
+    }
+    if (options?.search) {
+      searchParams.q = options.search;
+    }
+    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)
+    };
+  }
+  const methodName = stripPageSuffix(listTablesPage.name);
+  const listTablesDefinition = createPaginatedFunction(
+    listTablesPage,
+    ListTablesOptionsSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
+  );
+  return {
+    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/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)
+    };
+  }
+  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 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 = {
+      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
+  );
+  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: {
@@ -4982,6 +6749,9 @@ var registryPlugin = ({ sdk, context }) => {
       title: "Client Credentials",
       titlePlural: "Client Credentials"
     },
+    table: {
+      title: "Table"
+    },
     http: {
       title: "HTTP Request"
     },
@@ -5017,6 +6787,7 @@ var registryPlugin = ({ sdk, context }) => {
       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),
@@ -5558,7 +7329,7 @@ function getCpuTime() {
 }
 
 // src/plugins/eventEmission/builders.ts
-var SDK_VERSION = "0.34.0";
+var SDK_VERSION = "0.35.0";
 function createBaseEvent(context = {}) {
   return {
     event_id: generateEventId(),
@@ -6051,7 +7822,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 +7856,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, 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, 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 };