@zapier/google-contacts-connector 0.0.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,1134 @@
+// index.ts
+import { defineConnector, toFunctions } from "@zapier/connectors-sdk";
+
+// connections.ts
+import {
+  defineEnvTokenResolver,
+  zapierConnectionResolver
+} from "@zapier/connectors-sdk";
+var connectionResolvers = {
+  "google-contacts": [zapierConnectionResolver, defineEnvTokenResolver()]
+};
+
+// scripts/copyOtherContact.ts
+import { defineTool, handleIfScriptMain } from "@zapier/connectors-sdk";
+import { z as z2 } from "zod";
+
+// lib/google-contacts.ts
+import { ConnectorHttpError } from "@zapier/connectors-sdk";
+import { z } from "zod";
+var DEFAULT_PERSON_FIELDS = "names,emailAddresses,phoneNumbers,addresses,organizations,biographies,birthdays,urls,events,relations,memberships,nicknames,occupations,photos,metadata,userDefined";
+var DEFAULT_GROUP_FIELDS = "name,groupType,memberCount,clientData,metadata";
+var UPDATABLE_PERSON_FIELDS = [
+  "names",
+  "emailAddresses",
+  "phoneNumbers",
+  "addresses",
+  "organizations",
+  "biographies",
+  "birthdays",
+  "urls",
+  "events",
+  "relations",
+  "userDefined"
+];
+function deriveUpdatePersonFields(input) {
+  return UPDATABLE_PERSON_FIELDS.filter((f) => input[f] !== void 0).join(
+    ","
+  );
+}
+var nameFields = {
+  givenName: z.string().describe("First name.").optional(),
+  familyName: z.string().describe("Last name.").optional(),
+  middleName: z.string().describe("Middle name.").optional(),
+  honorificPrefix: z.string().describe("Title prefix, e.g. Dr., Ms.").optional(),
+  honorificSuffix: z.string().describe("Suffix, e.g. Jr., PhD.").optional(),
+  unstructuredName: z.string().describe(
+    "The full formatted name. Drives the display name \u2014 set it when changing name parts or the display name goes stale."
+  ).optional()
+};
+var NameSchema = z.object({
+  ...nameFields,
+  // Read-only computed names the API returns (output only — kept off NameInput).
+  displayName: z.string().describe("Read-only. The API's computed display name for the contact.").optional(),
+  displayNameLastFirst: z.string().describe("Read-only. The computed display name in last-name-first order.").optional()
+});
+var NameInput = z.strictObject(nameFields);
+var emailFields = {
+  value: z.string().describe("The email address."),
+  type: z.string().describe("Free-text label, e.g. home, work, other, or a custom label.").optional()
+};
+var EmailAddressSchema = z.object(emailFields);
+var EmailAddressInput = z.strictObject(emailFields);
+var phoneFields = {
+  value: z.string().describe("The phone number, in any format the user has it."),
+  type: z.string().describe("Free-text label, e.g. mobile, home, work, or a custom label.").optional()
+};
+var PhoneNumberSchema = z.object(phoneFields);
+var PhoneNumberInput = z.strictObject(phoneFields);
+var addressFields = {
+  streetAddress: z.string().describe("Street and number.").optional(),
+  extendedAddress: z.string().describe("Apartment, suite, unit, etc.").optional(),
+  city: z.string().describe("City / locality.").optional(),
+  region: z.string().describe("State / province / region.").optional(),
+  postalCode: z.string().describe("Postal or ZIP code.").optional(),
+  country: z.string().describe("Country name.").optional(),
+  countryCode: z.string().describe("ISO 3166-1 alpha-2 country code, e.g. US.").optional(),
+  poBox: z.string().describe("PO box.").optional(),
+  type: z.string().describe("Free-text label, e.g. home, work.").optional()
+};
+var AddressSchema = z.object(addressFields);
+var AddressInput = z.strictObject(addressFields);
+var organizationFields = {
+  name: z.string().describe("Company / organization name.").optional(),
+  title: z.string().describe("Job title.").optional(),
+  department: z.string().describe("Department.").optional(),
+  type: z.string().describe("Free-text label, e.g. work, school.").optional()
+};
+var OrganizationSchema = z.object(organizationFields);
+var OrganizationInput = z.strictObject(organizationFields);
+var biographyFields = {
+  value: z.string().describe("The note text."),
+  contentType: z.enum(["TEXT_PLAIN", "TEXT_HTML"]).describe("Whether the value is plain text or HTML.").optional()
+};
+var BiographySchema = z.object(biographyFields);
+var BiographyInput = z.strictObject(biographyFields);
+var dateFields = {
+  year: z.number().int().describe("Four-digit year. Omit if unknown.").optional(),
+  month: z.number().int().describe("Month, 1-12.").optional(),
+  day: z.number().int().describe("Day of month, 1-31.").optional()
+};
+var dateDescription = "A calendar date. Omit year for year-less dates (e.g. a birthday with no year).";
+var DateSchema = z.object(dateFields).describe(dateDescription);
+var DateInput = z.strictObject(dateFields).describe(dateDescription);
+var birthdayFields = {
+  date: DateSchema.optional(),
+  text: z.string().describe("Free-text birthday when a structured date is not available.").optional()
+};
+var BirthdaySchema = z.object(birthdayFields);
+var BirthdayInput = z.strictObject({
+  date: DateInput.optional(),
+  text: birthdayFields.text
+});
+var calendarEventFields = {
+  date: DateSchema.optional(),
+  type: z.string().describe("Free-text label, e.g. anniversary, or a custom label.").optional()
+};
+var ContactEventSchema = z.object(calendarEventFields);
+var ContactEventInput = z.strictObject({
+  date: DateInput.optional(),
+  type: calendarEventFields.type
+});
+var relationFields = {
+  person: z.string().describe("The related person's name, free text, e.g. Jane Doe."),
+  type: z.string().describe("Relationship label, e.g. spouse, child, manager.").optional()
+};
+var RelationSchema = z.object(relationFields);
+var RelationInput = z.strictObject(relationFields);
+var userDefinedFields = {
+  key: z.string().describe("The custom field's name."),
+  value: z.string().describe("The custom field's value.")
+};
+var UserDefinedSchema = z.object(userDefinedFields);
+var UserDefinedInput = z.strictObject(userDefinedFields);
+var urlFields = {
+  value: z.string().describe("The value, e.g. a URL."),
+  type: z.string().describe("Free-text label.").optional()
+};
+var UrlSchema = z.object(urlFields);
+var UrlInput = z.strictObject(urlFields);
+var MembershipInput = z.strictObject({
+  contactGroupResourceName: z.string().describe(
+    "A contact group resource name (contactGroups/\u2026) from listContactGroups."
+  )
+});
+var PhotoSchema = z.object({
+  url: z.string().optional(),
+  default: z.boolean().optional()
+});
+var MembershipSchema = z.object({
+  contactGroupMembership: z.object({ contactGroupResourceName: z.string().optional() }).optional()
+});
+var PersonSchema = z.object({
+  resourceName: z.string().describe(
+    "Canonical contact id, e.g. people/c12345. Pass to getContact/updateContact/deleteContact/modifyContactGroupMembers."
+  ),
+  etag: z.string().describe(
+    "Optimistic-concurrency token. Used internally by updateContact; changes after every edit."
+  ).optional(),
+  names: z.array(NameSchema).optional(),
+  emailAddresses: z.array(EmailAddressSchema).optional(),
+  phoneNumbers: z.array(PhoneNumberSchema).optional(),
+  addresses: z.array(AddressSchema).optional(),
+  organizations: z.array(OrganizationSchema).optional(),
+  biographies: z.array(BiographySchema).optional(),
+  birthdays: z.array(BirthdaySchema).optional(),
+  urls: z.array(UrlSchema).optional(),
+  events: z.array(ContactEventSchema).optional(),
+  relations: z.array(RelationSchema).optional(),
+  userDefined: z.array(UserDefinedSchema).optional(),
+  nicknames: z.array(z.object({ value: z.string().optional() })).optional(),
+  occupations: z.array(z.object({ value: z.string().optional() })).optional(),
+  memberships: z.array(MembershipSchema).optional(),
+  photos: z.array(PhotoSchema).optional()
+}).describe(
+  "A contact. Canonical People API Person resource \u2014 no flattening or derived fields."
+);
+var PersonResponseSchema = z.object({
+  person: PersonSchema.optional()
+});
+var ContactGroupSchema = z.object({
+  resourceName: z.string().describe(
+    "Canonical group id, e.g. contactGroups/1a2b3c. Pass to modifyContactGroupMembers."
+  ),
+  etag: z.string().describe(
+    "Optimistic-concurrency token. Used internally by updateContactGroup."
+  ).optional(),
+  name: z.string().describe("The group (label) name.").optional(),
+  formattedName: z.string().describe("Display name (localized for system groups).").optional(),
+  groupType: z.enum(["USER_CONTACT_GROUP", "SYSTEM_CONTACT_GROUP"]).describe(
+    "USER_CONTACT_GROUP (editable) or SYSTEM_CONTACT_GROUP (e.g. myContacts, starred \u2014 not renamable/deletable)."
+  ).optional(),
+  memberCount: z.number().int().describe("Number of contacts in the group.").optional(),
+  memberResourceNames: z.array(z.string()).describe(
+    "Member contact resource names (when requested via maxMembers)."
+  ).optional()
+}).describe("A contact group (label).");
+var RATE_LIMIT_STATUSES = /* @__PURE__ */ new Set(["RESOURCE_EXHAUSTED"]);
+async function readBody(res) {
+  let text;
+  try {
+    text = await res.text();
+  } catch {
+    return void 0;
+  }
+  if (text === "") return "";
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function throwForGoogleContacts(res, toolName) {
+  if (res.ok) return res;
+  const body = await readBody(res);
+  const err = body?.error;
+  const status = err?.status;
+  const apiMessage = err?.message;
+  const prefix = `Google Contacts ${toolName} ${res.status}`;
+  let message;
+  if (res.status === 401 || status === "UNAUTHENTICATED") {
+    message = `${prefix}: invalid or expired credentials. Reconnect Google Contacts.`;
+  } else if (res.status === 429 || status && RATE_LIMIT_STATUSES.has(status)) {
+    message = `${prefix}: RESOURCE_EXHAUSTED \u2014 rate/quota limited (the per-day Contact Writes quota is the common cause for writes). Back off and retry with jitter (the API does not document a Retry-After header).`;
+  } else if (res.status === 403) {
+    message = `${prefix}: ${status ?? "PERMISSION_DENIED"} \u2014 the granted OAuth scope is too narrow. Reconnect Google Contacts with contacts access (and contacts.other.readonly for other-contacts tools).`;
+  } else if (res.status === 400 && status === "FAILED_PRECONDITION") {
+    message = `${prefix}: FAILED_PRECONDITION \u2014 the contact changed since it was read (stale etag). Re-fetch with getContact and retry.`;
+  } else if (res.status === 400) {
+    message = `${prefix}: ${status ?? "INVALID_ARGUMENT"} \u2014 ${apiMessage ?? "invalid request"}. Check the field mask and that no optional section was sent empty ([] or [{}]).`;
+  } else if (res.status === 404 || status === "NOT_FOUND") {
+    message = `${prefix}: NOT_FOUND \u2014 ${apiMessage ?? "the contact or group does not exist"}. Verify the resourceName (resolve contacts via listContacts/searchContacts, groups via listContactGroups).`;
+  } else if (res.status === 409 || status === "ALREADY_EXISTS") {
+    message = `${prefix}: ALREADY_EXISTS \u2014 ${apiMessage ?? "a resource with that name already exists"}.`;
+  } else {
+    message = `${prefix}: ${apiMessage ?? status ?? "request failed"}`;
+  }
+  throw ConnectorHttpError.fromResponseBody(res, body, { message });
+}
+
+// scripts/copyOtherContact.ts
+var inputSchema = z2.object({
+  resourceName: z2.string().describe(
+    "Other-contact resource name, e.g. otherContacts/c12345 (from listOtherContacts or searchOtherContacts)."
+  ),
+  copyMask: z2.string().describe(
+    "Which fields to copy onto the new contact. Only emailAddresses, names, and phoneNumbers are supported. Defaults to all three."
+  ).default("names,emailAddresses,phoneNumbers")
+}).strict();
+var definition = defineTool({
+  name: "copyOtherContact",
+  title: "Copy Other Contact",
+  description: `Promote an "other contact" into the user's saved contacts (myContacts), returning an editable contact with a people/c\u2026 resourceName.`,
+  inputSchema,
+  outputSchema: PersonSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = `https://people.googleapis.com/v1/${input.resourceName}:copyOtherContactToMyContactsGroup`;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ copyMask: input.copyMask })
+    });
+    await throwForGoogleContacts(res, "copyOtherContact");
+    return res.json();
+  }
+});
+var copyOtherContact_default = definition;
+await handleIfScriptMain(import.meta, definition, { connectionResolvers });
+
+// scripts/createContact.ts
+import { defineTool as defineTool2, handleIfScriptMain as handleIfScriptMain2 } from "@zapier/connectors-sdk";
+import { z as z3 } from "zod";
+var inputSchema2 = z3.object({
+  names: z3.array(NameInput).describe(
+    "Name parts. Set unstructuredName (the full formatted name) or it is derived from the parts."
+  ).optional(),
+  emailAddresses: z3.array(EmailAddressInput).describe("Email addresses.").optional(),
+  phoneNumbers: z3.array(PhoneNumberInput).describe("Phone numbers.").optional(),
+  addresses: z3.array(AddressInput).describe("Postal addresses.").optional(),
+  organizations: z3.array(OrganizationInput).describe("Companies / job titles.").optional(),
+  biographies: z3.array(BiographyInput).describe("Notes about the contact.").optional(),
+  birthdays: z3.array(BirthdayInput).describe(
+    "Birthdays. Use a structured date (year optional for year-less birthdays)."
+  ).optional(),
+  urls: z3.array(UrlInput).describe("Websites or profile links.").optional(),
+  events: z3.array(ContactEventInput).describe("Custom dates such as anniversaries.").optional(),
+  relations: z3.array(RelationInput).describe("Related people (e.g. spouse, manager).").optional(),
+  userDefined: z3.array(UserDefinedInput).describe("Custom key/value fields.").optional(),
+  memberships: z3.array(MembershipInput).describe(
+    "Contact groups to add this new contact to at creation. For an EXISTING contact use modifyContactGroupMembers instead. Resolve ids via listContactGroups."
+  ).optional(),
+  personFields: z3.string().describe(
+    "Comma-separated list of contact fields to return (e.g. names,emailAddresses,phoneNumbers). Defaults to a comprehensive set; narrow it to reduce payload. Include metadata for the etag."
+  ).default(DEFAULT_PERSON_FIELDS)
+}).strict().refine(
+  (i) => (i.names?.length ?? 0) > 0 || (i.emailAddresses?.length ?? 0) > 0 || (i.phoneNumbers?.length ?? 0) > 0,
+  {
+    message: "Provide at least one of names, emailAddresses, or phoneNumbers \u2014 a contact with no name and no contact method is not useful."
+  }
+);
+var definition2 = defineTool2({
+  name: "createContact",
+  title: "Create Contact",
+  description: "Create a new contact from structured name, email, phone, address, and organization fields. Provide at least a name or one contact method.",
+  inputSchema: inputSchema2,
+  outputSchema: PersonSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const { personFields, memberships, ...sections } = input;
+    const body = {};
+    for (const [key, value] of Object.entries(sections)) {
+      if (value !== void 0) body[key] = value;
+    }
+    if (memberships !== void 0) {
+      body.memberships = memberships.map((m) => ({
+        contactGroupMembership: {
+          contactGroupResourceName: m.contactGroupResourceName
+        }
+      }));
+    }
+    const url = new URL(
+      "https://people.googleapis.com/v1/people:createContact"
+    );
+    url.searchParams.set("personFields", personFields);
+    const res = await ctx.fetch(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    await throwForGoogleContacts(res, "createContact");
+    return res.json();
+  }
+});
+var createContact_default = definition2;
+await handleIfScriptMain2(import.meta, definition2, { connectionResolvers });
+
+// scripts/createContactGroup.ts
+import { defineTool as defineTool3, handleIfScriptMain as handleIfScriptMain3 } from "@zapier/connectors-sdk";
+import { z as z4 } from "zod";
+var inputSchema3 = z4.object({
+  name: z4.string().describe(
+    "The contact group (label) name. A duplicate name returns an already-exists error."
+  )
+}).strict();
+var definition3 = defineTool3({
+  name: "createContactGroup",
+  title: "Create Contact Group",
+  description: "Create a new user contact group (label). Returns the resourceName used to add members via modifyContactGroupMembers.",
+  inputSchema: inputSchema3,
+  outputSchema: ContactGroupSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const res = await ctx.fetch(
+      "https://people.googleapis.com/v1/contactGroups",
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ contactGroup: { name: input.name } })
+      }
+    );
+    await throwForGoogleContacts(res, "createContactGroup");
+    return res.json();
+  }
+});
+var createContactGroup_default = definition3;
+await handleIfScriptMain3(import.meta, definition3, { connectionResolvers });
+
+// scripts/deleteContact.ts
+import { defineTool as defineTool4, handleIfScriptMain as handleIfScriptMain4 } from "@zapier/connectors-sdk";
+import { z as z5 } from "zod";
+var inputSchema4 = z5.object({
+  resourceName: z5.string().describe(
+    "Contact resource name, e.g. people/c12345 (from listContacts or searchContacts). Pass it whole, including the people/ prefix."
+  )
+}).strict();
+var definition4 = defineTool4({
+  name: "deleteContact",
+  title: "Delete Contact",
+  description: "Delete a contact from the user's account. A 404 means nothing was deleted \u2014 the resourceName wasn't found (already deleted, or a wrong/typo'd id); it is NOT a success. Re-resolve the contact via searchContacts/listContacts before retrying.",
+  inputSchema: inputSchema4,
+  outputSchema: z5.object({
+    success: z5.boolean().describe(
+      "True when the contact was deleted (the API returns an empty body)."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    // Not idempotent: a 404 (already-deleted or wrong id) throws rather than
+    // reporting success, so a blind retry isn't safe — the agent must re-resolve.
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = `https://people.googleapis.com/v1/${input.resourceName}:deleteContact`;
+    const res = await ctx.fetch(url, { method: "DELETE" });
+    await throwForGoogleContacts(res, "deleteContact");
+    return { success: true };
+  }
+});
+var deleteContact_default = definition4;
+await handleIfScriptMain4(import.meta, definition4, { connectionResolvers });
+
+// scripts/deleteContactGroup.ts
+import { defineTool as defineTool5, handleIfScriptMain as handleIfScriptMain5 } from "@zapier/connectors-sdk";
+import { z as z6 } from "zod";
+var inputSchema5 = z6.object({
+  resourceName: z6.string().describe(
+    "Contact group resource name, e.g. contactGroups/1a2b3c (from listContactGroups). Pass it whole, including the contactGroups/ prefix."
+  ),
+  deleteContacts: z6.boolean().describe(
+    "When true, also delete the contacts that were in the group (not just the label). Defaults to false (label only)."
+  ).default(false)
+}).strict();
+var definition5 = defineTool5({
+  name: "deleteContactGroup",
+  title: "Delete Contact Group",
+  description: "Delete a user contact group (label). System groups (myContacts, starred) cannot be deleted. Optionally delete the member contacts too. A 404 means nothing was deleted \u2014 the resourceName wasn't found (already deleted, or a wrong id); it is NOT a success. Re-resolve via listContactGroups before retrying.",
+  inputSchema: inputSchema5,
+  outputSchema: z6.object({
+    success: z6.boolean().describe(
+      "True when the group was deleted (the API returns an empty body)."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    // Not idempotent: a 404 (already-deleted or wrong id) throws rather than
+    // reporting success, so a blind retry isn't safe — the agent must re-resolve.
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://people.googleapis.com/v1/${input.resourceName}`
+    );
+    url.searchParams.set("deleteContacts", String(input.deleteContacts));
+    const res = await ctx.fetch(url.toString(), { method: "DELETE" });
+    await throwForGoogleContacts(res, "deleteContactGroup");
+    return { success: true };
+  }
+});
+var deleteContactGroup_default = definition5;
+await handleIfScriptMain5(import.meta, definition5, { connectionResolvers });
+
+// scripts/deleteContactPhoto.ts
+import { defineTool as defineTool6, handleIfScriptMain as handleIfScriptMain6 } from "@zapier/connectors-sdk";
+import { z as z7 } from "zod";
+var inputSchema6 = z7.object({
+  resourceName: z7.string().describe(
+    "Contact resource name, e.g. people/c12345 (from listContacts or searchContacts). Pass it whole, including the people/ prefix."
+  ),
+  personFields: z7.string().describe(
+    "Comma-separated list of contact fields to return (e.g. names,emailAddresses,phoneNumbers). Defaults to a comprehensive set; narrow it to reduce payload. Include metadata for the etag."
+  ).default(DEFAULT_PERSON_FIELDS)
+}).strict();
+var definition6 = defineTool6({
+  name: "deleteContactPhoto",
+  title: "Delete Contact Photo",
+  description: "Remove a contact's photo, reverting to the default avatar.",
+  inputSchema: inputSchema6,
+  outputSchema: PersonResponseSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://people.googleapis.com/v1/${input.resourceName}:deleteContactPhoto`
+    );
+    url.searchParams.set("personFields", input.personFields);
+    const res = await ctx.fetch(url.toString(), { method: "DELETE" });
+    await throwForGoogleContacts(res, "deleteContactPhoto");
+    return res.json();
+  }
+});
+var deleteContactPhoto_default = definition6;
+await handleIfScriptMain6(import.meta, definition6, { connectionResolvers });
+
+// scripts/getContact.ts
+import { defineTool as defineTool7, handleIfScriptMain as handleIfScriptMain7 } from "@zapier/connectors-sdk";
+import { z as z8 } from "zod";
+var inputSchema7 = z8.object({
+  resourceName: z8.string().describe(
+    "Contact resource name, e.g. people/c12345 (from listContacts or searchContacts). Pass it whole, including the people/ prefix."
+  ),
+  personFields: z8.string().describe(
+    "Comma-separated list of contact fields to return (e.g. names,emailAddresses,phoneNumbers). Defaults to a comprehensive set; narrow it to reduce payload. Include metadata for the etag."
+  ).default(DEFAULT_PERSON_FIELDS)
+}).strict();
+var definition7 = defineTool7({
+  name: "getContact",
+  title: "Get Contact",
+  description: "Retrieve a single contact by resource name, with full field detail. Call before an additive update to read the existing arrays.",
+  inputSchema: inputSchema7,
+  outputSchema: PersonSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://people.googleapis.com/v1/${input.resourceName}`
+    );
+    url.searchParams.set("personFields", input.personFields);
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForGoogleContacts(res, "getContact");
+    return res.json();
+  }
+});
+var getContact_default = definition7;
+await handleIfScriptMain7(import.meta, definition7, { connectionResolvers });
+
+// scripts/getContactGroup.ts
+import { defineTool as defineTool8, handleIfScriptMain as handleIfScriptMain8 } from "@zapier/connectors-sdk";
+import { z as z9 } from "zod";
+var inputSchema8 = z9.object({
+  resourceName: z9.string().describe(
+    "Contact group resource name, e.g. contactGroups/1a2b3c (from listContactGroups). Pass it whole, including the contactGroups/ prefix."
+  ),
+  maxMembers: z9.number().int().gte(1).describe(
+    "Include up to this many member contact resource names (people/c\u2026) in memberResourceNames. Omit to return group metadata only."
+  ).optional(),
+  groupFields: z9.string().describe(
+    "Comma-separated list of contact-group fields to return (e.g. name,groupType,memberCount)."
+  ).default(DEFAULT_GROUP_FIELDS)
+}).strict();
+var definition8 = defineTool8({
+  name: "getContactGroup",
+  title: "Get Contact Group",
+  description: "Get a single contact group (label) by resource name, optionally with its member contact resource names (set maxMembers).",
+  inputSchema: inputSchema8,
+  outputSchema: ContactGroupSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL(
+      `https://people.googleapis.com/v1/${input.resourceName}`
+    );
+    url.searchParams.set("groupFields", input.groupFields);
+    if (input.maxMembers !== void 0) {
+      url.searchParams.set("maxMembers", String(input.maxMembers));
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForGoogleContacts(res, "getContactGroup");
+    return res.json();
+  }
+});
+var getContactGroup_default = definition8;
+await handleIfScriptMain8(import.meta, definition8, { connectionResolvers });
+
+// scripts/listContactGroups.ts
+import { defineTool as defineTool9, handleIfScriptMain as handleIfScriptMain9 } from "@zapier/connectors-sdk";
+import { z as z10 } from "zod";
+var inputSchema9 = z10.object({
+  groupFields: z10.string().describe(
+    "Comma-separated list of contact-group fields to return (e.g. name,groupType,memberCount)."
+  ).default(DEFAULT_GROUP_FIELDS),
+  pageSize: z10.number().int().gte(1).lte(1e3).describe(
+    "Max groups to return per page. Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z10.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var definition9 = defineTool9({
+  name: "listContactGroups",
+  title: "List Contact Groups",
+  description: "List the account's contact groups (labels), user and system, with id, name, type, and member count. The resolver for any contactGroupResourceName.",
+  inputSchema: inputSchema9,
+  outputSchema: z10.object({
+    contactGroups: z10.array(ContactGroupSchema).optional().describe("The page of contact groups."),
+    next_page_token: z10.string().optional().describe("Cursor for the next page; absent when there are no more.")
+  }),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL("https://people.googleapis.com/v1/contactGroups");
+    url.searchParams.set("groupFields", input.groupFields);
+    url.searchParams.set("pageSize", String(input.pageSize ?? 20));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", input.pageToken);
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForGoogleContacts(res, "listContactGroups");
+    const payload = await res.json();
+    if (payload && typeof payload === "object" && "nextPageToken" in payload) {
+      payload.next_page_token = payload.nextPageToken;
+      delete payload.nextPageToken;
+    }
+    return payload;
+  }
+});
+var listContactGroups_default = definition9;
+await handleIfScriptMain9(import.meta, definition9, { connectionResolvers });
+
+// scripts/listContacts.ts
+import { defineTool as defineTool10, handleIfScriptMain as handleIfScriptMain10 } from "@zapier/connectors-sdk";
+import { z as z11 } from "zod";
+var inputSchema10 = z11.object({
+  personFields: z11.string().describe(
+    "Comma-separated list of contact fields to return (e.g. names,emailAddresses,phoneNumbers). Defaults to a comprehensive set; narrow it to reduce payload. Include metadata for the etag."
+  ).default(DEFAULT_PERSON_FIELDS),
+  sortOrder: z11.enum([
+    "LAST_MODIFIED_ASCENDING",
+    "LAST_MODIFIED_DESCENDING",
+    "FIRST_NAME_ASCENDING",
+    "LAST_NAME_ASCENDING"
+  ]).describe("Order of the returned contacts.").optional(),
+  pageSize: z11.number().int().gte(1).lte(1e3).describe(
+    "Max contacts to return per page. Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z11.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var definition10 = defineTool10({
+  name: "listContacts",
+  title: "List Contacts",
+  description: "List the user's contacts, paginated, with full field detail. The primary contact enumerator and resourceName resolver. Use this (not searchContacts) when freshness matters.",
+  inputSchema: inputSchema10,
+  outputSchema: z11.object({
+    contacts: z11.array(PersonSchema).optional().describe("The page of contacts."),
+    next_page_token: z11.string().optional().describe("Cursor for the next page; absent when there are no more."),
+    total_people: z11.number().int().optional().describe("Total contacts on the account.")
+  }),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL(
+      "https://people.googleapis.com/v1/people/me/connections"
+    );
+    url.searchParams.set("personFields", input.personFields);
+    if (input.sortOrder !== void 0) {
+      url.searchParams.set("sortOrder", input.sortOrder);
+    }
+    url.searchParams.set("pageSize", String(input.pageSize ?? 20));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", input.pageToken);
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForGoogleContacts(res, "listContacts");
+    const payload = await res.json();
+    if (payload && typeof payload === "object") {
+      if ("connections" in payload) {
+        payload.contacts = payload.connections;
+        delete payload.connections;
+      }
+      if ("nextPageToken" in payload) {
+        payload.next_page_token = payload.nextPageToken;
+        delete payload.nextPageToken;
+      }
+      if ("totalPeople" in payload) {
+        payload.total_people = payload.totalPeople;
+        delete payload.totalPeople;
+      }
+    }
+    return payload;
+  }
+});
+var listContacts_default = definition10;
+await handleIfScriptMain10(import.meta, definition10, { connectionResolvers });
+
+// scripts/listOtherContacts.ts
+import { defineTool as defineTool11, handleIfScriptMain as handleIfScriptMain11 } from "@zapier/connectors-sdk";
+import { z as z12 } from "zod";
+var inputSchema11 = z12.object({
+  readMask: z12.string().describe(
+    "Comma-separated fields to return. Other contacts support only emailAddresses, metadata, names, phoneNumbers, and photos."
+  ).default("names,emailAddresses,phoneNumbers,metadata"),
+  pageSize: z12.number().int().gte(1).lte(1e3).describe(
+    "Max other-contacts to return per page. Defaults to 20 when omitted; pass a value when you need a specific number of results."
+  ).optional(),
+  pageToken: z12.string().describe(
+    "Page cursor from a previous response's next_page_token. Omit for the first page."
+  ).optional()
+}).strict();
+var definition11 = defineTool11({
+  name: "listOtherContacts",
+  title: "List Other Contacts",
+  description: `List the user's auto-saved "other contacts" \u2014 people interacted with (e.g. emailed) but never explicitly saved. Read-only; use copyOtherContact to make one editable.`,
+  inputSchema: inputSchema11,
+  outputSchema: z12.object({
+    otherContacts: z12.array(PersonSchema).optional().describe("The page of other contacts."),
+    next_page_token: z12.string().optional().describe("Cursor for the next page; absent when there are no more.")
+  }),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL("https://people.googleapis.com/v1/otherContacts");
+    url.searchParams.set("readMask", input.readMask);
+    url.searchParams.set("pageSize", String(input.pageSize ?? 20));
+    if (input.pageToken !== void 0) {
+      url.searchParams.set("pageToken", input.pageToken);
+    }
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForGoogleContacts(res, "listOtherContacts");
+    const payload = await res.json();
+    if (payload && typeof payload === "object" && "nextPageToken" in payload) {
+      payload.next_page_token = payload.nextPageToken;
+      delete payload.nextPageToken;
+    }
+    return payload;
+  }
+});
+var listOtherContacts_default = definition11;
+await handleIfScriptMain11(import.meta, definition11, { connectionResolvers });
+
+// scripts/modifyContactGroupMembers.ts
+import { defineTool as defineTool12, handleIfScriptMain as handleIfScriptMain12 } from "@zapier/connectors-sdk";
+import { z as z13 } from "zod";
+var inputSchema12 = z13.object({
+  resourceName: z13.string().describe(
+    "Contact group resource name, e.g. contactGroups/1a2b3c (from listContactGroups)."
+  ),
+  resourceNamesToAdd: z13.array(z13.string()).describe("Contact resource names (people/c\u2026) to add to the group.").optional(),
+  resourceNamesToRemove: z13.array(z13.string()).describe("Contact resource names (people/c\u2026) to remove from the group.").optional()
+}).strict().refine(
+  (i) => (i.resourceNamesToAdd?.length ?? 0) > 0 || (i.resourceNamesToRemove?.length ?? 0) > 0,
+  {
+    message: "Provide at least one of resourceNamesToAdd or resourceNamesToRemove \u2014 both cannot be empty."
+  }
+);
+var definition12 = defineTool12({
+  name: "modifyContactGroupMembers",
+  title: "Modify Contact Group Members",
+  description: "Add and/or remove contacts in a contact group without disturbing other memberships. Combined add+remove must be 1000 or fewer.",
+  inputSchema: inputSchema12,
+  outputSchema: z13.object({
+    notFoundResourceNames: z13.array(z13.string()).optional().describe("Resource names that could not be found and were skipped."),
+    canNotRemoveLastContactGroupResourceNames: z13.array(z13.string()).optional().describe(
+      "Contacts that could not be removed because it was their only group (every contact stays in myContacts)."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    // resourceNamesToRemove removes group memberships — a non-additive update.
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = `https://people.googleapis.com/v1/${input.resourceName}/members:modify`;
+    const body = {};
+    if (input.resourceNamesToAdd !== void 0)
+      body.resourceNamesToAdd = input.resourceNamesToAdd;
+    if (input.resourceNamesToRemove !== void 0)
+      body.resourceNamesToRemove = input.resourceNamesToRemove;
+    const res = await ctx.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    await throwForGoogleContacts(res, "modifyContactGroupMembers");
+    return res.json();
+  }
+});
+var modifyContactGroupMembers_default = definition12;
+await handleIfScriptMain12(import.meta, definition12, { connectionResolvers });
+
+// scripts/searchContacts.ts
+import { defineTool as defineTool13, handleIfScriptMain as handleIfScriptMain13 } from "@zapier/connectors-sdk";
+import { z as z14 } from "zod";
+var inputSchema13 = z14.object({
+  query: z14.string().describe(
+    'Prefix phrase matched against names, nicknames, emails, phones, and organizations. "foo n" matches "foo name"; "oo n" does not.'
+  ),
+  readMask: z14.string().describe(
+    "Comma-separated list of contact fields to return on each match. Defaults to a comprehensive set."
+  ).default(DEFAULT_PERSON_FIELDS),
+  pageSize: z14.number().int().gte(1).lte(30).describe(
+    "Max results per page. Caps at 30. Defaults to 10 when omitted; pass a value when you need a specific number of results."
+  ).optional()
+}).strict();
+var definition13 = defineTool13({
+  name: "searchContacts",
+  title: "Search Contacts",
+  description: "Search the user's contacts by name, nickname, email, phone, or organization (prefix matching). Newly created/updated contacts may lag a few minutes behind \u2014 use listContacts when freshness matters.",
+  inputSchema: inputSchema13,
+  outputSchema: z14.object({
+    results: z14.array(z14.object({ person: PersonSchema.optional() })).optional().describe("Matching contacts.")
+  }),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL(
+      "https://people.googleapis.com/v1/people:searchContacts"
+    );
+    url.searchParams.set("query", input.query);
+    url.searchParams.set("readMask", input.readMask);
+    url.searchParams.set("pageSize", String(input.pageSize ?? 10));
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForGoogleContacts(res, "searchContacts");
+    return res.json();
+  }
+});
+var searchContacts_default = definition13;
+await handleIfScriptMain13(import.meta, definition13, { connectionResolvers });
+
+// scripts/searchOtherContacts.ts
+import { defineTool as defineTool14, handleIfScriptMain as handleIfScriptMain14 } from "@zapier/connectors-sdk";
+import { z as z15 } from "zod";
+var inputSchema14 = z15.object({
+  query: z15.string().describe(
+    "Prefix phrase matched against names, emails, and phones of other contacts."
+  ),
+  readMask: z15.string().describe(
+    "Comma-separated fields to return. Other contacts support only emailAddresses, metadata, names, phoneNumbers, and photos."
+  ).default("names,emailAddresses,phoneNumbers,metadata"),
+  pageSize: z15.number().int().gte(1).lte(30).describe(
+    "Max results per page. Caps at 30. Defaults to 10 when omitted; pass a value when you need a specific number of results."
+  ).optional()
+}).strict();
+var definition14 = defineTool14({
+  name: "searchOtherContacts",
+  title: "Search Other Contacts",
+  description: `Search the user's "other contacts" by name, email, or phone (prefix matching). Same lazy-index caveat as searchContacts \u2014 recently-seen contacts may lag.`,
+  inputSchema: inputSchema14,
+  outputSchema: z15.object({
+    results: z15.array(z15.object({ person: PersonSchema.optional() })).optional().describe("Matching other contacts.")
+  }),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = new URL(
+      "https://people.googleapis.com/v1/otherContacts:search"
+    );
+    url.searchParams.set("query", input.query);
+    url.searchParams.set("readMask", input.readMask);
+    url.searchParams.set("pageSize", String(input.pageSize ?? 10));
+    const res = await ctx.fetch(url.toString(), { method: "GET" });
+    await throwForGoogleContacts(res, "searchOtherContacts");
+    return res.json();
+  }
+});
+var searchOtherContacts_default = definition14;
+await handleIfScriptMain14(import.meta, definition14, { connectionResolvers });
+
+// scripts/updateContact.ts
+import { defineTool as defineTool15, handleIfScriptMain as handleIfScriptMain15 } from "@zapier/connectors-sdk";
+import { z as z16 } from "zod";
+var inputSchema15 = z16.object({
+  resourceName: z16.string().describe(
+    "Contact to update, e.g. people/c12345 (from listContacts or searchContacts). Pass it whole, including the people/ prefix."
+  ),
+  names: z16.array(NameInput).describe(
+    "Replaces the full names array. unstructuredName is rebuilt from the parts if you omit it."
+  ).optional(),
+  emailAddresses: z16.array(EmailAddressInput).describe(
+    "Replaces the full email list. To add one without losing the others, getContact first, append, then send the complete array."
+  ).optional(),
+  phoneNumbers: z16.array(PhoneNumberInput).describe(
+    "Replaces the full phone list. To add one without losing the others, getContact first, append, then send the complete array."
+  ).optional(),
+  addresses: z16.array(AddressInput).describe("Replaces the full addresses array.").optional(),
+  organizations: z16.array(OrganizationInput).describe("Replaces the full organizations array.").optional(),
+  biographies: z16.array(BiographyInput).describe("Replaces the full notes (biographies) array.").optional(),
+  birthdays: z16.array(BirthdayInput).describe("Replaces the full birthdays array.").optional(),
+  urls: z16.array(UrlInput).describe("Replaces the full urls array.").optional(),
+  events: z16.array(ContactEventInput).describe("Replaces the full custom-events array.").optional(),
+  relations: z16.array(RelationInput).describe("Replaces the full relations array.").optional(),
+  userDefined: z16.array(UserDefinedInput).describe("Replaces the full userDefined key/value array.").optional()
+}).strict();
+function withUnstructuredNames(names) {
+  return names.map((n) => {
+    if (n.unstructuredName) return n;
+    const parts = [
+      n.honorificPrefix,
+      n.givenName,
+      n.middleName,
+      n.familyName,
+      n.honorificSuffix
+    ].filter((p) => Boolean(p && p.trim()));
+    if (parts.length === 0) return n;
+    return { ...n, unstructuredName: parts.join(" ") };
+  });
+}
+var definition15 = defineTool15({
+  name: "updateContact",
+  title: "Update Contact",
+  description: "Update fields on an existing contact. Each array you send REPLACES that whole field (e.g. sending emailAddresses replaces every email) \u2014 to add to a list, getContact first, append, then send the full array. Fields you omit are left untouched. Does not change group membership (use modifyContactGroupMembers).",
+  inputSchema: inputSchema15,
+  outputSchema: PersonSchema,
+  annotations: {
+    readOnlyHint: false,
+    // Each array field is replace-not-merge: sending one (e.g. emailAddresses)
+    // overwrites the whole field and silently drops any values not included.
+    // That is a non-additive (destructive) update, so the host should treat it
+    // as such and not suppress a confirmation.
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const { resourceName, ...fields } = input;
+    const updatePersonFields = deriveUpdatePersonFields(fields);
+    if (updatePersonFields === "") {
+      throw new Error(
+        "Google Contacts updateContact: no fields to update \u2014 supply at least one of names, emailAddresses, phoneNumbers, addresses, organizations, biographies, birthdays, urls, events, relations, or userDefined."
+      );
+    }
+    const getUrl = new URL(`https://people.googleapis.com/v1/${resourceName}`);
+    getUrl.searchParams.set("personFields", "metadata");
+    const getRes = await ctx.fetch(getUrl.toString(), { method: "GET" });
+    await throwForGoogleContacts(getRes, "updateContact");
+    const current = await getRes.json();
+    const body = { etag: current.etag, ...fields };
+    if (fields.names) body.names = withUnstructuredNames(fields.names);
+    const patchUrl = new URL(
+      `https://people.googleapis.com/v1/${resourceName}:updateContact`
+    );
+    patchUrl.searchParams.set("updatePersonFields", updatePersonFields);
+    patchUrl.searchParams.set("personFields", DEFAULT_PERSON_FIELDS);
+    const patchRes = await ctx.fetch(patchUrl.toString(), {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    await throwForGoogleContacts(patchRes, "updateContact");
+    return patchRes.json();
+  }
+});
+var updateContact_default = definition15;
+await handleIfScriptMain15(import.meta, definition15, { connectionResolvers });
+
+// scripts/updateContactGroup.ts
+import { defineTool as defineTool16, handleIfScriptMain as handleIfScriptMain16 } from "@zapier/connectors-sdk";
+import { z as z17 } from "zod";
+var inputSchema16 = z17.object({
+  resourceName: z17.string().describe(
+    "Contact group to rename, e.g. contactGroups/1a2b3c (from listContactGroups). System groups (myContacts, starred) cannot be renamed."
+  ),
+  name: z17.string().describe("The new contact group (label) name.")
+}).strict();
+var definition16 = defineTool16({
+  name: "updateContactGroup",
+  title: "Update Contact Group",
+  description: "Rename an existing user contact group (label). Only USER_CONTACT_GROUPs can be renamed \u2014 system groups (myContacts, starred) are rejected. Check groupType via listContactGroups.",
+  inputSchema: inputSchema16,
+  outputSchema: ContactGroupSchema,
+  annotations: {
+    readOnlyHint: false,
+    // Rename overwrites the existing group name (replace, not add) — non-additive.
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const base = `https://people.googleapis.com/v1/${input.resourceName}`;
+    const getUrl = new URL(base);
+    getUrl.searchParams.set("groupFields", "metadata");
+    const getRes = await ctx.fetch(getUrl.toString(), { method: "GET" });
+    await throwForGoogleContacts(getRes, "updateContactGroup");
+    const current = await getRes.json();
+    const putRes = await ctx.fetch(base, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        contactGroup: { etag: current.etag, name: input.name },
+        updateGroupFields: "name"
+      })
+    });
+    await throwForGoogleContacts(putRes, "updateContactGroup");
+    return putRes.json();
+  }
+});
+var updateContactGroup_default = definition16;
+await handleIfScriptMain16(import.meta, definition16, { connectionResolvers });
+
+// scripts/updateContactPhoto.ts
+import { defineTool as defineTool17, handleIfScriptMain as handleIfScriptMain17 } from "@zapier/connectors-sdk";
+import { z as z18 } from "zod";
+var inputSchema17 = z18.object({
+  resourceName: z18.string().describe(
+    "Contact resource name, e.g. people/c12345 (from listContacts or searchContacts). Pass it whole, including the people/ prefix."
+  ),
+  photoBytes: z18.string().describe("The contact photo as a base64-encoded image string."),
+  personFields: z18.string().describe(
+    "Which fields to return on the updated contact. Defaults to a comprehensive set."
+  ).default("names,emailAddresses,phoneNumbers,photos,metadata")
+}).strict();
+var definition17 = defineTool17({
+  name: "updateContactPhoto",
+  title: "Update Contact Photo",
+  description: "Set or replace a contact's photo. photoBytes is the image as a base64-encoded string (not a URL or file path).",
+  inputSchema: inputSchema17,
+  outputSchema: PersonResponseSchema,
+  annotations: {
+    readOnlyHint: false,
+    // Overwrites the contact's existing photo (replace, not add) — non-additive.
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  connection: "google-contacts",
+  run: async (input, ctx) => {
+    const url = `https://people.googleapis.com/v1/${input.resourceName}:updateContactPhoto`;
+    const res = await ctx.fetch(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        photoBytes: input.photoBytes,
+        personFields: input.personFields
+      })
+    });
+    await throwForGoogleContacts(res, "updateContactPhoto");
+    return res.json();
+  }
+});
+var updateContactPhoto_default = definition17;
+await handleIfScriptMain17(import.meta, definition17, { connectionResolvers });
+
+// index.ts
+var connector = defineConnector({
+  scripts: {
+    copyOtherContact: copyOtherContact_default,
+    createContact: createContact_default,
+    createContactGroup: createContactGroup_default,
+    deleteContact: deleteContact_default,
+    deleteContactGroup: deleteContactGroup_default,
+    deleteContactPhoto: deleteContactPhoto_default,
+    getContact: getContact_default,
+    getContactGroup: getContactGroup_default,
+    listContactGroups: listContactGroups_default,
+    listContacts: listContacts_default,
+    listOtherContacts: listOtherContacts_default,
+    modifyContactGroupMembers: modifyContactGroupMembers_default,
+    searchContacts: searchContacts_default,
+    searchOtherContacts: searchOtherContacts_default,
+    updateContact: updateContact_default,
+    updateContactGroup: updateContactGroup_default,
+    updateContactPhoto: updateContactPhoto_default
+  },
+  connectionResolvers
+});
+var index_default = connector;
+var {
+  copyOtherContact,
+  createContact,
+  createContactGroup,
+  deleteContact,
+  deleteContactGroup,
+  deleteContactPhoto,
+  getContact,
+  getContactGroup,
+  listContactGroups,
+  listContacts,
+  listOtherContacts,
+  modifyContactGroupMembers,
+  searchContacts,
+  searchOtherContacts,
+  updateContact,
+  updateContactGroup,
+  updateContactPhoto
+} = toFunctions(connector);
+export {
+  copyOtherContact,
+  createContact,
+  createContactGroup,
+  index_default as default,
+  deleteContact,
+  deleteContactGroup,
+  deleteContactPhoto,
+  getContact,
+  getContactGroup,
+  listContactGroups,
+  listContacts,
+  listOtherContacts,
+  modifyContactGroupMembers,
+  searchContacts,
+  searchOtherContacts,
+  updateContact,
+  updateContactGroup,
+  updateContactPhoto
+};