@zapier/zapier-sdk 0.34.0 → 0.35.0

package/dist/index.cjs

@@ -832,6 +832,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) => {
@@ -1863,6 +1925,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 = {
@@ -2655,25 +3336,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
     };
@@ -4510,6 +5195,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 +5267,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,19 +5675,1093 @@ 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: {
+// 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 = 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/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 = zod.z.object({
+  data: TableApiItemSchema
+});
+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 = {
+      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 = 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: {
@@ -5004,6 +6771,9 @@ var registryPlugin = ({ sdk, context }) => {
       title: "Client Credentials",
       titlePlural: "Client Credentials"
     },
+    table: {
+      title: "Table"
+    },
     http: {
       title: "HTTP Request"
     },
@@ -5039,6 +6809,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),
@@ -5580,7 +7351,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(),
@@ -6073,7 +7844,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);
@@ -6169,9 +7940,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 +7969,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 +7990,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 +8004,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;