@keystrokehq/resend 0.0.16 → 0.1.0

package/dist/verify-resend-domain.operation-ClVQJYPC.mjs

@@ -1,1481 +0,0 @@
-import { t as resendCredentialSet } from "./resend.credential-set-BVQIXE4k.mjs";
-import { $ as listDomainsResponseSchema, G as listTemplatesResponseSchema, H as listTopicsResponseSchema, J as listSegmentContactsResponseSchema, K as templateDetailSchema, Q as domainDetailSchema, U as topicDefaultSubscriptionSchema, W as topicSchema, X as segmentDetailSchema, Y as listSegmentsResponseSchema, Z as domainCapabilitiesSchema, _ as webhookEventSelectionSchema, a as listAttachmentsResponseSchema, at as contactTopicsResponseSchema, c as sendEmailResponseSchema, ct as topicSubscriptionSchema, d as receivedAttachmentDetailSchema, dt as listBroadcastsResponseSchema, et as contactPropertySchema, f as receivedEmailDetailSchema, ft as apiKeyCreatedSchema, g as webhookDetailSchema, h as listWebhooksResponseSchema, ht as resendApiKeyPermissionSchema, i as emailDetailSchema, it as contactPropertiesValueSchema, l as listReceivedAttachmentsResponseSchema, lt as broadcastCreateInputSchema, m as logDetailSchema, mt as paginationQuerySchema, n as batchSendInputSchema, nt as listContactPropertiesResponseSchema, o as listEmailsResponseSchema, ot as listContactSegmentsResponseSchema, p as listLogsResponseSchema, pt as listApiKeysResponseSchema, q as templateWriteFieldsSchema, r as batchSendResponseSchema, rt as contactDetailSchema, s as sendEmailInputSchema, st as listContactsResponseSchema, t as attachmentDetailSchema, tt as contactPropertyTypeSchema, u as listReceivedEmailsResponseSchema, ut as broadcastDetailSchema, v as webhookStatusSchema, vt as resendRegionSchema, yt as resendTlsPolicySchema } from "./emails-DNEKKuhw.mjs";
-import { Operation } from "@keystrokehq/core";
-import { z } from "zod";
-
-//#region ../../packages/integration-authoring/dist/http.mjs
-/**
-* Typed error thrown by `createJsonRestClient` for non-2xx responses.
-*
-* Includes the full HTTP status, status text, response headers, raw body
-* string, and request URL/method so callers can make structured decisions
-* (retry on 5xx, map 401/403 to `CredentialRevokedError`, read
-* `Retry-After`, etc.) instead of parsing error messages.
-*/
-var JsonRestError = class extends Error {
-	name = "JsonRestError";
-	status;
-	statusText;
-	body;
-	headers;
-	url;
-	method;
-	constructor(init) {
-		super(`${init.errorPrefix}: ${init.status} ${init.statusText}${init.body ? ` — ${init.body}` : ""}`);
-		this.status = init.status;
-		this.statusText = init.statusText;
-		this.body = init.body;
-		this.headers = init.headers;
-		this.url = init.url;
-		this.method = init.method;
-	}
-	/** True for 401 and 403 responses (auth / permission failures). */
-	static isAuthError(error) {
-		return isJsonRestError(error) && (error.status === 401 || error.status === 403);
-	}
-};
-/**
-* Structural type guard for `JsonRestError`. Tolerates cross-realm errors by
-* checking the `name` property instead of relying on `instanceof`.
-*/
-function isJsonRestError(error) {
-	if (!error || typeof error !== "object") return false;
-	const candidate = error;
-	return candidate.name === "JsonRestError" && typeof candidate.status === "number" && typeof candidate.body === "string";
-}
-function buildQueryString(query) {
-	if (!query) return "";
-	const params = new URLSearchParams();
-	for (const [key, value] of Object.entries(query)) if (value !== void 0 && value !== null) params.set(key, String(value));
-	const qs = params.toString();
-	return qs ? `?${qs}` : "";
-}
-function createJsonRestClient(config) {
-	const fetchImpl = config.fetchImpl ?? fetch;
-	const request = async (options) => {
-		const { method, path, body, query, headers: requestHeaders } = options;
-		const url = `${config.baseUrl}${path}${buildQueryString(query)}`;
-		const headers = {
-			Accept: "application/json",
-			...config.defaultHeaders,
-			...config.authHeaders(),
-			...requestHeaders
-		};
-		if (body !== void 0) headers["Content-Type"] ??= "application/json";
-		const response = await fetchImpl(url, {
-			method,
-			headers,
-			body: body !== void 0 ? JSON.stringify(body) : void 0
-		});
-		if (!response.ok) {
-			const errorBody = await response.text().catch(() => "");
-			throw new JsonRestError({
-				errorPrefix: config.errorPrefix,
-				status: response.status,
-				statusText: response.statusText,
-				body: errorBody,
-				headers: response.headers,
-				url,
-				method
-			});
-		}
-		if (response.status === 204) return;
-		return await response.json();
-	};
-	return { request };
-}
-
-//#endregion
-//#region src/utils/client.ts
-/**
-* resend/client.ts
-*
-* Thin wrapper over the shared `createJsonRestClient` helper configured
-* for the Resend API.
-*
-* Resend-specific notes:
-* - Base URL is `https://api.resend.com` (no version prefix).
-* - Auth is `Authorization: Bearer re_…`.
-* - A `User-Agent` header is *mandatory*: missing UA = HTTP 403 with
-*   error code 1010. Always attach one.
-* - `POST /emails` and `POST /emails/batch` honour an optional
-*   `Idempotency-Key` header (24h TTL, ≤256 chars). Pass it via
-*   `request({ headers: { 'Idempotency-Key': key } })`.
-*/
-const RESEND_BASE_URL = "https://api.resend.com";
-/** User-Agent Resend sees on every request. Stable across minor releases. */
-const RESEND_USER_AGENT = "keystroke-resend/0.0.0";
-/**
-* Create a Resend API client from resolved credentials.
-*
-* @param credentials - Resolved credentials containing `RESEND_API_KEY`.
-* @param options - Optional overrides (primarily for testing).
-* @returns A client with a typed `request` method.
-*/
-function createResendClient(credentials, options = {}) {
-	return createJsonRestClient({
-		baseUrl: options.baseUrl ?? RESEND_BASE_URL,
-		errorPrefix: "Resend API error",
-		authHeaders: () => ({ Authorization: `Bearer ${credentials.RESEND_API_KEY}` }),
-		defaultHeaders: { "User-Agent": options.userAgent ?? RESEND_USER_AGENT },
-		...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
-	});
-}
-
-//#endregion
-//#region src/operations/add-resend-contact-to-segment.operation.ts
-const addContactToSegmentOperation = new Operation({
-	id: "resend.add-resend-contact-to-segment",
-	name: "Add Resend Contact to Segment",
-	description: "Add a contact to a segment.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		contact_id: z.string().min(1),
-		segment_id: z.string().min(1)
-	}),
-	output: z.object({}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: `/contacts/${encodeURIComponent(input.contact_id)}/segments/${encodeURIComponent(input.segment_id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/cancel-resend-scheduled-email.operation.ts
-const cancelScheduledEmailOperation = new Operation({
-	id: "resend.cancel-resend-scheduled-email",
-	name: "Cancel Resend Scheduled Email",
-	description: "Cancel a scheduled email before it is sent.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("email").optional(),
-		id: z.string()
-	}),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: `/emails/${encodeURIComponent(input.id)}/cancel`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-api-key.operation.ts
-const createApiKeyOperation = new Operation({
-	id: "resend.create-resend-api-key",
-	name: "Create Resend API Key",
-	description: "Create a new API key. The cleartext token is returned once — store it immediately; Resend cannot retrieve it again.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		name: z.string().min(1).max(50),
-		permission: resendApiKeyPermissionSchema.default("full_access"),
-		domain_id: z.string().min(1).optional().describe("When set with permission=sending_access, restricts the key to sending from a single verified domain.")
-	}),
-	output: apiKeyCreatedSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/api-keys",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-broadcast.operation.ts
-const createBroadcastOperation = new Operation({
-	id: "resend.create-resend-broadcast",
-	name: "Create Resend Broadcast",
-	description: "Create a draft broadcast targeting a segment (or legacy audience).",
-	credentialSets: [resendCredentialSet],
-	input: broadcastCreateInputSchema,
-	output: broadcastDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/broadcasts",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-contact.operation.ts
-const createContactOperation = new Operation({
-	id: "resend.create-resend-contact",
-	name: "Create Resend Contact",
-	description: "Create a contact.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		email: z.email(),
-		first_name: z.string().optional(),
-		last_name: z.string().optional(),
-		unsubscribed: z.boolean().optional(),
-		properties: z.record(z.string(), contactPropertiesValueSchema).optional(),
-		segment_ids: z.array(z.string().min(1)).optional(),
-		topic_subscriptions: z.array(topicSubscriptionSchema).optional()
-	}),
-	output: contactDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/contacts",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-contact-property.operation.ts
-const createContactPropertyOperation = new Operation({
-	id: "resend.create-resend-contact-property",
-	name: "Create Resend Contact Property",
-	description: "Create a custom contact property.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		key: z.string().min(1).regex(/^[a-z0-9_]+$/, "Keys use a-z, 0-9, underscore."),
-		type: contactPropertyTypeSchema,
-		label: z.string().optional()
-	}),
-	output: contactPropertySchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/contact-properties",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-domain.operation.ts
-const createDomainOperation = new Operation({
-	id: "resend.create-resend-domain",
-	name: "Create Resend Domain",
-	description: "Register a new sending or receiving domain.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		name: z.string().min(1),
-		region: resendRegionSchema.optional(),
-		custom_return_path: z.string().optional(),
-		open_tracking: z.boolean().optional(),
-		click_tracking: z.boolean().optional(),
-		tracking_subdomain: z.string().optional(),
-		tls: resendTlsPolicySchema.optional(),
-		capabilities: domainCapabilitiesSchema.optional()
-	}),
-	output: domainDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/domains",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-segment.operation.ts
-const createSegmentOperation = new Operation({
-	id: "resend.create-resend-segment",
-	name: "Create Resend Segment",
-	description: "Create a new segment. The filter DSL is provider-native JSON.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		name: z.string().min(1),
-		filter: z.record(z.string(), z.unknown()).optional()
-	}),
-	output: segmentDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/segments",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-template.operation.ts
-const createTemplateOperation = new Operation({
-	id: "resend.create-resend-template",
-	name: "Create Resend Template",
-	description: "Create a new email template (draft).",
-	credentialSets: [resendCredentialSet],
-	input: templateWriteFieldsSchema,
-	output: templateDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/templates",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-topic.operation.ts
-const createTopicOperation = new Operation({
-	id: "resend.create-resend-topic",
-	name: "Create Resend Topic",
-	description: "Create a new subscription topic.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		name: z.string().min(1),
-		default_subscription: topicDefaultSubscriptionSchema,
-		description: z.string().optional()
-	}),
-	output: topicSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/topics",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/create-resend-webhook.operation.ts
-const createWebhookOperation = new Operation({
-	id: "resend.create-resend-webhook",
-	name: "Create Resend Webhook",
-	description: "Register a webhook endpoint. Response includes the Svix signing secret (whsec_…); store it securely.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		endpoint_url: z.url(),
-		events: webhookEventSelectionSchema,
-		status: webhookStatusSchema.optional()
-	}),
-	output: webhookDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/webhooks",
-			body: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-api-key.operation.ts
-const deleteApiKeyOperation = new Operation({
-	id: "resend.delete-resend-api-key",
-	name: "Delete Resend API Key",
-	description: "Delete (revoke) an API key.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("api_key").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/api-keys/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-broadcast.operation.ts
-const deleteBroadcastOperation = new Operation({
-	id: "resend.delete-resend-broadcast",
-	name: "Delete Resend Broadcast",
-	description: "Delete a broadcast.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("broadcast").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/broadcasts/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-contact.operation.ts
-const deleteContactOperation = new Operation({
-	id: "resend.delete-resend-contact",
-	name: "Delete Resend Contact",
-	description: "Delete a contact.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("contact").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/contacts/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-contact-property.operation.ts
-const deleteContactPropertyOperation = new Operation({
-	id: "resend.delete-resend-contact-property",
-	name: "Delete Resend Contact Property",
-	description: "Delete a contact property.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("contact_property").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/contact-properties/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-domain.operation.ts
-const deleteDomainOperation = new Operation({
-	id: "resend.delete-resend-domain",
-	name: "Delete Resend Domain",
-	description: "Delete a domain.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("domain").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/domains/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-segment.operation.ts
-const deleteSegmentOperation = new Operation({
-	id: "resend.delete-resend-segment",
-	name: "Delete Resend Segment",
-	description: "Delete a segment.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("segment").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/segments/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-template.operation.ts
-const deleteTemplateOperation = new Operation({
-	id: "resend.delete-resend-template",
-	name: "Delete Resend Template",
-	description: "Delete an existing template.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("template").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/templates/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-topic.operation.ts
-const deleteTopicOperation = new Operation({
-	id: "resend.delete-resend-topic",
-	name: "Delete Resend Topic",
-	description: "Delete a topic.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("topic").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/topics/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/delete-resend-webhook.operation.ts
-const deleteWebhookOperation = new Operation({
-	id: "resend.delete-resend-webhook",
-	name: "Delete Resend Webhook",
-	description: "Delete a webhook endpoint.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		object: z.literal("webhook").optional(),
-		id: z.string(),
-		deleted: z.boolean().optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/webhooks/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/duplicate-resend-template.operation.ts
-const duplicateTemplateOperation = new Operation({
-	id: "resend.duplicate-resend-template",
-	name: "Duplicate Resend Template",
-	description: "Duplicate an existing template.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: templateDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: `/templates/${encodeURIComponent(input.id)}/duplicate`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/get-resend-contact-topics.operation.ts
-const getContactTopicsOperation = new Operation({
-	id: "resend.get-resend-contact-topics",
-	name: "Get Resend Contact Topics",
-	description: "List topic subscriptions for a contact.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ contact_id: z.string().min(1) }),
-	output: contactTopicsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/contacts/${encodeURIComponent(input.contact_id)}/topics`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-api-keys.operation.ts
-const listApiKeysOperation = new Operation({
-	id: "resend.list-resend-api-keys",
-	name: "List Resend API Keys",
-	description: "List API keys for the authenticated team.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listApiKeysResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/api-keys",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-broadcasts.operation.ts
-const listBroadcastsOperation = new Operation({
-	id: "resend.list-resend-broadcasts",
-	name: "List Resend Broadcasts",
-	description: "List broadcasts, optionally cursor-paginated.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listBroadcastsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/broadcasts",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-contact-properties.operation.ts
-const listContactPropertiesOperation = new Operation({
-	id: "resend.list-resend-contact-properties",
-	name: "List Resend Contact Properties",
-	description: "List all custom contact properties.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listContactPropertiesResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/contact-properties",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-contact-segments.operation.ts
-const listContactSegmentsOperation = new Operation({
-	id: "resend.list-resend-contact-segments",
-	name: "List Resend Contact Segments",
-	description: "List segments a contact belongs to.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ contact_id: z.string().min(1) }),
-	output: listContactSegmentsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/contacts/${encodeURIComponent(input.contact_id)}/segments`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-contacts.operation.ts
-const listContactsOperation = new Operation({
-	id: "resend.list-resend-contacts",
-	name: "List Resend Contacts",
-	description: "List contacts, optionally filtered by segment.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema.extend({ segment_id: z.string().min(1).optional() }),
-	output: listContactsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/contacts",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-domains.operation.ts
-const listDomainsOperation = new Operation({
-	id: "resend.list-resend-domains",
-	name: "List Resend Domains",
-	description: "Retrieve a list of domains.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listDomainsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/domains",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-logs.operation.ts
-const listLogsOperation = new Operation({
-	id: "resend.list-resend-logs",
-	name: "List Resend Logs",
-	description: "List API request logs. Plan-gated.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listLogsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/logs",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-received-email-attachments.operation.ts
-const listReceivedAttachmentsOperation = new Operation({
-	id: "resend.list-resend-received-email-attachments",
-	name: "List Resend Received Email Attachments",
-	description: "List attachments on a single received email.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema.extend({ email_id: z.string().min(1) }),
-	output: listReceivedAttachmentsResponseSchema,
-	run: async (input, context) => {
-		const { email_id, ...query } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/emails/receiving/${encodeURIComponent(email_id)}/attachments`,
-			query
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-received-emails.operation.ts
-const listReceivedEmailsOperation = new Operation({
-	id: "resend.list-resend-received-emails",
-	name: "List Resend Received Emails",
-	description: "List inbound (received) emails for the authenticated team.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listReceivedEmailsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/emails/receiving",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-segment-contacts.operation.ts
-const listSegmentContactsOperation = new Operation({
-	id: "resend.list-resend-segment-contacts",
-	name: "List Resend Segment Contacts",
-	description: "List the contacts in a segment.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema.extend({ segment_id: z.string().min(1) }),
-	output: listSegmentContactsResponseSchema,
-	run: async (input, context) => {
-		const { segment_id, ...query } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/segments/${encodeURIComponent(segment_id)}/contacts`,
-			query
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-segments.operation.ts
-const listSegmentsOperation = new Operation({
-	id: "resend.list-resend-segments",
-	name: "List Resend Segments",
-	description: "Retrieve a cursor-paginated list of segments.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listSegmentsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/segments",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-sent-email-attachments.operation.ts
-const listSentAttachmentsOperation = new Operation({
-	id: "resend.list-resend-sent-email-attachments",
-	name: "List Resend Sent Email Attachments",
-	description: "List attachments that were sent with a given email.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema.extend({ email_id: z.string().min(1) }),
-	output: listAttachmentsResponseSchema,
-	run: async (input, context) => {
-		const { email_id, ...query } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/emails/${encodeURIComponent(email_id)}/attachments`,
-			query
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-sent-emails.operation.ts
-const listSentEmailsOperation = new Operation({
-	id: "resend.list-resend-sent-emails",
-	name: "List Resend Sent Emails",
-	description: "Retrieve a cursor-paginated list of emails your team has sent.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listEmailsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/emails",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-templates.operation.ts
-const listTemplatesOperation = new Operation({
-	id: "resend.list-resend-templates",
-	name: "List Resend Templates",
-	description: "Retrieve a cursor-paginated list of templates.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listTemplatesResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/templates",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-topics.operation.ts
-const listTopicsOperation = new Operation({
-	id: "resend.list-resend-topics",
-	name: "List Resend Topics",
-	description: "Retrieve a cursor-paginated list of topics.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listTopicsResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/topics",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/list-resend-webhooks.operation.ts
-const listWebhooksOperation = new Operation({
-	id: "resend.list-resend-webhooks",
-	name: "List Resend Webhooks",
-	description: "List registered webhook endpoints.",
-	credentialSets: [resendCredentialSet],
-	input: paginationQuerySchema,
-	output: listWebhooksResponseSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: "/webhooks",
-			query: input
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/publish-resend-template.operation.ts
-const publishTemplateOperation = new Operation({
-	id: "resend.publish-resend-template",
-	name: "Publish Resend Template",
-	description: "Publish a draft template so it can be referenced from sendEmail.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: templateDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: `/templates/${encodeURIComponent(input.id)}/publish`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/remove-resend-contact-from-segment.operation.ts
-const removeContactFromSegmentOperation = new Operation({
-	id: "resend.remove-resend-contact-from-segment",
-	name: "Remove Resend Contact from Segment",
-	description: "Remove a contact from a segment.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		contact_id: z.string().min(1),
-		segment_id: z.string().min(1)
-	}),
-	output: z.object({}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "DELETE",
-			path: `/contacts/${encodeURIComponent(input.contact_id)}/segments/${encodeURIComponent(input.segment_id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-broadcast.operation.ts
-const retrieveBroadcastOperation = new Operation({
-	id: "resend.retrieve-resend-broadcast",
-	name: "Retrieve Resend Broadcast",
-	description: "Retrieve a single broadcast by id.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: broadcastDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/broadcasts/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-contact.operation.ts
-const retrieveContactOperation = new Operation({
-	id: "resend.retrieve-resend-contact",
-	name: "Retrieve Resend Contact",
-	description: "Retrieve a contact by id or email.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: contactDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/contacts/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-contact-property.operation.ts
-const retrieveContactPropertyOperation = new Operation({
-	id: "resend.retrieve-resend-contact-property",
-	name: "Retrieve Resend Contact Property",
-	description: "Retrieve a single contact property by id.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: contactPropertySchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/contact-properties/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-domain.operation.ts
-const retrieveDomainOperation = new Operation({
-	id: "resend.retrieve-resend-domain",
-	name: "Retrieve Resend Domain",
-	description: "Retrieve a domain by id, including DNS records.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: domainDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/domains/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-email.operation.ts
-const retrieveEmailOperation = new Operation({
-	id: "resend.retrieve-resend-email",
-	name: "Retrieve Resend Email",
-	description: "Retrieve a single sent email by its id.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: emailDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/emails/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-log.operation.ts
-const retrieveLogOperation = new Operation({
-	id: "resend.retrieve-resend-log",
-	name: "Retrieve Resend Log",
-	description: "Retrieve a single API request log with full request and response bodies.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: logDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/logs/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-received-email.operation.ts
-const retrieveReceivedEmailOperation = new Operation({
-	id: "resend.retrieve-resend-received-email",
-	name: "Retrieve Resend Received Email",
-	description: "Retrieve a single received email with its body, headers, and attachment metadata.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: receivedEmailDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/emails/receiving/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-received-email-attachment.operation.ts
-const retrieveReceivedAttachmentOperation = new Operation({
-	id: "resend.retrieve-resend-received-email-attachment",
-	name: "Retrieve Resend Received Email Attachment",
-	description: "Retrieve a single attachment from a received email. Response includes a time-limited signed URL for the binary body.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		email_id: z.string().min(1),
-		attachment_id: z.string().min(1)
-	}),
-	output: receivedAttachmentDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/emails/receiving/${encodeURIComponent(input.email_id)}/attachments/${encodeURIComponent(input.attachment_id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-segment.operation.ts
-const retrieveSegmentOperation = new Operation({
-	id: "resend.retrieve-resend-segment",
-	name: "Retrieve Resend Segment",
-	description: "Retrieve a single segment by id.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: segmentDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/segments/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-sent-email-attachment.operation.ts
-const retrieveSentAttachmentOperation = new Operation({
-	id: "resend.retrieve-resend-sent-email-attachment",
-	name: "Retrieve Resend Sent Email Attachment",
-	description: "Retrieve a single attachment from a sent email. Response includes a time-limited signed URL for the binary body.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		email_id: z.string().min(1),
-		attachment_id: z.string().min(1)
-	}),
-	output: attachmentDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/emails/${encodeURIComponent(input.email_id)}/attachments/${encodeURIComponent(input.attachment_id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-template.operation.ts
-const retrieveTemplateOperation = new Operation({
-	id: "resend.retrieve-resend-template",
-	name: "Retrieve Resend Template",
-	description: "Retrieve a single template by id or alias.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: templateDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/templates/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-topic.operation.ts
-const retrieveTopicOperation = new Operation({
-	id: "resend.retrieve-resend-topic",
-	name: "Retrieve Resend Topic",
-	description: "Retrieve a single topic by id.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: topicSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/topics/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/retrieve-resend-webhook.operation.ts
-const retrieveWebhookOperation = new Operation({
-	id: "resend.retrieve-resend-webhook",
-	name: "Retrieve Resend Webhook",
-	description: "Retrieve a webhook endpoint, including its signing secret.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: webhookDetailSchema,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "GET",
-			path: `/webhooks/${encodeURIComponent(input.id)}`
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/send-resend-batch-emails.operation.ts
-const sendBatchEmailsOperation = new Operation({
-	id: "resend.send-resend-batch-emails",
-	name: "Send Resend Batch Emails",
-	description: "Send up to 100 transactional emails in a single Resend API call.",
-	credentialSets: [resendCredentialSet],
-	input: batchSendInputSchema,
-	output: batchSendResponseSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/emails/batch",
-			body: input.emails,
-			...input.idempotency_key ? { headers: { "Idempotency-Key": input.idempotency_key } } : {}
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/send-resend-broadcast.operation.ts
-const sendBroadcastOperation = new Operation({
-	id: "resend.send-resend-broadcast",
-	name: "Send Resend Broadcast",
-	description: "Start sending a draft broadcast. Optionally schedule it for later.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		scheduled_at: z.string().min(1).optional()
-	}),
-	output: z.object({
-		id: z.string(),
-		object: z.literal("broadcast").optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, scheduled_at } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: `/broadcasts/${encodeURIComponent(id)}/send`,
-			...scheduled_at ? { body: { scheduled_at } } : {}
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/send-resend-email.operation.ts
-const sendEmailOperation = new Operation({
-	id: "resend.send-resend-email",
-	name: "Send Resend Email",
-	description: "Send a single transactional email via Resend.",
-	credentialSets: [resendCredentialSet],
-	input: sendEmailInputSchema,
-	output: sendEmailResponseSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { idempotency_key, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: "/emails",
-			body,
-			...idempotency_key ? { headers: { "Idempotency-Key": idempotency_key } } : {}
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-broadcast.operation.ts
-const updateBroadcastOperation = new Operation({
-	id: "resend.update-resend-broadcast",
-	name: "Update Resend Broadcast",
-	description: "Update a draft broadcast. Ignored once the broadcast has started sending.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		name: z.string().optional(),
-		from: z.string().optional(),
-		subject: z.string().optional(),
-		reply_to: z.union([z.string(), z.array(z.string())]).optional(),
-		preview_text: z.string().optional(),
-		html: z.string().optional(),
-		text: z.string().optional(),
-		template: z.object({
-			id: z.string().min(1),
-			variables: z.record(z.string(), z.union([z.string(), z.number()])).optional()
-		}).optional(),
-		segment_id: z.string().optional(),
-		audience_id: z.string().optional(),
-		scheduled_at: z.string().optional()
-	}),
-	output: broadcastDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/broadcasts/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-contact.operation.ts
-const updateContactOperation = new Operation({
-	id: "resend.update-resend-contact",
-	name: "Update Resend Contact",
-	description: "Update an existing contact.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		email: z.email().optional(),
-		first_name: z.string().optional(),
-		last_name: z.string().optional(),
-		unsubscribed: z.boolean().optional(),
-		properties: z.record(z.string(), contactPropertiesValueSchema).optional()
-	}),
-	output: contactDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/contacts/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-contact-property.operation.ts
-const updateContactPropertyOperation = new Operation({
-	id: "resend.update-resend-contact-property",
-	name: "Update Resend Contact Property",
-	description: "Update a contact property (label only; key and type are immutable).",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		label: z.string().optional()
-	}),
-	output: contactPropertySchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/contact-properties/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-contact-topics.operation.ts
-const updateContactTopicsOperation = new Operation({
-	id: "resend.update-resend-contact-topics",
-	name: "Update Resend Contact Topics",
-	description: "Update topic subscriptions for a contact.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		contact_id: z.string().min(1),
-		subscriptions: z.array(topicSubscriptionSchema).min(1)
-	}),
-	output: contactTopicsResponseSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { contact_id, subscriptions } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/contacts/${encodeURIComponent(contact_id)}/topics`,
-			body: { subscriptions }
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-domain.operation.ts
-const updateDomainOperation = new Operation({
-	id: "resend.update-resend-domain",
-	name: "Update Resend Domain",
-	description: "Update tracking, TLS, or receiving settings on a domain.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		open_tracking: z.boolean().optional(),
-		click_tracking: z.boolean().optional(),
-		tracking_subdomain: z.string().optional(),
-		tls: resendTlsPolicySchema.optional(),
-		capabilities: domainCapabilitiesSchema.optional()
-	}),
-	output: domainDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/domains/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-scheduled-email.operation.ts
-const updateScheduledEmailOperation = new Operation({
-	id: "resend.update-resend-scheduled-email",
-	name: "Update Resend Scheduled Email",
-	description: "Update a scheduled email before it is sent. Typically used to move scheduled_at.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		scheduled_at: z.string().min(1).optional()
-	}),
-	output: sendEmailResponseSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/emails/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-template.operation.ts
-const updateTemplateOperation = new Operation({
-	id: "resend.update-resend-template",
-	name: "Update Resend Template",
-	description: "Update an existing template. Produces a new draft version.",
-	credentialSets: [resendCredentialSet],
-	input: templateWriteFieldsSchema.partial().extend({ id: z.string().min(1) }),
-	output: templateDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/templates/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-topic.operation.ts
-const updateTopicOperation = new Operation({
-	id: "resend.update-resend-topic",
-	name: "Update Resend Topic",
-	description: "Update an existing topic.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		name: z.string().optional(),
-		description: z.string().optional(),
-		default_subscription: topicDefaultSubscriptionSchema.optional()
-	}),
-	output: topicSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/topics/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/update-resend-webhook.operation.ts
-const updateWebhookOperation = new Operation({
-	id: "resend.update-resend-webhook",
-	name: "Update Resend Webhook",
-	description: "Update a webhook endpoint. Does NOT rotate the signing secret — cutover via create+delete for rotation.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({
-		id: z.string().min(1),
-		endpoint_url: z.url().optional(),
-		events: webhookEventSelectionSchema.optional(),
-		status: webhookStatusSchema.optional()
-	}),
-	output: webhookDetailSchema,
-	needsApproval: true,
-	run: async (input, context) => {
-		const { id, ...body } = input;
-		return createResendClient(context.credentials.resend).request({
-			method: "PATCH",
-			path: `/webhooks/${encodeURIComponent(id)}`,
-			body
-		});
-	}
-});
-
-//#endregion
-//#region src/operations/verify-resend-domain.operation.ts
-const verifyDomainOperation = new Operation({
-	id: "resend.verify-resend-domain",
-	name: "Verify Resend Domain",
-	description: "Trigger DNS verification on a domain.",
-	credentialSets: [resendCredentialSet],
-	input: z.object({ id: z.string().min(1) }),
-	output: z.object({
-		id: z.string(),
-		object: z.literal("domain").optional()
-	}).passthrough(),
-	needsApproval: true,
-	run: async (input, context) => {
-		return createResendClient(context.credentials.resend).request({
-			method: "POST",
-			path: `/domains/${encodeURIComponent(input.id)}/verify`
-		});
-	}
-});
-
-//#endregion
-export { deleteContactOperation as $, listTopicsOperation as A, listContactsOperation as B, retrieveDomainOperation as C, removeContactFromSegmentOperation as D, retrieveBroadcastOperation as E, listSegmentContactsOperation as F, getContactTopicsOperation as G, listContactPropertiesOperation as H, listReceivedEmailsOperation as I, deleteTopicOperation as J, duplicateTemplateOperation as K, listReceivedAttachmentsOperation as L, listSentEmailsOperation as M, listSentAttachmentsOperation as N, publishTemplateOperation as O, listSegmentsOperation as P, deleteContactPropertyOperation as Q, listLogsOperation as R, retrieveEmailOperation as S, retrieveContactOperation as T, listBroadcastsOperation as U, listContactSegmentsOperation as V, listApiKeysOperation as W, deleteSegmentOperation as X, deleteTemplateOperation as Y, deleteDomainOperation as Z, retrieveSentAttachmentOperation as _, updateScheduledEmailOperation as a, createSegmentOperation as at, retrieveReceivedEmailOperation as b, updateContactPropertyOperation as c, createContactOperation as ct, sendEmailOperation as d, cancelScheduledEmailOperation as dt, deleteBroadcastOperation as et, sendBroadcastOperation as f, addContactToSegmentOperation as ft, retrieveTemplateOperation as g, retrieveTopicOperation as h, updateTemplateOperation as i, createTemplateOperation as it, listTemplatesOperation as j, listWebhooksOperation as k, updateContactOperation as l, createBroadcastOperation as lt, retrieveWebhookOperation as m, updateWebhookOperation as n, createWebhookOperation as nt, updateDomainOperation as o, createDomainOperation as ot, sendBatchEmailsOperation as p, deleteWebhookOperation as q, updateTopicOperation as r, createTopicOperation as rt, updateContactTopicsOperation as s, createContactPropertyOperation as st, verifyDomainOperation as t, deleteApiKeyOperation as tt, updateBroadcastOperation as u, createApiKeyOperation as ut, retrieveSegmentOperation as v, retrieveContactPropertyOperation as w, retrieveLogOperation as x, retrieveReceivedAttachmentOperation as y, listDomainsOperation as z };