@zapier/trello-connector 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,2654 @@
+// index.ts
+import { defineConnector, toFunctions } from "@zapier/connectors-sdk";
+
+// connections.ts
+import {
+  defineEnvPrefixResolver,
+  zapierConnectionResolver
+} from "@zapier/connectors-sdk";
+var TRELLO_OAUTH_HEADER = (apiKey, token) => `OAuth oauth_consumer_key="${apiKey}", oauth_token="${token}"`;
+var directTrelloResolver = defineEnvPrefixResolver({
+  name: "env",
+  keys: ["API_KEY", "TOKEN"],
+  build: ({ API_KEY, TOKEN }) => {
+    const authorization = TRELLO_OAUTH_HEADER(API_KEY, TOKEN);
+    return (url, init = {}) => {
+      const headers = new Headers(init.headers);
+      headers.set("Authorization", authorization);
+      return globalThis.fetch(url, { ...init, headers });
+    };
+  }
+});
+var connectionResolvers = {
+  trello: [zapierConnectionResolver, directTrelloResolver]
+};
+
+// scripts/addCardAttachment.ts
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z } from "zod";
+
+// lib/trello.ts
+import { ConnectorHttpError, readResponseBody } from "@zapier/connectors-sdk";
+var TRELLO_BASE = "https://api.trello.com/1";
+var TRELLO_ID_REGEX = /^[0-9a-fA-F]{24}$/;
+async function trelloError(tool, res) {
+  const body = await readResponseBody(res);
+  let hint = "";
+  if (res.status === 404) {
+    hint = " \u2014 verify the id exists and you have access.";
+  } else if (res.status === 401) {
+    hint = " \u2014 check Trello auth credentials.";
+  }
+  throw ConnectorHttpError.fromResponseBody(res, body, {
+    message: `Trello ${tool} ${res.status}${hint}`
+  });
+}
+function trelloFormBody(fields) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, String(value));
+  }
+  return params.toString();
+}
+var trelloFormHeaders = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function nameContains(name, query) {
+  return name.toLowerCase().includes(query.toLowerCase());
+}
+
+// scripts/addCardAttachment.ts
+var inputSchema = z.object({
+  id: z.string().describe("24-char hex card id."),
+  url: z.string().url().describe(
+    "URL to attach (link attachment). Mutually exclusive with fileUrl."
+  ).optional(),
+  fileUrl: z.string().url().describe(
+    "Remote file URL to download and upload. Mutually exclusive with url."
+  ).optional(),
+  name: z.string().describe("Attachment display name.").optional(),
+  mimeType: z.string().optional()
+}).strict().refine((v) => v.url ? !v.fileUrl : !!v.fileUrl, {
+  message: "Provide exactly one of url or fileUrl."
+});
+var outputSchema = z.object({
+  id: z.string().regex(TRELLO_ID_REGEX),
+  name: z.string(),
+  url: z.string(),
+  mimeType: z.string().nullable().optional(),
+  bytes: z.number().nullable().optional(),
+  isUpload: z.boolean().nullable().optional()
+});
+var definition = defineTool({
+  name: "addCardAttachment",
+  title: "Add Card Attachment",
+  description: "Add a URL link attachment or upload a file from a remote URL to a card. Provide url OR fileUrl, not both.",
+  inputSchema,
+  outputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const cardPath = `${TRELLO_BASE}/cards/${encodeURIComponent(input.id)}/attachments`;
+    if (input.fileUrl) {
+      const fileRes = await ctx.fetch(input.fileUrl);
+      if (!fileRes.ok) await trelloError("addCardAttachment", fileRes);
+      const buffer = await fileRes.arrayBuffer();
+      const fileName = input.name ?? "attachment";
+      const form = new FormData();
+      form.append(
+        "file",
+        new Blob([buffer], {
+          type: input.mimeType ?? fileRes.headers.get("content-type") ?? void 0
+        }),
+        fileName
+      );
+      form.append("name", fileName);
+      if (input.mimeType) form.append("mimeType", input.mimeType);
+      const uploadRes = await ctx.fetch(cardPath, {
+        method: "POST",
+        body: form
+      });
+      if (!uploadRes.ok) await trelloError("addCardAttachment", uploadRes);
+      return uploadRes.json();
+    }
+    const linkRes = await ctx.fetch(cardPath, {
+      method: "POST",
+      headers: trelloFormHeaders,
+      body: trelloFormBody({
+        url: input.url,
+        name: input.name ?? input.url,
+        mimeType: input.mimeType
+      })
+    });
+    if (!linkRes.ok) await trelloError("addCardAttachment", linkRes);
+    return linkRes.json();
+  }
+});
+var addCardAttachment_default = definition;
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });
+
+// scripts/addCardLabel.ts
+import { defineTool as defineTool2, handleIfScriptMain as handleIfScriptMain2 } from "@zapier/connectors-sdk";
+import { z as z2 } from "zod";
+var inputSchema2 = z2.object({
+  id: z2.string().describe("24-char hex card id."),
+  value: z2.string().describe("Label id from listLabels.")
+}).strict();
+var outputSchema2 = z2.object({
+  id: z2.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z2.string(),
+  desc: z2.string().nullable().optional(),
+  closed: z2.boolean().nullable().optional(),
+  idBoard: z2.string(),
+  idList: z2.string(),
+  idShort: z2.number().int().nullable().optional(),
+  shortLink: z2.string().nullable().optional(),
+  shortUrl: z2.string().nullable().optional(),
+  url: z2.string().nullable().optional(),
+  due: z2.union([z2.string().datetime({ offset: true }), z2.null()]).optional(),
+  dueComplete: z2.boolean().nullable().optional(),
+  dateLastActivity: z2.string().datetime({ offset: true }).nullable().optional(),
+  idLabels: z2.array(z2.string()).nullable().optional(),
+  idMembers: z2.array(z2.string()).nullable().optional(),
+  labels: z2.array(
+    z2.object({
+      id: z2.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+      idBoard: z2.string(),
+      name: z2.string().nullable().optional(),
+      color: z2.string().nullable().optional()
+    })
+  ).nullable().optional(),
+  pos: z2.number().nullable().optional(),
+  customFields: z2.record(z2.string(), z2.any()).nullable().describe("Custom field values keyed by field name when requested.").optional()
+});
+var definition2 = defineTool2({
+  name: "addCardLabel",
+  title: "Add Card Label",
+  description: "Add an existing board label to a card by label id.",
+  inputSchema: inputSchema2,
+  outputSchema: outputSchema2,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/idLabels`;
+    const body = {};
+    if (input.value !== void 0) body["value"] = input.value;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello addCardLabel ${res.status}: ${errBody}`);
+    }
+    const cardRes = await ctx.fetch(
+      `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}`
+    );
+    if (!cardRes.ok) {
+      const errBody = await cardRes.text();
+      throw new Error(`Trello addCardLabel ${cardRes.status}: ${errBody}`);
+    }
+    return cardRes.json();
+  }
+});
+var addCardLabel_default = definition2;
+await handleIfScriptMain2(import.meta, definition2, { connectionResolvers });
+
+// scripts/addCardMember.ts
+import { defineTool as defineTool3, handleIfScriptMain as handleIfScriptMain3 } from "@zapier/connectors-sdk";
+import { z as z3 } from "zod";
+var inputSchema3 = z3.object({
+  id: z3.string().describe("24-char hex card id."),
+  value: z3.string().describe("Member id to add.")
+}).strict();
+var outputSchema3 = z3.object({
+  id: z3.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z3.string(),
+  desc: z3.string().nullable().optional(),
+  closed: z3.boolean().nullable().optional(),
+  idBoard: z3.string(),
+  idList: z3.string(),
+  idShort: z3.number().int().nullable().optional(),
+  shortLink: z3.string().nullable().optional(),
+  shortUrl: z3.string().nullable().optional(),
+  url: z3.string().nullable().optional(),
+  due: z3.union([z3.string().datetime({ offset: true }), z3.null()]).optional(),
+  dueComplete: z3.boolean().nullable().optional(),
+  dateLastActivity: z3.string().datetime({ offset: true }).nullable().optional(),
+  idLabels: z3.array(z3.string()).nullable().optional(),
+  idMembers: z3.array(z3.string()).nullable().optional(),
+  labels: z3.array(
+    z3.object({
+      id: z3.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+      idBoard: z3.string(),
+      name: z3.string().nullable().optional(),
+      color: z3.string().nullable().optional()
+    })
+  ).nullable().optional(),
+  pos: z3.number().nullable().optional(),
+  customFields: z3.record(z3.string(), z3.any()).nullable().describe("Custom field values keyed by field name when requested.").optional()
+});
+var definition3 = defineTool3({
+  name: "addCardMember",
+  title: "Add Card Member",
+  description: "Add a member to a card.",
+  inputSchema: inputSchema3,
+  outputSchema: outputSchema3,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/idMembers`;
+    const body = {};
+    if (input.value !== void 0) body["value"] = input.value;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello addCardMember ${res.status}: ${errBody}`);
+    }
+    const cardRes = await ctx.fetch(
+      `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}`
+    );
+    if (!cardRes.ok) {
+      const errBody = await cardRes.text();
+      throw new Error(`Trello addCardMember ${cardRes.status}: ${errBody}`);
+    }
+    return cardRes.json();
+  }
+});
+var addCardMember_default = definition3;
+await handleIfScriptMain3(import.meta, definition3, { connectionResolvers });
+
+// scripts/addChecklistItem.ts
+import { defineTool as defineTool4, handleIfScriptMain as handleIfScriptMain4 } from "@zapier/connectors-sdk";
+import { z as z4 } from "zod";
+var inputSchema4 = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  pos: z4.any().superRefine((x, ctx) => {
+    const schemas = [z4.enum(["top", "bottom"]), z4.number()];
+    const { errors, failed } = schemas.reduce(
+      ({ errors: errors2, failed: failed2 }, schema) => ((result) => result.error ? {
+        errors: [...errors2, ...result.error.issues],
+        failed: failed2 + 1
+      } : { errors: errors2, failed: failed2 })(schema.safeParse(x)),
+      { errors: [], failed: 0 }
+    );
+    const passed = schemas.length - failed;
+    if (passed !== 1) {
+      ctx.addIssue(
+        errors.length ? {
+          path: [],
+          code: "invalid_union",
+          errors: [errors],
+          message: "Invalid input: Should pass single schema. Passed " + passed
+        } : {
+          path: [],
+          code: "custom",
+          errors: [errors],
+          message: "Invalid input: Should pass single schema. Passed " + passed
+        }
+      );
+    }
+  }).optional()
+}).strict();
+var outputSchema4 = z4.object({
+  id: z4.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z4.string(),
+  state: z4.enum(["complete", "incomplete"]),
+  idChecklist: z4.string().nullable().optional()
+});
+var definition4 = defineTool4({
+  name: "addChecklistItem",
+  title: "Add Checklist Item",
+  description: "Add an item to a checklist.",
+  inputSchema: inputSchema4,
+  outputSchema: outputSchema4,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists/${encodeURIComponent(input.id)}/checkItems`;
+    const body = {};
+    if (input.name !== void 0) body["name"] = input.name;
+    if (input.pos !== void 0) body["pos"] = input.pos;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello addChecklistItem ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var addChecklistItem_default = definition4;
+await handleIfScriptMain4(import.meta, definition4, { connectionResolvers });
+
+// scripts/addMemberToBoard.ts
+import { defineTool as defineTool5, handleIfScriptMain as handleIfScriptMain5 } from "@zapier/connectors-sdk";
+import { z as z5 } from "zod";
+var inputSchema5 = z5.object({
+  id: z5.string().describe("24-char hex board id."),
+  email: z5.string().describe("Member email to invite/add."),
+  type: z5.enum(["normal", "admin", "observer"]).describe("Membership type.").optional(),
+  fullName: z5.string().describe("Display name when inviting by email.").optional()
+}).strict();
+var outputSchema5 = z5.object({ status: z5.number() });
+var definition5 = defineTool5({
+  name: "addMemberToBoard",
+  title: "Add Member To Board",
+  description: "Add a member to a board by member id or email.",
+  inputSchema: inputSchema5,
+  outputSchema: outputSchema5,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/memberships`;
+    const body = {};
+    if (input.email !== void 0) body["email"] = input.email;
+    if (input.type !== void 0) body["type"] = input.type;
+    if (input.fullName !== void 0) body["fullName"] = input.fullName;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello addMemberToBoard ${res.status}: ${errBody}`);
+    }
+    return { status: res.status };
+  }
+});
+var addMemberToBoard_default = definition5;
+await handleIfScriptMain5(import.meta, definition5, { connectionResolvers });
+
+// scripts/archiveCard.ts
+import { defineTool as defineTool6, handleIfScriptMain as handleIfScriptMain6 } from "@zapier/connectors-sdk";
+import { z as z6 } from "zod";
+var inputSchema6 = z6.object({
+  id: z6.string().describe("24-char hex card id to archive."),
+  closed: z6.boolean().default(true).describe("Archive when true (default); set false to reopen.")
+}).strict();
+var outputSchema6 = z6.object({
+  id: z6.string().regex(TRELLO_ID_REGEX),
+  name: z6.string(),
+  closed: z6.boolean(),
+  idBoard: z6.string(),
+  idList: z6.string(),
+  url: z6.string(),
+  shortUrl: z6.string().nullable().optional()
+});
+var definition6 = defineTool6({
+  name: "archiveCard",
+  title: "Archive Card",
+  description: "Archive (close) a card by id. Prefer this over updateCard when the job is only archiving. Reopen with closed=false.",
+  inputSchema: inputSchema6,
+  outputSchema: outputSchema6,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/cards/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: trelloFormHeaders,
+      body: trelloFormBody({ closed: input.closed })
+    });
+    if (!res.ok) await trelloError("archiveCard", res);
+    const card = await res.json();
+    if (input.closed && card.closed) {
+      return card;
+    }
+    return card;
+  }
+});
+var archiveCard_default = definition6;
+await handleIfScriptMain6(import.meta, definition6, { connectionResolvers });
+
+// scripts/closeBoard.ts
+import { defineTool as defineTool7, handleIfScriptMain as handleIfScriptMain7 } from "@zapier/connectors-sdk";
+import { z as z7 } from "zod";
+var inputSchema7 = z7.object({
+  id: z7.string().describe("24-char hex board id."),
+  closed: z7.boolean().default(true).describe("Set true to archive the board.")
+}).strict();
+var outputSchema7 = z7.object({
+  id: z7.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z7.string(),
+  desc: z7.string().nullable().optional(),
+  closed: z7.boolean().nullable().optional(),
+  idOrganization: z7.string().nullable().optional(),
+  url: z7.string().nullable().optional(),
+  shortUrl: z7.string().nullable().optional(),
+  dateLastActivity: z7.string().datetime({ offset: true }).nullable().optional()
+});
+var definition7 = defineTool7({
+  name: "closeBoard",
+  title: "Close Board",
+  description: "Archive (close) a board by setting closed to true.",
+  inputSchema: inputSchema7,
+  outputSchema: outputSchema7,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}`;
+    const body = {};
+    if (input.closed !== void 0) body["closed"] = input.closed;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello closeBoard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var closeBoard_default = definition7;
+await handleIfScriptMain7(import.meta, definition7, { connectionResolvers });
+
+// scripts/completeChecklistItem.ts
+import { defineTool as defineTool8, handleIfScriptMain as handleIfScriptMain8 } from "@zapier/connectors-sdk";
+import { z as z8 } from "zod";
+var inputSchema8 = z8.object({
+  id: z8.string().describe("24-char hex card id."),
+  idCheckItem: z8.string(),
+  state: z8.enum(["complete", "incomplete"])
+}).strict();
+var outputSchema8 = z8.object({
+  id: z8.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z8.string(),
+  state: z8.enum(["complete", "incomplete"]),
+  idChecklist: z8.string().nullable().optional()
+});
+var definition8 = defineTool8({
+  name: "completeChecklistItem",
+  title: "Complete Checklist Item",
+  description: "Mark a checklist item complete or incomplete.",
+  inputSchema: inputSchema8,
+  outputSchema: outputSchema8,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/checkItem/${encodeURIComponent(input.idCheckItem)}`;
+    const body = {};
+    if (input.state !== void 0) body["state"] = input.state;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello completeChecklistItem ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var completeChecklistItem_default = definition8;
+await handleIfScriptMain8(import.meta, definition8, { connectionResolvers });
+
+// scripts/copyBoard.ts
+import { defineTool as defineTool9, handleIfScriptMain as handleIfScriptMain9 } from "@zapier/connectors-sdk";
+import { z as z9 } from "zod";
+var inputSchema9 = z9.object({
+  id: z9.string().describe("24-char hex board id."),
+  name: z9.string().describe("Name for the copy.").optional(),
+  idOrganization: z9.string().describe("Destination workspace id.").optional(),
+  keepFromSource: z9.string().describe("Comma-separated props to keep, e.g. cards,labels.").optional(),
+  idBoardSource: z9.string().describe(
+    "Source board id (wire name idBoardSource; same as path id when omitted)."
+  ).optional()
+}).strict();
+var outputSchema9 = z9.object({
+  id: z9.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z9.string(),
+  desc: z9.string().nullable().optional(),
+  closed: z9.boolean().nullable().optional(),
+  idOrganization: z9.string().nullable().optional(),
+  url: z9.string().nullable().optional(),
+  shortUrl: z9.string().nullable().optional(),
+  dateLastActivity: z9.string().datetime({ offset: true }).nullable().optional()
+});
+var definition9 = defineTool9({
+  name: "copyBoard",
+  title: "Copy Board",
+  description: "Copy an existing board, optionally keeping cards and changing the destination workspace.",
+  inputSchema: inputSchema9,
+  outputSchema: outputSchema9,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const fields = {
+      idBoardSource: input.idBoardSource ?? input.id
+    };
+    if (input.name !== void 0) fields.name = input.name;
+    if (input.idOrganization !== void 0) {
+      fields.idOrganization = input.idOrganization;
+    }
+    if (input.keepFromSource !== void 0) {
+      fields.keepFromSource = input.keepFromSource;
+    }
+    const res = await ctx.fetch(`${TRELLO_BASE}/boards`, {
+      method: "POST",
+      headers: trelloFormHeaders,
+      body: trelloFormBody(fields)
+    });
+    if (!res.ok) await trelloError("copyBoard", res);
+    return res.json();
+  }
+});
+var copyBoard_default = definition9;
+await handleIfScriptMain9(import.meta, definition9, { connectionResolvers });
+
+// scripts/createBoard.ts
+import { defineTool as defineTool10, handleIfScriptMain as handleIfScriptMain10 } from "@zapier/connectors-sdk";
+import { z as z10 } from "zod";
+var inputSchema10 = z10.object({
+  name: z10.string().describe("Board name."),
+  desc: z10.string().describe("Board description.").optional(),
+  idOrganization: z10.string().describe("Workspace (organization) id. Resolve via listOrganizations.").optional(),
+  defaultLists: z10.boolean().describe("Create default To Do / Doing / Done lists. Default true.").optional()
+}).strict();
+var outputSchema10 = z10.object({
+  id: z10.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z10.string(),
+  desc: z10.string().nullable().optional(),
+  closed: z10.boolean().nullable().optional(),
+  idOrganization: z10.string().nullable().optional(),
+  url: z10.string().nullable().optional(),
+  shortUrl: z10.string().nullable().optional(),
+  dateLastActivity: z10.string().datetime({ offset: true }).nullable().optional()
+});
+var definition10 = defineTool10({
+  name: "createBoard",
+  title: "Create Board",
+  description: "Create a new Trello board in a workspace.",
+  inputSchema: inputSchema10,
+  outputSchema: outputSchema10,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards`;
+    const body = {};
+    if (input.name !== void 0) body["name"] = input.name;
+    if (input.desc !== void 0) body["desc"] = input.desc;
+    if (input.idOrganization !== void 0)
+      body["idOrganization"] = input.idOrganization;
+    if (input.defaultLists !== void 0)
+      body["defaultLists"] = input.defaultLists;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createBoard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var createBoard_default = definition10;
+await handleIfScriptMain10(import.meta, definition10, { connectionResolvers });
+
+// scripts/createCard.ts
+import { defineTool as defineTool11, handleIfScriptMain as handleIfScriptMain11 } from "@zapier/connectors-sdk";
+import { z as z11 } from "zod";
+var cardOutputSchema = z11.object({
+  id: z11.string().regex(TRELLO_ID_REGEX),
+  idShort: z11.number().int().nullable().optional(),
+  name: z11.string(),
+  desc: z11.string().nullable().optional(),
+  idBoard: z11.string(),
+  idList: z11.string(),
+  shortUrl: z11.string().nullable().optional(),
+  url: z11.string(),
+  due: z11.union([z11.string().datetime({ offset: true }), z11.null()]).optional(),
+  start: z11.union([z11.string().datetime({ offset: true }), z11.null()]).optional(),
+  closed: z11.boolean(),
+  idMembers: z11.array(z11.string()).optional(),
+  idLabels: z11.array(z11.string()).optional(),
+  labels: z11.array(
+    z11.object({
+      id: z11.string(),
+      name: z11.string().nullable().optional(),
+      color: z11.string().nullable().optional()
+    })
+  ).optional(),
+  dateLastActivity: z11.string().datetime({ offset: true }).nullable().optional(),
+  customFields: z11.record(z11.string(), z11.json()).optional()
+});
+var inputSchema11 = z11.object({
+  idList: z11.string().describe("Destination list id. Resolve via listLists or findList."),
+  name: z11.string().describe("Card title."),
+  desc: z11.string().describe("Card description (Trello Markdown).").optional(),
+  pos: z11.union([z11.enum(["top", "bottom"]), z11.number()]).describe("Position in the destination list.").optional(),
+  due: z11.string().datetime({ offset: true }).optional(),
+  start: z11.string().datetime({ offset: true }).optional(),
+  idMembers: z11.array(z11.string()).describe("Member ids to assign. Resolve via listBoardMembers.").optional(),
+  idLabels: z11.array(z11.string()).describe("Label ids to add. Resolve via listLabels or findLabel.").optional(),
+  attachmentUrl: z11.string().url().describe("URL attachment to add after create.").optional(),
+  attachmentFileUrl: z11.string().url().describe("Remote file URL to fetch and upload as attachment.").optional(),
+  checklistName: z11.string().describe("Create a checklist with this name after card create.").optional(),
+  checklistItems: z11.array(z11.string()).describe("Checklist item names for the new checklist.").optional(),
+  customFieldValues: z11.record(z11.string(), z11.json()).describe(
+    "Custom field values keyed by field name. Resolve names via listCustomFields."
+  ).optional(),
+  address: z11.string().optional(),
+  coordinates: z11.string().describe("latitude,longitude").optional(),
+  locationName: z11.string().optional()
+}).strict();
+var definition11 = defineTool11({
+  name: "createCard",
+  title: "Create Card",
+  description: "Create a card on a list with optional members, labels, attachments, checklist, and custom fields. Resolve idList via listLists or findList first.",
+  inputSchema: inputSchema11,
+  outputSchema: cardOutputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const createFields = {
+      name: input.name,
+      idList: input.idList
+    };
+    if (input.desc !== void 0)
+      createFields.desc = input.desc.slice(0, 16383);
+    if (input.pos !== void 0) createFields.pos = input.pos;
+    if (input.due !== void 0) createFields.due = input.due;
+    if (input.start !== void 0) createFields.start = input.start;
+    if (input.address !== void 0) createFields.address = input.address;
+    if (input.coordinates !== void 0)
+      createFields.coordinates = input.coordinates;
+    if (input.locationName !== void 0)
+      createFields.locationName = input.locationName;
+    if (input.idLabels?.length)
+      createFields.idLabels = input.idLabels.join(",");
+    const createRes = await ctx.fetch(`${TRELLO_BASE}/cards`, {
+      method: "POST",
+      headers: trelloFormHeaders,
+      body: trelloFormBody(createFields)
+    });
+    if (!createRes.ok) await trelloError("createCard", createRes);
+    let card = await createRes.json();
+    const cardId = card.id;
+    if (input.idMembers?.length) {
+      for (const memberId of input.idMembers) {
+        const memberRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/idMembers`,
+          {
+            method: "POST",
+            headers: trelloFormHeaders,
+            body: trelloFormBody({ value: memberId })
+          }
+        );
+        if (!memberRes.ok) await trelloError("createCard", memberRes);
+      }
+    }
+    const attachUrl = input.attachmentUrl ?? input.attachmentFileUrl;
+    if (attachUrl) {
+      if (input.attachmentFileUrl) {
+        const fileRes = await ctx.fetch(input.attachmentFileUrl);
+        if (!fileRes.ok) await trelloError("createCard", fileRes);
+        const buffer = await fileRes.arrayBuffer();
+        const form = new FormData();
+        form.append("file", new Blob([buffer]), "attachment");
+        form.append("name", "attachment");
+        const uploadRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/attachments`,
+          { method: "POST", body: form }
+        );
+        if (!uploadRes.ok) await trelloError("createCard", uploadRes);
+      } else {
+        const urlRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/attachments`,
+          {
+            method: "POST",
+            headers: trelloFormHeaders,
+            body: trelloFormBody({ url: attachUrl, name: attachUrl })
+          }
+        );
+        if (!urlRes.ok) await trelloError("createCard", urlRes);
+      }
+    }
+    if (input.checklistName) {
+      const checklistRes = await ctx.fetch(`${TRELLO_BASE}/checklists`, {
+        method: "POST",
+        headers: trelloFormHeaders,
+        body: trelloFormBody({
+          idCard: cardId,
+          name: input.checklistName
+        })
+      });
+      if (!checklistRes.ok) await trelloError("createCard", checklistRes);
+      const checklist = await checklistRes.json();
+      if (input.checklistItems?.length) {
+        for (const itemName of input.checklistItems) {
+          const itemRes = await ctx.fetch(
+            `${TRELLO_BASE}/checklists/${checklist.id}/checkItems`,
+            {
+              method: "POST",
+              headers: trelloFormHeaders,
+              body: trelloFormBody({ name: itemName })
+            }
+          );
+          if (!itemRes.ok) await trelloError("createCard", itemRes);
+        }
+      }
+    }
+    if (input.customFieldValues && Object.keys(input.customFieldValues).length) {
+      const boardId = card.idBoard;
+      const fieldsRes = await ctx.fetch(
+        `${TRELLO_BASE}/boards/${boardId}/customFields`
+      );
+      if (!fieldsRes.ok) await trelloError("createCard", fieldsRes);
+      const fields = await fieldsRes.json();
+      const byName = new Map(fields.map((f) => [f.name, f]));
+      for (const [fieldName, rawValue] of Object.entries(
+        input.customFieldValues
+      )) {
+        const field = byName.get(fieldName);
+        if (!field) {
+          throw new Error(
+            `Trello createCard: unknown custom field "${fieldName}". Resolve via listCustomFields.`
+          );
+        }
+        let itemValue = {};
+        switch (field.type) {
+          case "checkbox":
+            itemValue = { checked: Boolean(rawValue) ? "true" : "false" };
+            break;
+          case "date":
+            itemValue = { date: String(rawValue) };
+            break;
+          case "number":
+            itemValue = { number: String(rawValue) };
+            break;
+          case "list": {
+            itemValue = { idValue: String(rawValue) };
+            break;
+          }
+          default:
+            itemValue = { text: String(rawValue) };
+        }
+        const cfRes = await ctx.fetch(
+          `${TRELLO_BASE}/cards/${cardId}/customField/${field.id}/item`,
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ value: itemValue })
+          }
+        );
+        if (!cfRes.ok) await trelloError("createCard", cfRes);
+      }
+    }
+    const refreshRes = await ctx.fetch(`${TRELLO_BASE}/cards/${cardId}`);
+    if (refreshRes.ok) {
+      card = await refreshRes.json();
+    }
+    return card;
+  }
+});
+var createCard_default = definition11;
+await handleIfScriptMain11(import.meta, definition11, { connectionResolvers });
+
+// scripts/createChecklist.ts
+import { defineTool as defineTool12, handleIfScriptMain as handleIfScriptMain12 } from "@zapier/connectors-sdk";
+import { z as z12 } from "zod";
+var inputSchema12 = z12.object({ idCard: z12.string(), name: z12.string() }).strict();
+var outputSchema11 = z12.object({
+  id: z12.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z12.string(),
+  idCard: z12.string().nullable().optional()
+});
+var definition12 = defineTool12({
+  name: "createChecklist",
+  title: "Create Checklist",
+  description: "Create a checklist on a card.",
+  inputSchema: inputSchema12,
+  outputSchema: outputSchema11,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists`;
+    const body = {};
+    if (input.idCard !== void 0) body["idCard"] = input.idCard;
+    if (input.name !== void 0) body["name"] = input.name;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createChecklist ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var createChecklist_default = definition12;
+await handleIfScriptMain12(import.meta, definition12, { connectionResolvers });
+
+// scripts/createComment.ts
+import { defineTool as defineTool13, handleIfScriptMain as handleIfScriptMain13 } from "@zapier/connectors-sdk";
+import { z as z13 } from "zod";
+var inputSchema13 = z13.object({
+  id: z13.string().describe("24-char hex card id."),
+  text: z13.string().describe(
+    "Comment body (Trello Markdown; @member mentions use @username)."
+  )
+}).strict();
+var outputSchema12 = z13.object({
+  id: z13.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  type: z13.string(),
+  date: z13.string().datetime({ offset: true }),
+  data: z13.object({
+    text: z13.string().nullable().optional(),
+    card: z13.object({
+      id: z13.string().nullable().optional(),
+      name: z13.string().nullable().optional()
+    }).nullable().optional()
+  }).nullable().optional()
+});
+var definition13 = defineTool13({
+  name: "createComment",
+  title: "Create Comment",
+  description: "Add a comment to a card.",
+  inputSchema: inputSchema13,
+  outputSchema: outputSchema12,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/actions/comments`;
+    const body = {};
+    if (input.text !== void 0) body["text"] = input.text;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createComment ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var createComment_default = definition13;
+await handleIfScriptMain13(import.meta, definition13, { connectionResolvers });
+
+// scripts/createLabel.ts
+import { defineTool as defineTool14, handleIfScriptMain as handleIfScriptMain14 } from "@zapier/connectors-sdk";
+import { z as z14 } from "zod";
+var inputSchema14 = z14.object({
+  name: z14.string().optional(),
+  color: z14.enum([
+    "yellow",
+    "purple",
+    "blue",
+    "red",
+    "green",
+    "orange",
+    "black",
+    "sky",
+    "pink",
+    "lime"
+  ]).optional(),
+  idBoard: z14.string()
+}).strict();
+var outputSchema13 = z14.object({
+  id: z14.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  idBoard: z14.string(),
+  name: z14.string().nullable().optional(),
+  color: z14.string().nullable().optional()
+});
+var definition14 = defineTool14({
+  name: "createLabel",
+  title: "Create Label",
+  description: "Create a label on a board (or add a named label to a card when idCard set).",
+  inputSchema: inputSchema14,
+  outputSchema: outputSchema13,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/labels`;
+    const body = {};
+    if (input.name !== void 0) body["name"] = input.name;
+    if (input.color !== void 0) body["color"] = input.color;
+    if (input.idBoard !== void 0) body["idBoard"] = input.idBoard;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createLabel ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var createLabel_default = definition14;
+await handleIfScriptMain14(import.meta, definition14, { connectionResolvers });
+
+// scripts/createList.ts
+import { defineTool as defineTool15, handleIfScriptMain as handleIfScriptMain15 } from "@zapier/connectors-sdk";
+import { z as z15 } from "zod";
+var inputSchema15 = z15.object({
+  name: z15.string(),
+  idBoard: z15.string().describe("Board id."),
+  pos: z15.any().superRefine((x, ctx) => {
+    const schemas = [z15.enum(["top", "bottom"]), z15.number()];
+    const { errors, failed } = schemas.reduce(
+      ({ errors: errors2, failed: failed2 }, schema) => ((result) => result.error ? {
+        errors: [...errors2, ...result.error.issues],
+        failed: failed2 + 1
+      } : { errors: errors2, failed: failed2 })(schema.safeParse(x)),
+      { errors: [], failed: 0 }
+    );
+    const passed = schemas.length - failed;
+    if (passed !== 1) {
+      ctx.addIssue(
+        errors.length ? {
+          path: [],
+          code: "invalid_union",
+          errors: [errors],
+          message: "Invalid input: Should pass single schema. Passed " + passed
+        } : {
+          path: [],
+          code: "custom",
+          errors: [errors],
+          message: "Invalid input: Should pass single schema. Passed " + passed
+        }
+      );
+    }
+  }).optional()
+}).strict();
+var outputSchema14 = z15.object({
+  id: z15.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z15.string(),
+  closed: z15.boolean().nullable().optional(),
+  idBoard: z15.string(),
+  pos: z15.number().nullable().optional()
+});
+var definition15 = defineTool15({
+  name: "createList",
+  title: "Create List",
+  description: "Create a list on a board.",
+  inputSchema: inputSchema15,
+  outputSchema: outputSchema14,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/lists`;
+    const body = {};
+    if (input.name !== void 0) body["name"] = input.name;
+    if (input.idBoard !== void 0) body["idBoard"] = input.idBoard;
+    if (input.pos !== void 0) body["pos"] = input.pos;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello createList ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var createList_default = definition15;
+await handleIfScriptMain15(import.meta, definition15, { connectionResolvers });
+
+// scripts/deleteChecklist.ts
+import { defineTool as defineTool16, handleIfScriptMain as handleIfScriptMain16 } from "@zapier/connectors-sdk";
+import { z as z16 } from "zod";
+var inputSchema16 = z16.object({ id: z16.string() }).strict();
+var outputSchema15 = z16.object({ status: z16.number() });
+var definition16 = defineTool16({
+  name: "deleteChecklist",
+  title: "Delete Checklist",
+  description: "Delete a checklist.",
+  inputSchema: inputSchema16,
+  outputSchema: outputSchema15,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "DELETE"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello deleteChecklist ${res.status}: ${errBody}`);
+    }
+    return { status: res.status };
+  }
+});
+var deleteChecklist_default = definition16;
+await handleIfScriptMain16(import.meta, definition16, { connectionResolvers });
+
+// scripts/findBoard.ts
+import { defineTool as defineTool17, handleIfScriptMain as handleIfScriptMain17 } from "@zapier/connectors-sdk";
+import { z as z17 } from "zod";
+var inputSchema17 = z17.object({ query: z17.string(), organizationId: z17.string().optional() }).strict();
+var itemSchema = z17.array(
+  z17.object({
+    id: z17.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z17.string(),
+    desc: z17.string().nullable().optional(),
+    closed: z17.boolean().nullable().optional(),
+    idOrganization: z17.string().nullable().optional(),
+    url: z17.string().nullable().optional(),
+    shortUrl: z17.string().nullable().optional(),
+    dateLastActivity: z17.string().datetime({ offset: true }).nullable().optional()
+  })
+);
+var outputSchema16 = z17.object({ items: itemSchema });
+var definition17 = defineTool17({
+  name: "findBoard",
+  title: "Find Board",
+  description: "Find boards by name via GET /search with modelTypes=boards.",
+  inputSchema: inputSchema17,
+  outputSchema: outputSchema16,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(`${TRELLO_BASE}/search`);
+    url.searchParams.set("query", input.query);
+    url.searchParams.set("modelTypes", "boards");
+    url.searchParams.set("boardsLimit", "50");
+    if (input.organizationId !== void 0) {
+      url.searchParams.set("idOrganizations", input.organizationId);
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    if (!res.ok) await trelloError("findBoard", res);
+    const data = await res.json();
+    return { items: data.boards ?? [] };
+  }
+});
+var findBoard_default = definition17;
+await handleIfScriptMain17(import.meta, definition17, { connectionResolvers });
+
+// scripts/findChecklist.ts
+import { defineTool as defineTool18, handleIfScriptMain as handleIfScriptMain18 } from "@zapier/connectors-sdk";
+import { z as z18 } from "zod";
+var inputSchema18 = z18.object({ id: z18.string().describe("24-char hex card id."), name: z18.string() }).strict();
+var itemSchema2 = z18.array(
+  z18.object({
+    id: z18.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z18.string(),
+    idCard: z18.string().nullable().optional()
+  })
+);
+var outputSchema17 = z18.object({ items: itemSchema2 });
+var definition18 = defineTool18({
+  name: "findChecklist",
+  title: "Find Checklist",
+  description: "Find checklists on a card whose name contains the search string.",
+  inputSchema: inputSchema18,
+  outputSchema: outputSchema17,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/cards/${encodeURIComponent(input.id)}/checklists`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findChecklist", res);
+    const checklists = await res.json();
+    const items = (Array.isArray(checklists) ? checklists : []).filter(
+      (cl) => nameContains(cl.name ?? "", input.name)
+    );
+    return { items };
+  }
+});
+var findChecklist_default = definition18;
+await handleIfScriptMain18(import.meta, definition18, { connectionResolvers });
+
+// scripts/findChecklistItem.ts
+import { defineTool as defineTool19, handleIfScriptMain as handleIfScriptMain19 } from "@zapier/connectors-sdk";
+import { z as z19 } from "zod";
+var inputSchema19 = z19.object({ id: z19.string(), name: z19.string() }).strict();
+var itemSchema3 = z19.array(
+  z19.object({
+    id: z19.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z19.string(),
+    state: z19.enum(["complete", "incomplete"]),
+    idChecklist: z19.string().nullable().optional()
+  })
+);
+var outputSchema18 = z19.object({ items: itemSchema3 });
+var definition19 = defineTool19({
+  name: "findChecklistItem",
+  title: "Find Checklist Item",
+  description: "Find checklist items whose name contains the search string.",
+  inputSchema: inputSchema19,
+  outputSchema: outputSchema18,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/checklists/${encodeURIComponent(input.id)}/checkItems`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findChecklistItem", res);
+    const checkItems = await res.json();
+    const items = (Array.isArray(checkItems) ? checkItems : []).filter(
+      (item) => nameContains(item.name ?? "", input.name)
+    );
+    return { items };
+  }
+});
+var findChecklistItem_default = definition19;
+await handleIfScriptMain19(import.meta, definition19, { connectionResolvers });
+
+// scripts/findLabel.ts
+import { defineTool as defineTool20, handleIfScriptMain as handleIfScriptMain20 } from "@zapier/connectors-sdk";
+import { z as z20 } from "zod";
+var inputSchema20 = z20.object({
+  id: z20.string().describe("24-char hex board id."),
+  name: z20.string()
+}).strict();
+var itemSchema4 = z20.array(
+  z20.object({
+    id: z20.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    idBoard: z20.string(),
+    name: z20.string().nullable().optional(),
+    color: z20.string().nullable().optional()
+  })
+);
+var outputSchema19 = z20.object({ items: itemSchema4 });
+var definition20 = defineTool20({
+  name: "findLabel",
+  title: "Find Label",
+  description: "Find labels on a board whose name contains the search string.",
+  inputSchema: inputSchema20,
+  outputSchema: outputSchema19,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/boards/${encodeURIComponent(input.id)}/labels`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findLabel", res);
+    const labels = await res.json();
+    const items = (Array.isArray(labels) ? labels : []).filter(
+      (label) => nameContains(label.name ?? "", input.name)
+    );
+    return { items };
+  }
+});
+var findLabel_default = definition20;
+await handleIfScriptMain20(import.meta, definition20, { connectionResolvers });
+
+// scripts/findList.ts
+import { defineTool as defineTool21, handleIfScriptMain as handleIfScriptMain21 } from "@zapier/connectors-sdk";
+import { z as z21 } from "zod";
+var inputSchema21 = z21.object({
+  id: z21.string().describe("24-char hex board id."),
+  name: z21.string()
+}).strict();
+var itemSchema5 = z21.array(
+  z21.object({
+    id: z21.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z21.string(),
+    closed: z21.boolean().nullable().optional(),
+    idBoard: z21.string(),
+    pos: z21.number().nullable().optional()
+  })
+);
+var outputSchema20 = z21.object({ items: itemSchema5 });
+var definition21 = defineTool21({
+  name: "findList",
+  title: "Find List",
+  description: "Find lists on a board whose name contains the search string.",
+  inputSchema: inputSchema21,
+  outputSchema: outputSchema20,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/boards/${encodeURIComponent(input.id)}/lists`;
+    const res = await ctx.fetch(url, { method: "GET" });
+    if (!res.ok) await trelloError("findList", res);
+    const lists = await res.json();
+    const items = (Array.isArray(lists) ? lists : []).filter(
+      (list) => nameContains(list.name ?? "", input.name)
+    );
+    return { items };
+  }
+});
+var findList_default = definition21;
+await handleIfScriptMain21(import.meta, definition21, { connectionResolvers });
+
+// scripts/findOrganizationMember.ts
+import { defineTool as defineTool22, handleIfScriptMain as handleIfScriptMain22 } from "@zapier/connectors-sdk";
+import { z as z22 } from "zod";
+var inputSchema22 = z22.object({ query: z22.string(), organizationId: z22.string().optional() }).strict();
+var itemSchema6 = z22.array(
+  z22.object({
+    id: z22.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    username: z22.string(),
+    fullName: z22.string().nullable().optional(),
+    initials: z22.string().nullable().optional(),
+    avatarUrl: z22.string().nullable().optional(),
+    email: z22.string().nullable().describe("Present only when token has account read scope.").optional()
+  })
+);
+var outputSchema21 = z22.object({ items: itemSchema6 });
+var definition22 = defineTool22({
+  name: "findOrganizationMember",
+  title: "Find Organization Member",
+  description: "Find members via GET /search/members/.",
+  inputSchema: inputSchema22,
+  outputSchema: outputSchema21,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(`${TRELLO_BASE}/search/members/`);
+    url.searchParams.set("query", input.query);
+    url.searchParams.set("limit", "20");
+    if (input.organizationId !== void 0) {
+      url.searchParams.set("idOrganization", input.organizationId);
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    if (!res.ok) await trelloError("findOrganizationMember", res);
+    const data = await res.json();
+    return { items: Array.isArray(data) ? data : [] };
+  }
+});
+var findOrganizationMember_default = definition22;
+await handleIfScriptMain22(import.meta, definition22, { connectionResolvers });
+
+// scripts/getAction.ts
+import { defineTool as defineTool23, handleIfScriptMain as handleIfScriptMain23 } from "@zapier/connectors-sdk";
+import { z as z23 } from "zod";
+var inputSchema23 = z23.object({ id: z23.string() }).strict();
+var outputSchema22 = z23.object({
+  id: z23.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  type: z23.string(),
+  date: z23.string().datetime({ offset: true }),
+  data: z23.object({
+    text: z23.string().nullable().optional(),
+    card: z23.object({
+      id: z23.string().nullable().optional(),
+      name: z23.string().nullable().optional()
+    }).nullable().optional()
+  }).nullable().optional()
+});
+var definition23 = defineTool23({
+  name: "getAction",
+  title: "Get Action",
+  description: "Get an action (activity) by id, including comments.",
+  inputSchema: inputSchema23,
+  outputSchema: outputSchema22,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/actions/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getAction ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getAction_default = definition23;
+await handleIfScriptMain23(import.meta, definition23, { connectionResolvers });
+
+// scripts/getBoard.ts
+import { defineTool as defineTool24, handleIfScriptMain as handleIfScriptMain24 } from "@zapier/connectors-sdk";
+import { z as z24 } from "zod";
+var inputSchema24 = z24.object({ id: z24.string().describe("24-char hex board id.") }).strict();
+var outputSchema23 = z24.object({
+  id: z24.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z24.string(),
+  desc: z24.string().nullable().optional(),
+  closed: z24.boolean().nullable().optional(),
+  idOrganization: z24.string().nullable().optional(),
+  url: z24.string().nullable().optional(),
+  shortUrl: z24.string().nullable().optional(),
+  dateLastActivity: z24.string().datetime({ offset: true }).nullable().optional()
+});
+var definition24 = defineTool24({
+  name: "getBoard",
+  title: "Get Board",
+  description: "Get a board by id.",
+  inputSchema: inputSchema24,
+  outputSchema: outputSchema23,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getBoard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getBoard_default = definition24;
+await handleIfScriptMain24(import.meta, definition24, { connectionResolvers });
+
+// scripts/getCard.ts
+import { defineTool as defineTool25, handleIfScriptMain as handleIfScriptMain25 } from "@zapier/connectors-sdk";
+import { z as z25 } from "zod";
+var inputSchema25 = z25.object({ id: z25.string().describe("24-char hex card id.") }).strict();
+var outputSchema24 = z25.object({
+  id: z25.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z25.string(),
+  desc: z25.string().nullable().optional(),
+  closed: z25.boolean().nullable().optional(),
+  idBoard: z25.string(),
+  idList: z25.string(),
+  idShort: z25.number().int().nullable().optional(),
+  shortLink: z25.string().nullable().optional(),
+  shortUrl: z25.string().nullable().optional(),
+  url: z25.string().nullable().optional(),
+  due: z25.union([z25.string().datetime({ offset: true }), z25.null()]).optional(),
+  dueComplete: z25.boolean().nullable().optional(),
+  dateLastActivity: z25.string().datetime({ offset: true }).nullable().optional(),
+  idLabels: z25.array(z25.string()).nullable().optional(),
+  idMembers: z25.array(z25.string()).nullable().optional(),
+  labels: z25.array(
+    z25.object({
+      id: z25.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+      idBoard: z25.string(),
+      name: z25.string().nullable().optional(),
+      color: z25.string().nullable().optional()
+    })
+  ).nullable().optional(),
+  pos: z25.number().nullable().optional(),
+  customFields: z25.record(z25.string(), z25.any()).nullable().describe("Custom field values keyed by field name when requested.").optional()
+});
+var definition25 = defineTool25({
+  name: "getCard",
+  title: "Get Card",
+  description: "Get a card by id.",
+  inputSchema: inputSchema25,
+  outputSchema: outputSchema24,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getCard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getCard_default = definition25;
+await handleIfScriptMain25(import.meta, definition25, { connectionResolvers });
+
+// scripts/getChecklist.ts
+import { defineTool as defineTool26, handleIfScriptMain as handleIfScriptMain26 } from "@zapier/connectors-sdk";
+import { z as z26 } from "zod";
+var inputSchema26 = z26.object({ id: z26.string() }).strict();
+var outputSchema25 = z26.object({
+  id: z26.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z26.string(),
+  idCard: z26.string().nullable().optional()
+});
+var definition26 = defineTool26({
+  name: "getChecklist",
+  title: "Get Checklist",
+  description: "Get a checklist by id.",
+  inputSchema: inputSchema26,
+  outputSchema: outputSchema25,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getChecklist ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getChecklist_default = definition26;
+await handleIfScriptMain26(import.meta, definition26, { connectionResolvers });
+
+// scripts/getChecklistItem.ts
+import { defineTool as defineTool27, handleIfScriptMain as handleIfScriptMain27 } from "@zapier/connectors-sdk";
+import { z as z27 } from "zod";
+var inputSchema27 = z27.object({ id: z27.string(), idCheckItem: z27.string() }).strict();
+var outputSchema26 = z27.object({
+  id: z27.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z27.string(),
+  state: z27.enum(["complete", "incomplete"]),
+  idChecklist: z27.string().nullable().optional()
+});
+var definition27 = defineTool27({
+  name: "getChecklistItem",
+  title: "Get Checklist Item",
+  description: "Get a checklist item by id.",
+  inputSchema: inputSchema27,
+  outputSchema: outputSchema26,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/checklists/${encodeURIComponent(input.id)}/checkItems/${encodeURIComponent(input.idCheckItem)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getChecklistItem ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getChecklistItem_default = definition27;
+await handleIfScriptMain27(import.meta, definition27, { connectionResolvers });
+
+// scripts/getCurrentMember.ts
+import { defineTool as defineTool28, handleIfScriptMain as handleIfScriptMain28 } from "@zapier/connectors-sdk";
+import { z as z28 } from "zod";
+var inputSchema28 = z28.object({}).strict();
+var outputSchema27 = z28.object({
+  id: z28.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  username: z28.string(),
+  fullName: z28.string().nullable().optional(),
+  initials: z28.string().nullable().optional(),
+  avatarUrl: z28.string().nullable().optional(),
+  email: z28.string().nullable().describe("Present only when token has account read scope.").optional()
+});
+var definition28 = defineTool28({
+  name: "getCurrentMember",
+  title: "Get Current Member",
+  description: "Get the authenticated member (identity resolver).",
+  inputSchema: inputSchema28,
+  outputSchema: outputSchema27,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (_input, ctx) => {
+    const url = `https://api.trello.com/1/members/me`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getCurrentMember ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getCurrentMember_default = definition28;
+await handleIfScriptMain28(import.meta, definition28, { connectionResolvers });
+
+// scripts/getLabel.ts
+import { defineTool as defineTool29, handleIfScriptMain as handleIfScriptMain29 } from "@zapier/connectors-sdk";
+import { z as z29 } from "zod";
+var inputSchema29 = z29.object({ id: z29.string() }).strict();
+var outputSchema28 = z29.object({
+  id: z29.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  idBoard: z29.string(),
+  name: z29.string().nullable().optional(),
+  color: z29.string().nullable().optional()
+});
+var definition29 = defineTool29({
+  name: "getLabel",
+  title: "Get Label",
+  description: "Get a label by id.",
+  inputSchema: inputSchema29,
+  outputSchema: outputSchema28,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/labels/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getLabel ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getLabel_default = definition29;
+await handleIfScriptMain29(import.meta, definition29, { connectionResolvers });
+
+// scripts/getList.ts
+import { defineTool as defineTool30, handleIfScriptMain as handleIfScriptMain30 } from "@zapier/connectors-sdk";
+import { z as z30 } from "zod";
+var inputSchema30 = z30.object({ id: z30.string() }).strict();
+var outputSchema29 = z30.object({
+  id: z30.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z30.string(),
+  closed: z30.boolean().nullable().optional(),
+  idBoard: z30.string(),
+  pos: z30.number().nullable().optional()
+});
+var definition30 = defineTool30({
+  name: "getList",
+  title: "Get List",
+  description: "Get a list by id.",
+  inputSchema: inputSchema30,
+  outputSchema: outputSchema29,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/lists/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getList ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getList_default = definition30;
+await handleIfScriptMain30(import.meta, definition30, { connectionResolvers });
+
+// scripts/getMember.ts
+import { defineTool as defineTool31, handleIfScriptMain as handleIfScriptMain31 } from "@zapier/connectors-sdk";
+import { z as z31 } from "zod";
+var inputSchema31 = z31.object({ id: z31.string() }).strict();
+var outputSchema30 = z31.object({
+  id: z31.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  username: z31.string(),
+  fullName: z31.string().nullable().optional(),
+  initials: z31.string().nullable().optional(),
+  avatarUrl: z31.string().nullable().optional(),
+  email: z31.string().nullable().describe("Present only when token has account read scope.").optional()
+});
+var definition31 = defineTool31({
+  name: "getMember",
+  title: "Get Member",
+  description: "Get a member by id.",
+  inputSchema: inputSchema31,
+  outputSchema: outputSchema30,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/members/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getMember ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getMember_default = definition31;
+await handleIfScriptMain31(import.meta, definition31, { connectionResolvers });
+
+// scripts/getOrganization.ts
+import { defineTool as defineTool32, handleIfScriptMain as handleIfScriptMain32 } from "@zapier/connectors-sdk";
+import { z as z32 } from "zod";
+var inputSchema32 = z32.object({ id: z32.string() }).strict();
+var outputSchema31 = z32.object({
+  id: z32.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z32.string(),
+  displayName: z32.string(),
+  url: z32.string().nullable().optional()
+});
+var definition32 = defineTool32({
+  name: "getOrganization",
+  title: "Get Organization",
+  description: "Get a workspace (organization) by id.",
+  inputSchema: inputSchema32,
+  outputSchema: outputSchema31,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/organizations/${encodeURIComponent(input.id)}`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello getOrganization ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var getOrganization_default = definition32;
+await handleIfScriptMain32(import.meta, definition32, { connectionResolvers });
+
+// scripts/listBoardMembers.ts
+import { defineTool as defineTool33, handleIfScriptMain as handleIfScriptMain33 } from "@zapier/connectors-sdk";
+import { z as z33 } from "zod";
+var inputSchema33 = z33.object({ id: z33.string().describe("24-char hex board id.") }).strict();
+var itemSchema7 = z33.array(
+  z33.object({
+    id: z33.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    username: z33.string(),
+    fullName: z33.string().nullable().optional(),
+    initials: z33.string().nullable().optional(),
+    avatarUrl: z33.string().nullable().optional(),
+    email: z33.string().nullable().describe("Present only when token has account read scope.").optional()
+  })
+);
+var outputSchema32 = z33.object({ items: itemSchema7 });
+var definition33 = defineTool33({
+  name: "listBoardMembers",
+  title: "List Board Members",
+  description: "List members of a board.",
+  inputSchema: inputSchema33,
+  outputSchema: outputSchema32,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/members`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listBoardMembers ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  }
+});
+var listBoardMembers_default = definition33;
+await handleIfScriptMain33(import.meta, definition33, { connectionResolvers });
+
+// scripts/listBoards.ts
+import { defineTool as defineTool34, handleIfScriptMain as handleIfScriptMain34 } from "@zapier/connectors-sdk";
+import { z as z34 } from "zod";
+var inputSchema34 = z34.object({
+  filter: z34.enum([
+    "all",
+    "closed",
+    "members",
+    "none",
+    "open",
+    "organization",
+    "pinned",
+    "public",
+    "starred",
+    "unpinned"
+  ]).default("all")
+}).strict();
+var itemSchema8 = z34.array(
+  z34.object({
+    id: z34.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z34.string(),
+    desc: z34.string().nullable().optional(),
+    closed: z34.boolean().nullable().optional(),
+    idOrganization: z34.string().nullable().optional(),
+    url: z34.string().nullable().optional(),
+    shortUrl: z34.string().nullable().optional(),
+    dateLastActivity: z34.string().datetime({ offset: true }).nullable().optional()
+  })
+);
+var outputSchema33 = z34.object({ items: itemSchema8 });
+var definition34 = defineTool34({
+  name: "listBoards",
+  title: "List Boards",
+  description: "List boards the authenticated member can access.",
+  inputSchema: inputSchema34,
+  outputSchema: outputSchema33,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(`https://api.trello.com/1/members/me/boards`);
+    if (input.filter !== void 0) {
+      url.searchParams.set("filter", String(input.filter));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listBoards ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  }
+});
+var listBoards_default = definition34;
+await handleIfScriptMain34(import.meta, definition34, { connectionResolvers });
+
+// scripts/listCardAttachments.ts
+import { defineTool as defineTool35, handleIfScriptMain as handleIfScriptMain35 } from "@zapier/connectors-sdk";
+import { z as z35 } from "zod";
+var inputSchema35 = z35.object({ id: z35.string().describe("24-char hex card id.") }).strict();
+var itemSchema9 = z35.array(
+  z35.object({
+    id: z35.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z35.string(),
+    url: z35.string().nullable().optional(),
+    mimeType: z35.string().nullable().optional(),
+    bytes: z35.union([z35.number().int(), z35.null()]).optional(),
+    isUpload: z35.boolean().nullable().optional()
+  })
+);
+var outputSchema34 = z35.object({ items: itemSchema9 });
+var definition35 = defineTool35({
+  name: "listCardAttachments",
+  title: "List Card Attachments",
+  description: "List attachments on a card (metadata only; use download URLs from response).",
+  inputSchema: inputSchema35,
+  outputSchema: outputSchema34,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/attachments`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listCardAttachments ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  }
+});
+var listCardAttachments_default = definition35;
+await handleIfScriptMain35(import.meta, definition35, { connectionResolvers });
+
+// scripts/listCards.ts
+import { defineTool as defineTool36, handleIfScriptMain as handleIfScriptMain36 } from "@zapier/connectors-sdk";
+import { z as z36 } from "zod";
+var inputSchema36 = z36.object({
+  id: z36.string().describe("24-char hex board id."),
+  filter: z36.enum(["all", "closed", "none", "open", "visible"]).default("open"),
+  before: z36.string().describe("Return cards older than this card id (cursor for next page).").optional(),
+  limit: z36.number().int().gte(1).lte(1e3).describe(
+    "Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional()
+}).strict();
+var outputSchema35 = z36.object({
+  items: z36.array(
+    z36.object({
+      id: z36.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+      name: z36.string(),
+      desc: z36.string().nullable().optional(),
+      closed: z36.boolean().nullable().optional(),
+      idBoard: z36.string(),
+      idList: z36.string(),
+      idShort: z36.number().int().nullable().optional(),
+      shortLink: z36.string().nullable().optional(),
+      shortUrl: z36.string().nullable().optional(),
+      url: z36.string().nullable().optional(),
+      due: z36.union([z36.string().datetime({ offset: true }), z36.null()]).optional(),
+      dueComplete: z36.boolean().nullable().optional(),
+      dateLastActivity: z36.string().datetime({ offset: true }).nullable().optional(),
+      idLabels: z36.any().nullable().describe("Nested object \u2014 shape passes through.").optional(),
+      idMembers: z36.any().nullable().describe("Nested object \u2014 shape passes through.").optional(),
+      labels: z36.any().nullable().describe("Nested object \u2014 shape passes through.").optional(),
+      pos: z36.number().nullable().optional(),
+      customFields: z36.any().nullable().describe("Nested object \u2014 shape passes through.").optional()
+    })
+  ).nullable().optional(),
+  has_more: z36.boolean().nullable().describe(
+    "True when the page is full and before-cursor paging may return more."
+  ).optional()
+});
+var definition36 = defineTool36({
+  name: "listCards",
+  title: "List Cards",
+  description: "List cards on a board with optional filter and before-cursor pagination.",
+  inputSchema: inputSchema36,
+  outputSchema: outputSchema35,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/cards`
+    );
+    if (input.filter !== void 0) {
+      url.searchParams.set("filter", String(input.filter));
+    }
+    if (input.before !== void 0) {
+      url.searchParams.set("before", String(input.before));
+    }
+    url.searchParams.set("limit", String(input.limit ?? 20));
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listCards ${res.status}: ${errBody}`);
+    }
+    const limit = input.limit ?? 20;
+    const cards = await res.json();
+    const items = Array.isArray(cards) ? cards : [];
+    return { items, has_more: items.length >= limit };
+  }
+});
+var listCards_default = definition36;
+await handleIfScriptMain36(import.meta, definition36, { connectionResolvers });
+
+// scripts/listCustomFields.ts
+import { defineTool as defineTool37, handleIfScriptMain as handleIfScriptMain37 } from "@zapier/connectors-sdk";
+import { z as z37 } from "zod";
+var inputSchema37 = z37.object({ id: z37.string().describe("24-char hex board id.") }).strict();
+var itemSchema10 = z37.array(
+  z37.object({
+    id: z37.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z37.string(),
+    type: z37.enum(["checkbox", "date", "list", "number", "text"]),
+    options: z37.array(
+      z37.object({
+        id: z37.string(),
+        value: z37.object({ text: z37.string().optional() }).optional(),
+        color: z37.string().optional()
+      })
+    ).nullable().optional()
+  })
+);
+var outputSchema36 = z37.object({ items: itemSchema10 });
+var definition37 = defineTool37({
+  name: "listCustomFields",
+  title: "List Custom Fields",
+  description: "List custom field definitions on a board. Use before setting custom field values on cards.",
+  inputSchema: inputSchema37,
+  outputSchema: outputSchema36,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/customFields`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listCustomFields ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  }
+});
+var listCustomFields_default = definition37;
+await handleIfScriptMain37(import.meta, definition37, { connectionResolvers });
+
+// scripts/listLabels.ts
+import { defineTool as defineTool38, handleIfScriptMain as handleIfScriptMain38 } from "@zapier/connectors-sdk";
+import { z as z38 } from "zod";
+var inputSchema38 = z38.object({ id: z38.string().describe("24-char hex board id.") }).strict();
+var itemSchema11 = z38.array(
+  z38.object({
+    id: z38.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    idBoard: z38.string(),
+    name: z38.string().nullable().optional(),
+    color: z38.string().nullable().optional()
+  })
+);
+var outputSchema37 = z38.object({ items: itemSchema11 });
+var definition38 = defineTool38({
+  name: "listLabels",
+  title: "List Labels",
+  description: "List labels defined on a board.",
+  inputSchema: inputSchema38,
+  outputSchema: outputSchema37,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/labels`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listLabels ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  }
+});
+var listLabels_default = definition38;
+await handleIfScriptMain38(import.meta, definition38, { connectionResolvers });
+
+// scripts/listLists.ts
+import { defineTool as defineTool39, handleIfScriptMain as handleIfScriptMain39 } from "@zapier/connectors-sdk";
+import { z as z39 } from "zod";
+var inputSchema39 = z39.object({
+  id: z39.string().describe("24-char hex board id."),
+  filter: z39.enum(["all", "closed", "none", "open"]).default("open")
+}).strict();
+var itemSchema12 = z39.array(
+  z39.object({
+    id: z39.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z39.string(),
+    closed: z39.boolean().nullable().optional(),
+    idBoard: z39.string(),
+    pos: z39.number().nullable().optional()
+  })
+);
+var outputSchema38 = z39.object({ items: itemSchema12 });
+var definition39 = defineTool39({
+  name: "listLists",
+  title: "List Lists",
+  description: "List all lists on a board. Use findList to match by name.",
+  inputSchema: inputSchema39,
+  outputSchema: outputSchema38,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://api.trello.com/1/boards/${encodeURIComponent(input.id)}/lists`
+    );
+    if (input.filter !== void 0) {
+      url.searchParams.set("filter", String(input.filter));
+    }
+    const res = await ctx.fetch(url.toString(), {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listLists ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  }
+});
+var listLists_default = definition39;
+await handleIfScriptMain39(import.meta, definition39, { connectionResolvers });
+
+// scripts/listOrganizations.ts
+import { defineTool as defineTool40, handleIfScriptMain as handleIfScriptMain40 } from "@zapier/connectors-sdk";
+import { z as z40 } from "zod";
+var inputSchema40 = z40.object({}).strict();
+var itemSchema13 = z40.array(
+  z40.object({
+    id: z40.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+    name: z40.string(),
+    displayName: z40.string(),
+    url: z40.string().nullable().optional()
+  })
+);
+var outputSchema39 = z40.object({ items: itemSchema13 });
+var definition40 = defineTool40({
+  name: "listOrganizations",
+  title: "List Organizations",
+  description: "List workspaces the authenticated member belongs to.",
+  inputSchema: inputSchema40,
+  outputSchema: outputSchema39,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (_input, ctx) => {
+    const url = `https://api.trello.com/1/members/me/organizations`;
+    const res = await ctx.fetch(url, {
+      method: "GET"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello listOrganizations ${res.status}: ${errBody}`);
+    }
+    const data = await res.json();
+    return { items: data };
+  }
+});
+var listOrganizations_default = definition40;
+await handleIfScriptMain40(import.meta, definition40, { connectionResolvers });
+
+// scripts/moveCard.ts
+import { defineTool as defineTool41, handleIfScriptMain as handleIfScriptMain41 } from "@zapier/connectors-sdk";
+import { z as z41 } from "zod";
+var inputSchema41 = z41.object({
+  id: z41.string().describe("24-char hex card id to move."),
+  idList: z41.string().describe("Destination list id. Resolve via listLists or findList."),
+  idBoard: z41.string().describe("Destination board id when moving across boards.").optional()
+}).strict();
+var outputSchema40 = z41.object({
+  id: z41.string().regex(TRELLO_ID_REGEX),
+  name: z41.string(),
+  closed: z41.boolean().nullable().optional(),
+  idBoard: z41.string(),
+  idList: z41.string(),
+  url: z41.string(),
+  shortUrl: z41.string().nullable().optional()
+});
+var definition41 = defineTool41({
+  name: "moveCard",
+  title: "Move Card",
+  description: "Move a card to another list (and optionally another board). Resolve list ids via listLists or findList before calling.",
+  inputSchema: inputSchema41,
+  outputSchema: outputSchema40,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `${TRELLO_BASE}/cards/${encodeURIComponent(input.id)}`;
+    const body = { idList: input.idList };
+    if (input.idBoard !== void 0) body.idBoard = input.idBoard;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: trelloFormHeaders,
+      body: trelloFormBody(body)
+    });
+    if (!res.ok) await trelloError("moveCard", res);
+    return res.json();
+  }
+});
+var moveCard_default = definition41;
+await handleIfScriptMain41(import.meta, definition41, { connectionResolvers });
+
+// scripts/removeCardLabel.ts
+import { defineTool as defineTool42, handleIfScriptMain as handleIfScriptMain42 } from "@zapier/connectors-sdk";
+import { z as z42 } from "zod";
+var inputSchema42 = z42.object({
+  id: z42.string().describe("24-char hex card id."),
+  idLabel: z42.string()
+}).strict();
+var outputSchema41 = z42.object({ status: z42.number() });
+var definition42 = defineTool42({
+  name: "removeCardLabel",
+  title: "Remove Card Label",
+  description: "Remove a label from a card.",
+  inputSchema: inputSchema42,
+  outputSchema: outputSchema41,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}/idLabels/${encodeURIComponent(input.idLabel)}`;
+    const res = await ctx.fetch(url, {
+      method: "DELETE"
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello removeCardLabel ${res.status}: ${errBody}`);
+    }
+    return { status: res.status };
+  }
+});
+var removeCardLabel_default = definition42;
+await handleIfScriptMain42(import.meta, definition42, { connectionResolvers });
+
+// scripts/searchCards.ts
+import { defineTool as defineTool43, handleIfScriptMain as handleIfScriptMain43 } from "@zapier/connectors-sdk";
+import { z as z43 } from "zod";
+function buildSearchQuery(input) {
+  if (input.query !== void 0) return input.query;
+  const parts = [];
+  if (input.keyword !== void 0) parts.push(input.keyword);
+  if (input.listName !== void 0) parts.push(`list:${input.listName}`);
+  if (input.member !== void 0) {
+    parts.push(
+      input.member.startsWith("@") ? input.member : `@${input.member}`
+    );
+  }
+  if (input.label !== void 0) parts.push(`label:${input.label}`);
+  if (input.dueFilter !== void 0) parts.push(`due:${input.dueFilter}`);
+  if (parts.length === 0) {
+    throw new Error("Trello searchCards: provide query or keyword.");
+  }
+  return parts.join(" ");
+}
+var inputSchema43 = z43.object({
+  query: z43.string().describe(
+    "Raw Trello query string (e.g. board:MyBoard @me due:week). Mutually exclusive with keyword-based structured search."
+  ).optional(),
+  keyword: z43.string().describe("Search card name/description when not using raw query.").optional(),
+  boardId: z43.string().describe("Limit to this board id.").optional(),
+  listName: z43.string().optional(),
+  member: z43.string().describe("Member filter; use @me for current user.").optional(),
+  label: z43.string().optional(),
+  dueFilter: z43.enum(["day", "week", "month", "overdue", "complete", "incomplete"]).optional(),
+  organizationId: z43.string().optional(),
+  cardsLimit: z43.number().int().gte(1).lte(1e3).describe(
+    "Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  partial: z43.boolean().default(true)
+}).strict();
+var outputSchema42 = z43.object({
+  items: z43.array(
+    z43.object({
+      id: z43.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+      name: z43.string(),
+      desc: z43.string().nullable().optional(),
+      closed: z43.boolean().nullable().optional(),
+      idBoard: z43.string(),
+      idList: z43.string(),
+      idShort: z43.number().int().nullable().optional(),
+      shortLink: z43.string().nullable().optional(),
+      shortUrl: z43.string().nullable().optional(),
+      url: z43.string().nullable().optional(),
+      due: z43.union([z43.string().datetime({ offset: true }), z43.null()]).optional(),
+      dueComplete: z43.boolean().nullable().optional(),
+      dateLastActivity: z43.string().datetime({ offset: true }).nullable().optional(),
+      idLabels: z43.array(z43.string()).nullable().optional(),
+      idMembers: z43.array(z43.string()).nullable().optional(),
+      labels: z43.array(
+        z43.object({
+          id: z43.string(),
+          name: z43.string().nullable().optional(),
+          color: z43.string().nullable().optional()
+        })
+      ).nullable().optional(),
+      pos: z43.number().nullable().optional(),
+      customFields: z43.record(z43.string(), z43.json()).nullable().optional()
+    })
+  ).nullable().optional(),
+  has_more: z43.boolean().nullable().optional()
+});
+var definition43 = defineTool43({
+  name: "searchCards",
+  title: "Search Cards",
+  description: "Search for cards using Trello query DSL or structured filters.",
+  inputSchema: inputSchema43,
+  outputSchema: outputSchema42,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = new URL(`${TRELLO_BASE}/search`);
+    url.searchParams.set("query", buildSearchQuery(input));
+    url.searchParams.set("modelTypes", "cards");
+    if (input.boardId !== void 0) {
+      url.searchParams.set("idBoards", input.boardId);
+    }
+    if (input.organizationId !== void 0) {
+      url.searchParams.set("idOrganizations", input.organizationId);
+    }
+    const limit = input.cardsLimit ?? 20;
+    url.searchParams.set("cards_limit", String(limit));
+    if (input.partial !== void 0) {
+      url.searchParams.set("partial", String(input.partial));
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    if (!res.ok) await trelloError("searchCards", res);
+    const data = await res.json();
+    const items = Array.isArray(data.cards) ? data.cards : [];
+    return { items, has_more: items.length >= limit };
+  }
+});
+var searchCards_default = definition43;
+await handleIfScriptMain43(import.meta, definition43, { connectionResolvers });
+
+// scripts/updateCard.ts
+import { defineTool as defineTool44, handleIfScriptMain as handleIfScriptMain44 } from "@zapier/connectors-sdk";
+import { z as z44 } from "zod";
+var inputSchema44 = z44.object({
+  id: z44.string().describe("24-char hex card id."),
+  name: z44.string().optional(),
+  desc: z44.string().describe(
+    "Card description (Trello Markdown). Append vs overwrite controlled by descOverwrite."
+  ).optional(),
+  descOverwrite: z44.boolean().describe("When false, append desc to existing; when true, replace.").optional(),
+  due: z44.string().datetime({ offset: true }).describe("Due datetime (ISO 8601). Pass null string to clear.").optional(),
+  start: z44.string().datetime({ offset: true }).describe("Start datetime. Pass null string to clear.").optional(),
+  dueComplete: z44.boolean().optional(),
+  closed: z44.boolean().describe("Set true to archive the card (archiveCard tool behavior).").optional(),
+  idList: z44.string().describe("Move card to this list id (moveCard tool behavior).").optional(),
+  idBoard: z44.string().describe("Destination board when moving across boards.").optional(),
+  pos: z44.any().superRefine((x, ctx) => {
+    const schemas = [z44.enum(["top", "bottom"]), z44.number()];
+    const { errors, failed } = schemas.reduce(
+      ({ errors: errors2, failed: failed2 }, schema) => ((result) => result.error ? {
+        errors: [...errors2, ...result.error.issues],
+        failed: failed2 + 1
+      } : { errors: errors2, failed: failed2 })(schema.safeParse(x)),
+      { errors: [], failed: 0 }
+    );
+    const passed = schemas.length - failed;
+    if (passed !== 1) {
+      ctx.addIssue(
+        errors.length ? {
+          path: [],
+          code: "invalid_union",
+          errors: [errors],
+          message: "Invalid input: Should pass single schema. Passed " + passed
+        } : {
+          path: [],
+          code: "custom",
+          errors: [errors],
+          message: "Invalid input: Should pass single schema. Passed " + passed
+        }
+      );
+    }
+  }).optional(),
+  address: z44.string().optional(),
+  locationName: z44.string().optional(),
+  coordinates: z44.string().describe("latitude,longitude e.g. 40.712776,-74.005974").optional()
+}).strict();
+var outputSchema43 = z44.object({
+  id: z44.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+  name: z44.string(),
+  desc: z44.string().nullable().optional(),
+  closed: z44.boolean().nullable().optional(),
+  idBoard: z44.string(),
+  idList: z44.string(),
+  idShort: z44.number().int().nullable().optional(),
+  shortLink: z44.string().nullable().optional(),
+  shortUrl: z44.string().nullable().optional(),
+  url: z44.string().nullable().optional(),
+  due: z44.union([z44.string().datetime({ offset: true }), z44.null()]).optional(),
+  dueComplete: z44.boolean().nullable().optional(),
+  dateLastActivity: z44.string().datetime({ offset: true }).nullable().optional(),
+  idLabels: z44.array(z44.string()).nullable().optional(),
+  idMembers: z44.array(z44.string()).nullable().optional(),
+  labels: z44.array(
+    z44.object({
+      id: z44.string().regex(new RegExp("^[0-9a-fA-F]{24}$")).describe("Trello object id (24 hex chars)."),
+      idBoard: z44.string(),
+      name: z44.string().nullable().optional(),
+      color: z44.string().nullable().optional()
+    })
+  ).nullable().optional(),
+  pos: z44.number().nullable().optional(),
+  customFields: z44.record(z44.string(), z44.any()).nullable().describe("Custom field values keyed by field name when requested.").optional()
+});
+var definition44 = defineTool44({
+  name: "updateCard",
+  title: "Update Card",
+  description: "Update card fields (name, description, due, cover, list, archive). Custom fields updated separately in run() polish.",
+  inputSchema: inputSchema44,
+  outputSchema: outputSchema43,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "trello",
+  run: async (input, ctx) => {
+    const url = `https://api.trello.com/1/cards/${encodeURIComponent(input.id)}`;
+    const body = {};
+    if (input.name !== void 0) body["name"] = input.name;
+    if (input.desc !== void 0) body["desc"] = input.desc;
+    if (input.descOverwrite !== void 0)
+      body["descOverwrite"] = input.descOverwrite;
+    if (input.due !== void 0) body["due"] = input.due;
+    if (input.start !== void 0) body["start"] = input.start;
+    if (input.dueComplete !== void 0)
+      body["dueComplete"] = input.dueComplete;
+    if (input.closed !== void 0) body["closed"] = input.closed;
+    if (input.idList !== void 0) body["idList"] = input.idList;
+    if (input.idBoard !== void 0) body["idBoard"] = input.idBoard;
+    if (input.pos !== void 0) body["pos"] = input.pos;
+    if (input.address !== void 0) body["address"] = input.address;
+    if (input.locationName !== void 0)
+      body["locationName"] = input.locationName;
+    if (input.coordinates !== void 0)
+      body["coordinates"] = input.coordinates;
+    const res = await ctx.fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      throw new Error(`Trello updateCard ${res.status}: ${errBody}`);
+    }
+    return res.json();
+  }
+});
+var updateCard_default = definition44;
+await handleIfScriptMain44(import.meta, definition44, { connectionResolvers });
+
+// index.ts
+var connector = defineConnector({
+  scripts: {
+    addCardAttachment: addCardAttachment_default,
+    addCardLabel: addCardLabel_default,
+    addCardMember: addCardMember_default,
+    addChecklistItem: addChecklistItem_default,
+    addMemberToBoard: addMemberToBoard_default,
+    archiveCard: archiveCard_default,
+    closeBoard: closeBoard_default,
+    completeChecklistItem: completeChecklistItem_default,
+    copyBoard: copyBoard_default,
+    createBoard: createBoard_default,
+    createCard: createCard_default,
+    createChecklist: createChecklist_default,
+    createComment: createComment_default,
+    createLabel: createLabel_default,
+    createList: createList_default,
+    deleteChecklist: deleteChecklist_default,
+    findBoard: findBoard_default,
+    findChecklist: findChecklist_default,
+    findChecklistItem: findChecklistItem_default,
+    findLabel: findLabel_default,
+    findList: findList_default,
+    findOrganizationMember: findOrganizationMember_default,
+    getAction: getAction_default,
+    getBoard: getBoard_default,
+    getCard: getCard_default,
+    getChecklist: getChecklist_default,
+    getChecklistItem: getChecklistItem_default,
+    getCurrentMember: getCurrentMember_default,
+    getLabel: getLabel_default,
+    getList: getList_default,
+    getMember: getMember_default,
+    getOrganization: getOrganization_default,
+    listBoardMembers: listBoardMembers_default,
+    listBoards: listBoards_default,
+    listCardAttachments: listCardAttachments_default,
+    listCards: listCards_default,
+    listCustomFields: listCustomFields_default,
+    listLabels: listLabels_default,
+    listLists: listLists_default,
+    listOrganizations: listOrganizations_default,
+    moveCard: moveCard_default,
+    removeCardLabel: removeCardLabel_default,
+    searchCards: searchCards_default,
+    updateCard: updateCard_default
+  },
+  connectionResolvers
+});
+var index_default = connector;
+var {
+  addCardAttachment,
+  addCardLabel,
+  addCardMember,
+  addChecklistItem,
+  addMemberToBoard,
+  archiveCard,
+  closeBoard,
+  completeChecklistItem,
+  copyBoard,
+  createBoard,
+  createCard,
+  createChecklist,
+  createComment,
+  createLabel,
+  createList,
+  deleteChecklist,
+  findBoard,
+  findChecklist,
+  findChecklistItem,
+  findLabel,
+  findList,
+  findOrganizationMember,
+  getAction,
+  getBoard,
+  getCard,
+  getChecklist,
+  getChecklistItem,
+  getCurrentMember,
+  getLabel,
+  getList,
+  getMember,
+  getOrganization,
+  listBoardMembers,
+  listBoards,
+  listCardAttachments,
+  listCards,
+  listCustomFields,
+  listLabels,
+  listLists,
+  listOrganizations,
+  moveCard,
+  removeCardLabel,
+  searchCards,
+  updateCard
+} = toFunctions(connector);
+export {
+  addCardAttachment,
+  addCardLabel,
+  addCardMember,
+  addChecklistItem,
+  addMemberToBoard,
+  archiveCard,
+  closeBoard,
+  completeChecklistItem,
+  copyBoard,
+  createBoard,
+  createCard,
+  createChecklist,
+  createComment,
+  createLabel,
+  createList,
+  index_default as default,
+  deleteChecklist,
+  findBoard,
+  findChecklist,
+  findChecklistItem,
+  findLabel,
+  findList,
+  findOrganizationMember,
+  getAction,
+  getBoard,
+  getCard,
+  getChecklist,
+  getChecklistItem,
+  getCurrentMember,
+  getLabel,
+  getList,
+  getMember,
+  getOrganization,
+  listBoardMembers,
+  listBoards,
+  listCardAttachments,
+  listCards,
+  listCustomFields,
+  listLabels,
+  listLists,
+  listOrganizations,
+  moveCard,
+  removeCardLabel,
+  searchCards,
+  updateCard
+};