samva 0.16.0 → 0.18.0

package/dist/effect/generated/mailboxes.js

@@ -0,0 +1,2312 @@
+import { ApiKeySecurityMiddleware, AttachmentId, BillingProviderError, ConflictError, ConversationId, CreateMailboxEndpointPayload, Cursor, EmailAttachment, ForbiddenError, GatewayTimeoutError, InternalError, JsonValue, MailboxActionDecision, MailboxActionId, MailboxChannel, MailboxChannelUnsupportedError, MailboxDraftId, MailboxEndpointId, MailboxGrantRole, MailboxId, MailboxLabelId, MailboxMetadata, MailboxMetadataPatch, MailboxPolicyId, MailboxPolicyOutcomeKind, MailboxSendConflictError, MailboxSendMode, MailboxSendOutcome, MailboxSendReceipt, MailboxSendRefusedError, MailboxThreadFolder, MailboxThreadId, MailboxThreadPriority, MediaId, MessageId, NamespaceId, OnboardingReviewRequiredError, PaymentRequiredError, RateLimitedError, ResourceNotFoundError, SenderNotReadyError, SkippedRecipient, SuccessResponse, UnauthorizedError, UserId, ValidationError } from "./shared.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/mailboxes.ts
+const MailboxStatus = /* @__PURE__ */ Schema.Union([Schema.Literal("active"), Schema.Literal("paused")]).annotate({ identifier: "MailboxStatus" });
+const MailboxAgentActivity = /* @__PURE__ */ Schema.Struct({
+	actions: Schema.Struct({
+		byType: Schema.Array(Schema.Struct({
+			type: Schema.Union([
+				Schema.Literal("sendMessage"),
+				Schema.Literal("reply"),
+				Schema.Literal("updateDraft"),
+				Schema.Literal("createNote"),
+				Schema.Literal("assignThread"),
+				Schema.Literal("changeThreadState"),
+				Schema.Literal("call"),
+				Schema.Literal("extensionRequest")
+			]),
+			count: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+		})),
+		byState: Schema.Array(Schema.Struct({
+			state: Schema.Union([
+				Schema.Literal("proposed"),
+				Schema.Literal("allowed"),
+				Schema.Literal("approvalRequired"),
+				Schema.Literal("policyDenied"),
+				Schema.Literal("approved"),
+				Schema.Literal("approvalDenied"),
+				Schema.Literal("executing"),
+				Schema.Literal("executed"),
+				Schema.Literal("failed"),
+				Schema.Literal("queued"),
+				Schema.Literal("accepted"),
+				Schema.Literal("completed"),
+				Schema.Literal("notSent"),
+				Schema.Literal("uncertain")
+			]),
+			count: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+		}))
+	}),
+	events: Schema.Struct({ byType: Schema.Array(Schema.Struct({
+		type: Schema.Union([
+			Schema.Literal("mailbox.created"),
+			Schema.Literal("endpoint.attached"),
+			Schema.Literal("endpoint.detached"),
+			Schema.Literal("message.received"),
+			Schema.Literal("message.released"),
+			Schema.Literal("message.sent"),
+			Schema.Literal("thread.created"),
+			Schema.Literal("action.proposed"),
+			Schema.Literal("action.policy_decided"),
+			Schema.Literal("action.approval_requested"),
+			Schema.Literal("action.approval_resolved"),
+			Schema.Literal("action.accepted"),
+			Schema.Literal("action.executed"),
+			Schema.Literal("action.failed")
+		]),
+		count: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+	})) }),
+	pendingApprovals: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+}).annotate({ identifier: "MailboxAgentActivity" });
+const MailboxDraftState = /* @__PURE__ */ Schema.Union([
+	Schema.Literal("saved"),
+	Schema.Literal("locked"),
+	Schema.Literal("sent")
+]).annotate({ identifier: "MailboxDraftState" });
+const MailboxEventId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^mbxevt_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^mbxevt_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "MailboxEventId"
+})).pipe(Schema.brand("MailboxEventId"));
+const MailboxGrantId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^mbxacl_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^mbxacl_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "MailboxGrantId"
+})).pipe(Schema.brand("MailboxGrantId"));
+const MailboxMessageSender = /* @__PURE__ */ Schema.Struct({
+	actor: Schema.optionalKey(Schema.Union([Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}), Schema.Null])),
+	displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	address: Schema.String
+}).annotate({ identifier: "MailboxMessageSender" });
+const MailboxMessageRecipient = /* @__PURE__ */ Schema.Struct({
+	kind: Schema.Union([
+		Schema.Literal("to"),
+		Schema.Literal("cc"),
+		Schema.Literal("bcc")
+	]),
+	actor: Schema.optionalKey(Schema.Union([Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}), Schema.Null])),
+	displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	address: Schema.String
+}).annotate({ identifier: "MailboxMessageRecipient" });
+const MailboxMessageAuthentication = /* @__PURE__ */ Schema.Struct({
+	spf: Schema.Union([Schema.String, Schema.Null]),
+	dkim: Schema.Union([Schema.String, Schema.Null]),
+	dmarc: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxMessageAuthentication" });
+const MailboxDownloadUrl = /* @__PURE__ */ Schema.Struct({
+	url: Schema.String,
+	expiresAt: Schema.String
+}).annotate({ identifier: "MailboxDownloadUrl" });
+const MailboxThreadSender = /* @__PURE__ */ Schema.Struct({
+	address: Schema.Union([Schema.String, Schema.Null]),
+	displayName: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxThreadSender" });
+const MailboxThreadParticipant = /* @__PURE__ */ Schema.Struct({
+	actor: Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}),
+	role: Schema.Union([
+		Schema.Literal("recipient"),
+		Schema.Literal("sender"),
+		Schema.Literal("assignee"),
+		Schema.Literal("observer")
+	]),
+	address: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+}).annotate({ identifier: "MailboxThreadParticipant" });
+const MailboxNoteId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^note_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^note_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "MailboxNoteId"
+})).pipe(Schema.brand("MailboxNoteId"));
+const MailboxCopiedAttachment = /* @__PURE__ */ Schema.Struct({
+	filename: Schema.String,
+	content: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	mediaId: Schema.optionalKey(Schema.Union([MediaId, Schema.Null])),
+	contentType: Schema.String,
+	size: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isLessThanOrEqualTo(26214400).annotate({ expected: "a value less than or equal to 26214400" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" }))
+}).annotate({ identifier: "MailboxCopiedAttachment" });
+const MailboxSummary = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	namespaceId: Schema.Union([NamespaceId, Schema.Null]),
+	slug: Schema.String,
+	name: Schema.String,
+	status: MailboxStatus,
+	primaryAddress: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String
+}).annotate({ identifier: "MailboxSummary" });
+const MailboxEndpoint = /* @__PURE__ */ Schema.Struct({
+	id: MailboxEndpointId,
+	address: Schema.String,
+	displayName: Schema.Union([Schema.String, Schema.Null]),
+	default: Schema.Boolean,
+	channel: Schema.Literal("email"),
+	source: Schema.Union([Schema.Literal("samvaHosted"), Schema.Literal("verifiedDomain")]),
+	domainId: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxEndpoint" });
+const MailboxQuarantinedMessage = /* @__PURE__ */ Schema.Struct({
+	id: MessageId,
+	disposition: Schema.Union([Schema.Literal("quarantined"), Schema.Literal("isolated")]),
+	reason: Schema.Union([
+		Schema.Literal("spam"),
+		Schema.Literal("dmarc"),
+		Schema.Literal("virus"),
+		Schema.Literal("virus_unscanned"),
+		Schema.Literal("phishing"),
+		Schema.Literal("fraud"),
+		Schema.Literal("prompt_injection")
+	]),
+	source: Schema.Union([Schema.Literal("receipt"), Schema.Literal("classifier")]),
+	from: Schema.Struct({
+		address: Schema.String,
+		name: Schema.Union([Schema.String, Schema.Null])
+	}),
+	subject: Schema.Union([Schema.String, Schema.Null]),
+	receivedAt: Schema.String,
+	heldAt: Schema.String,
+	releasedAt: Schema.Union([Schema.String, Schema.Null]),
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	discardedAt: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxQuarantinedMessage" });
+const MailboxDraftSummary = /* @__PURE__ */ Schema.Struct({
+	id: MailboxDraftId,
+	channel: MailboxChannel,
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	inReplyToMessageId: Schema.Union([MessageId, Schema.Null]),
+	state: MailboxDraftState,
+	lockedByActionId: Schema.Union([MailboxActionId, Schema.Null]),
+	to: Schema.Array(Schema.String),
+	subject: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "MailboxDraftSummary" });
+const MailboxEvent = /* @__PURE__ */ Schema.Struct({
+	id: MailboxEventId,
+	type: Schema.Union([
+		Schema.Literal("mailbox.created"),
+		Schema.Literal("endpoint.attached"),
+		Schema.Literal("endpoint.detached"),
+		Schema.Literal("message.received"),
+		Schema.Literal("message.released"),
+		Schema.Literal("message.sent"),
+		Schema.Literal("thread.created"),
+		Schema.Literal("action.proposed"),
+		Schema.Literal("action.policy_decided"),
+		Schema.Literal("action.approval_requested"),
+		Schema.Literal("action.approval_resolved"),
+		Schema.Literal("action.accepted"),
+		Schema.Literal("action.executed"),
+		Schema.Literal("action.failed")
+	]),
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	actionId: Schema.Union([MailboxActionId, Schema.Null]),
+	actor: Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}),
+	payload: Schema.Record(Schema.String, JsonValue),
+	occurredAt: Schema.String
+}).annotate({ identifier: "MailboxEvent" });
+const MailboxFolderCount = /* @__PURE__ */ Schema.Struct({
+	folder: MailboxThreadFolder,
+	count: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	unreadCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+}).annotate({ identifier: "MailboxFolderCount" });
+const MailboxGrant = /* @__PURE__ */ Schema.Struct({
+	id: MailboxGrantId,
+	actor: Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}),
+	permissions: Schema.Array(Schema.Union([
+		Schema.Literal("mailbox:read"),
+		Schema.Literal("mailbox:configure"),
+		Schema.Literal("thread:read"),
+		Schema.Literal("thread:write"),
+		Schema.Literal("label:write"),
+		Schema.Literal("draft:write"),
+		Schema.Literal("note:write"),
+		Schema.Literal("action:propose"),
+		Schema.Literal("action:approve"),
+		Schema.Literal("policy:read"),
+		Schema.Literal("quarantine:read"),
+		Schema.Literal("quarantine:release")
+	])),
+	sendMode: MailboxSendMode,
+	createdAt: Schema.String
+}).annotate({ identifier: "MailboxGrant" });
+const MailboxLabel = /* @__PURE__ */ Schema.Struct({
+	id: MailboxLabelId,
+	slug: Schema.String,
+	displayName: Schema.String,
+	color: Schema.Union([Schema.Union([
+		Schema.Literal("billing"),
+		Schema.Literal("domain"),
+		Schema.Literal("agent"),
+		Schema.Literal("routing"),
+		Schema.Literal("important"),
+		Schema.Literal("neutral")
+	]), Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "MailboxLabel" });
+const MailboxMessageSummary = /* @__PURE__ */ Schema.Struct({
+	id: MessageId,
+	channel: MailboxChannel,
+	direction: Schema.Union([Schema.Literal("inbound"), Schema.Literal("outbound")]),
+	from: MailboxMessageSender,
+	to: Schema.Array(Schema.String),
+	subject: Schema.Union([Schema.String, Schema.Null]),
+	preview: Schema.Union([Schema.String, Schema.Null]),
+	hasAttachments: Schema.Boolean,
+	occurredAt: Schema.String
+}).annotate({ identifier: "MailboxMessageSummary" });
+const MailboxMessage = /* @__PURE__ */ Schema.Struct({
+	id: MessageId,
+	threadId: MailboxThreadId,
+	conversationId: ConversationId,
+	direction: Schema.Union([Schema.Literal("inbound"), Schema.Literal("outbound")]),
+	from: MailboxMessageSender,
+	sentBy: Schema.optionalKey(Schema.Union([Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}), Schema.Null])),
+	occurredAt: Schema.String,
+	channel: Schema.Literal("email"),
+	recipients: Schema.Array(MailboxMessageRecipient),
+	replyTo: Schema.Array(Schema.String),
+	subject: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	text: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	html: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	replyText: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	headers: Schema.Struct({
+		messageId: Schema.Union([Schema.String, Schema.Null]),
+		inReplyTo: Schema.Union([Schema.String, Schema.Null]),
+		references: Schema.Array(Schema.String)
+	}),
+	authentication: Schema.Union([MailboxMessageAuthentication, Schema.Null]),
+	attachments: Schema.Array(Schema.Struct({
+		id: AttachmentId,
+		filename: Schema.String,
+		contentType: Schema.String,
+		size: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		isInline: Schema.Boolean
+	}))
+}).annotate({ identifier: "MailboxMessage" });
+const MailboxPolicy = /* @__PURE__ */ Schema.Struct({
+	id: MailboxPolicyId,
+	name: Schema.String,
+	outcome: MailboxPolicyOutcomeKind,
+	reason: Schema.Union([Schema.String, Schema.Null]),
+	enabled: Schema.Boolean,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "MailboxPolicy" });
+const MailboxThreadSummary = /* @__PURE__ */ Schema.Struct({
+	id: MailboxThreadId,
+	channel: MailboxChannel,
+	endpointId: Schema.Union([MailboxEndpointId, Schema.Null]),
+	subject: Schema.Union([Schema.String, Schema.Null]),
+	preview: Schema.Union([Schema.String, Schema.Null]),
+	from: Schema.Union([MailboxThreadSender, Schema.Null]),
+	messageCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	hasAttachments: Schema.Boolean,
+	hasDraft: Schema.Boolean,
+	folder: MailboxThreadFolder,
+	priority: MailboxThreadPriority,
+	labels: Schema.Array(MailboxLabelId),
+	read: Schema.Boolean,
+	starred: Schema.Boolean,
+	snoozedUntil: Schema.Union([Schema.String, Schema.Null]),
+	lastActivityAt: Schema.String
+}).annotate({ identifier: "MailboxThreadSummary" });
+const MailboxThreadState = /* @__PURE__ */ Schema.Struct({
+	id: MailboxThreadId,
+	folder: MailboxThreadFolder,
+	priority: MailboxThreadPriority,
+	labels: Schema.Array(MailboxLabelId),
+	read: Schema.Boolean,
+	starred: Schema.Boolean,
+	snoozedUntil: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxThreadState" });
+const MailboxThread = /* @__PURE__ */ Schema.Struct({
+	id: MailboxThreadId,
+	channel: MailboxChannel,
+	endpointId: Schema.Union([MailboxEndpointId, Schema.Null]),
+	subject: Schema.Union([Schema.String, Schema.Null]),
+	preview: Schema.Union([Schema.String, Schema.Null]),
+	from: Schema.Union([MailboxThreadSender, Schema.Null]),
+	messageCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	hasAttachments: Schema.Boolean,
+	hasDraft: Schema.Boolean,
+	folder: MailboxThreadFolder,
+	priority: MailboxThreadPriority,
+	labels: Schema.Array(MailboxLabelId),
+	read: Schema.Boolean,
+	starred: Schema.Boolean,
+	snoozedUntil: Schema.Union([Schema.String, Schema.Null]),
+	lastActivityAt: Schema.String,
+	conversationId: ConversationId,
+	participants: Schema.Array(MailboxThreadParticipant),
+	createdAt: Schema.String
+}).annotate({ identifier: "MailboxThread" });
+const MailboxNote = /* @__PURE__ */ Schema.Struct({
+	id: MailboxNoteId,
+	author: Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}),
+	body: Schema.String,
+	color: Schema.Union([Schema.String, Schema.Null]),
+	pinned: Schema.Boolean,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "MailboxNote" });
+const MailboxSendSnapshot = /* @__PURE__ */ Schema.Struct({
+	channel: Schema.Literal("email"),
+	draftRevision: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThan(0).annotate({ expected: "a value greater than 0" })),
+	from: Schema.String,
+	fromName: Schema.Union([Schema.String, Schema.Null]),
+	to: Schema.TupleWithRest(Schema.Tuple([Schema.String]), [Schema.String]),
+	cc: Schema.Array(Schema.String),
+	bcc: Schema.Array(Schema.String),
+	replyTo: Schema.Array(Schema.String),
+	subject: Schema.String,
+	text: Schema.Union([Schema.String, Schema.Null]),
+	html: Schema.Union([Schema.String, Schema.Null]),
+	attachments: Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" })),
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	conversationId: Schema.Union([ConversationId, Schema.Null]),
+	inReplyToMessageId: Schema.Union([MessageId, Schema.Null])
+}).annotate({ identifier: "MailboxSendSnapshot" });
+const MailboxDraft = /* @__PURE__ */ Schema.Struct({
+	id: MailboxDraftId,
+	channel: Schema.Literal("email"),
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	inReplyToMessageId: Schema.Union([MessageId, Schema.Null]),
+	state: MailboxDraftState,
+	lockedByActionId: Schema.Union([MailboxActionId, Schema.Null]),
+	to: Schema.Array(Schema.String),
+	subject: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	endpointId: Schema.Union([MailboxEndpointId, Schema.Null]),
+	cc: Schema.Array(Schema.String),
+	bcc: Schema.Array(Schema.String),
+	replyTo: Schema.Array(Schema.String),
+	html: Schema.Union([Schema.String, Schema.Null]),
+	text: Schema.Union([Schema.String, Schema.Null]),
+	attachments: Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" }))
+}).annotate({ identifier: "MailboxDraft" });
+const MailboxPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxSummary),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxPage" });
+const Mailbox = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	namespaceId: Schema.Union([NamespaceId, Schema.Null]),
+	slug: Schema.String,
+	name: Schema.String,
+	status: MailboxStatus,
+	primaryAddress: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	description: Schema.Union([Schema.String, Schema.Null]),
+	metadata: MailboxMetadata,
+	endpoints: Schema.Array(MailboxEndpoint),
+	updatedAt: Schema.String
+}).annotate({ identifier: "Mailbox" });
+const MailboxQuarantinePage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxQuarantinedMessage),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxQuarantinePage" });
+const MailboxNonSendAction = /* @__PURE__ */ Schema.Struct({
+	id: MailboxActionId,
+	source: Schema.Union([
+		Schema.Literal("humanUi"),
+		Schema.Literal("externalApi"),
+		Schema.Literal("aiSdkTool"),
+		Schema.Literal("extension"),
+		Schema.Literal("externalAgent"),
+		Schema.Literal("samvaManagedAgent"),
+		Schema.Literal("system")
+	]),
+	proposedBy: Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}),
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	draftId: Schema.Union([MailboxDraftId, Schema.Null]),
+	decision: Schema.Union([MailboxActionDecision, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	type: Schema.Union([
+		Schema.Literal("updateDraft"),
+		Schema.Literal("createNote"),
+		Schema.Literal("assignThread"),
+		Schema.Literal("changeThreadState"),
+		Schema.Literal("call"),
+		Schema.Literal("extensionRequest")
+	]),
+	state: Schema.Union([
+		Schema.Literal("proposed"),
+		Schema.Literal("allowed"),
+		Schema.Literal("approvalRequired"),
+		Schema.Literal("policyDenied"),
+		Schema.Literal("approved"),
+		Schema.Literal("approvalDenied"),
+		Schema.Literal("executing"),
+		Schema.Literal("executed"),
+		Schema.Literal("failed")
+	])
+}).annotate({ identifier: "MailboxNonSendAction" });
+const MailboxPendingSendReceipt = /* @__PURE__ */ Schema.Struct({
+	actionId: MailboxActionId,
+	draftId: Schema.Union([MailboxDraftId, Schema.Null]),
+	messageId: Schema.Union([MessageId, Schema.Null]),
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	state: Schema.Union([
+		Schema.Literal("approvalRequired"),
+		Schema.Literal("queued"),
+		Schema.Literal("accepted"),
+		Schema.Literal("completed"),
+		Schema.Literal("notSent"),
+		Schema.Literal("uncertain")
+	]),
+	acceptedAt: Schema.Union([Schema.String, Schema.Null]),
+	waitReason: Schema.Union([Schema.Union([
+		Schema.Literal("rate"),
+		Schema.Literal("daily-quota"),
+		Schema.Literal("domain-health"),
+		Schema.Literal("sending-paused"),
+		Schema.Literal("upstream-unavailable"),
+		Schema.Literal("retry"),
+		Schema.Literal("campaign-paused"),
+		Schema.Literal("domain-warming"),
+		Schema.Literal("onboarding-review"),
+		Schema.Literal("content-review"),
+		Schema.Literal("screening-unavailable")
+	]), Schema.Null]),
+	reviewExpectedAt: Schema.Union([Schema.String, Schema.Null]),
+	skippedRecipients: Schema.Array(SkippedRecipient),
+	executeUntil: Schema.Union([Schema.String, Schema.Null]),
+	retryAt: Schema.Union([Schema.String, Schema.Null]),
+	problem: Schema.Union([MailboxSendOutcome, Schema.Null]),
+	retryEligible: Schema.Boolean,
+	decision: Schema.Union([MailboxActionDecision, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "MailboxPendingSendReceipt" });
+const MailboxDraftPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxDraftSummary),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxDraftPage" });
+const MailboxEventPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxEvent),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxEventPage" });
+const MailboxFolderCountList = /* @__PURE__ */ Schema.Struct({ items: Schema.Array(MailboxFolderCount) }).annotate({ identifier: "MailboxFolderCountList" });
+const MailboxGrantPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxGrant),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxGrantPage" });
+const MailboxLabelList = /* @__PURE__ */ Schema.Struct({ items: Schema.Array(MailboxLabel) }).annotate({ identifier: "MailboxLabelList" });
+const MailboxMessagePage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxMessageSummary),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxMessagePage" });
+const MailboxThreadContentPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxMessage),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxThreadContentPage" });
+const MailboxPolicyList = /* @__PURE__ */ Schema.Struct({ items: Schema.Array(MailboxPolicy) }).annotate({ identifier: "MailboxPolicyList" });
+const MailboxThreadPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxThreadSummary),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxThreadPage" });
+const MailboxNotePage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxNote),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxNotePage" });
+const MailboxSendAction = /* @__PURE__ */ Schema.Struct({
+	id: MailboxActionId,
+	source: Schema.Union([
+		Schema.Literal("humanUi"),
+		Schema.Literal("externalApi"),
+		Schema.Literal("aiSdkTool"),
+		Schema.Literal("extension"),
+		Schema.Literal("externalAgent"),
+		Schema.Literal("samvaManagedAgent"),
+		Schema.Literal("system")
+	]),
+	proposedBy: Schema.Struct({
+		kind: Schema.Union([
+			Schema.Literal("user"),
+			Schema.Literal("apiKey"),
+			Schema.Literal("extension"),
+			Schema.Literal("externalAgent"),
+			Schema.Literal("samvaAgent"),
+			Schema.Literal("system")
+		]),
+		id: Schema.String,
+		displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+	}),
+	threadId: Schema.Union([MailboxThreadId, Schema.Null]),
+	draftId: Schema.Union([MailboxDraftId, Schema.Null]),
+	decision: Schema.Union([MailboxActionDecision, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	type: Schema.Union([Schema.Literal("sendMessage"), Schema.Literal("reply")]),
+	state: Schema.Union([
+		Schema.Literal("approvalRequired"),
+		Schema.Literal("queued"),
+		Schema.Literal("accepted"),
+		Schema.Literal("completed"),
+		Schema.Literal("notSent"),
+		Schema.Literal("uncertain")
+	]),
+	send: MailboxSendReceipt,
+	intent: Schema.Union([MailboxSendSnapshot, Schema.Null])
+}).annotate({ identifier: "MailboxSendAction" });
+const MailboxAction = /* @__PURE__ */ Schema.Union([MailboxSendAction, MailboxNonSendAction]).annotate({ identifier: "MailboxAction" });
+const MailboxPendingAction = /* @__PURE__ */ Schema.Union([MailboxSendAction, MailboxNonSendAction]).annotate({ identifier: "MailboxPendingAction" });
+const MailboxActionPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(MailboxAction),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "MailboxActionPage" });
+const MailboxesListQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const MailboxesList200 = MailboxPage;
+const MailboxesList401 = UnauthorizedError;
+const MailboxesList403 = ForbiddenError;
+const MailboxesList422 = ValidationError;
+const MailboxesList500 = InternalError;
+const MailboxesList504 = GatewayTimeoutError;
+const MailboxesCreateRequestJson = /* @__PURE__ */ Schema.Struct({
+	namespaceId: Schema.optionalKey(Schema.Union([NamespaceId, Schema.Null])),
+	endpoint: CreateMailboxEndpointPayload,
+	name: Schema.String,
+	slug: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	metadata: Schema.optionalKey(Schema.Union([MailboxMetadata, Schema.Null]))
+});
+const MailboxesCreate201 = Mailbox;
+const MailboxesCreate401 = UnauthorizedError;
+const MailboxesCreate402 = PaymentRequiredError;
+const MailboxesCreate403 = ForbiddenError;
+const MailboxesCreate404 = ResourceNotFoundError;
+const MailboxesCreate409 = ConflictError;
+const MailboxesCreate422 = /* @__PURE__ */ Schema.Union([ValidationError, MailboxChannelUnsupportedError]);
+const MailboxesCreate500 = InternalError;
+const MailboxesCreate502 = BillingProviderError;
+const MailboxesCreate504 = GatewayTimeoutError;
+const MailboxesGetPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesGet200 = Mailbox;
+const MailboxesGet401 = UnauthorizedError;
+const MailboxesGet403 = ForbiddenError;
+const MailboxesGet404 = ResourceNotFoundError;
+const MailboxesGet422 = ValidationError;
+const MailboxesGet500 = InternalError;
+const MailboxesGet504 = GatewayTimeoutError;
+const MailboxesRemovePathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesRemove200 = SuccessResponse;
+const MailboxesRemove401 = UnauthorizedError;
+const MailboxesRemove403 = ForbiddenError;
+const MailboxesRemove404 = ResourceNotFoundError;
+const MailboxesRemove422 = ValidationError;
+const MailboxesRemove500 = InternalError;
+const MailboxesRemove502 = BillingProviderError;
+const MailboxesRemove504 = GatewayTimeoutError;
+const MailboxesUpdatePathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesUpdateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })), Schema.Null])),
+	metadata: Schema.optionalKey(Schema.Union([MailboxMetadataPatch, Schema.Null]))
+});
+const MailboxesUpdate200 = Mailbox;
+const MailboxesUpdate401 = UnauthorizedError;
+const MailboxesUpdate403 = ForbiddenError;
+const MailboxesUpdate404 = ResourceNotFoundError;
+const MailboxesUpdate422 = ValidationError;
+const MailboxesUpdate500 = InternalError;
+const MailboxesUpdate504 = GatewayTimeoutError;
+const MailboxesListActionsPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListActionsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	threadId: Schema.optionalKey(Schema.Union([MailboxThreadId, Schema.Null])),
+	state: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("proposed"),
+		Schema.Literal("allowed"),
+		Schema.Literal("approvalRequired"),
+		Schema.Literal("policyDenied"),
+		Schema.Literal("approved"),
+		Schema.Literal("approvalDenied"),
+		Schema.Literal("executing"),
+		Schema.Literal("executed"),
+		Schema.Literal("failed"),
+		Schema.Literal("queued"),
+		Schema.Literal("accepted"),
+		Schema.Literal("completed"),
+		Schema.Literal("notSent"),
+		Schema.Literal("uncertain")
+	]), Schema.Null])),
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const MailboxesListActions200 = MailboxActionPage;
+const MailboxesListActions401 = UnauthorizedError;
+const MailboxesListActions403 = ForbiddenError;
+const MailboxesListActions404 = ResourceNotFoundError;
+const MailboxesListActions422 = ValidationError;
+const MailboxesListActions500 = InternalError;
+const MailboxesListActions504 = GatewayTimeoutError;
+const MailboxesGetActionPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	actionId: MailboxActionId
+});
+const MailboxesGetAction200 = MailboxAction;
+const MailboxesGetAction401 = UnauthorizedError;
+const MailboxesGetAction403 = ForbiddenError;
+const MailboxesGetAction404 = ResourceNotFoundError;
+const MailboxesGetAction422 = ValidationError;
+const MailboxesGetAction500 = InternalError;
+const MailboxesGetAction504 = GatewayTimeoutError;
+const MailboxesApproveActionPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	actionId: MailboxActionId
+});
+const MailboxesApproveAction200 = MailboxAction;
+const MailboxesApproveAction202 = MailboxPendingAction;
+const MailboxesApproveAction401 = UnauthorizedError;
+const MailboxesApproveAction402 = PaymentRequiredError;
+const MailboxesApproveAction403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesApproveAction404 = ResourceNotFoundError;
+const MailboxesApproveAction409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesApproveAction422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesApproveAction429 = RateLimitedError;
+const MailboxesApproveAction500 = InternalError;
+const MailboxesApproveAction502 = BillingProviderError;
+const MailboxesApproveAction503 = SenderNotReadyError;
+const MailboxesApproveAction504 = GatewayTimeoutError;
+const MailboxesCancelActionPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	actionId: MailboxActionId
+});
+const MailboxesCancelAction200 = MailboxSendReceipt;
+const MailboxesCancelAction202 = MailboxPendingSendReceipt;
+const MailboxesCancelAction401 = UnauthorizedError;
+const MailboxesCancelAction402 = PaymentRequiredError;
+const MailboxesCancelAction403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesCancelAction404 = ResourceNotFoundError;
+const MailboxesCancelAction409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesCancelAction422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesCancelAction429 = RateLimitedError;
+const MailboxesCancelAction500 = InternalError;
+const MailboxesCancelAction502 = BillingProviderError;
+const MailboxesCancelAction503 = SenderNotReadyError;
+const MailboxesCancelAction504 = GatewayTimeoutError;
+const MailboxesDenyActionPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	actionId: MailboxActionId
+});
+const MailboxesDenyActionRequestJson = /* @__PURE__ */ Schema.Struct({ reason: Schema.String });
+const MailboxesDenyAction200 = MailboxAction;
+const MailboxesDenyAction401 = UnauthorizedError;
+const MailboxesDenyAction403 = ForbiddenError;
+const MailboxesDenyAction404 = ResourceNotFoundError;
+const MailboxesDenyAction409 = /* @__PURE__ */ Schema.Union([ConflictError, MailboxSendConflictError]);
+const MailboxesDenyAction422 = ValidationError;
+const MailboxesDenyAction500 = InternalError;
+const MailboxesDenyAction504 = GatewayTimeoutError;
+const MailboxesRetryActionPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	actionId: MailboxActionId
+});
+const MailboxesRetryAction200 = MailboxSendReceipt;
+const MailboxesRetryAction202 = MailboxPendingSendReceipt;
+const MailboxesRetryAction401 = UnauthorizedError;
+const MailboxesRetryAction402 = PaymentRequiredError;
+const MailboxesRetryAction403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesRetryAction404 = ResourceNotFoundError;
+const MailboxesRetryAction409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesRetryAction422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesRetryAction429 = RateLimitedError;
+const MailboxesRetryAction500 = InternalError;
+const MailboxesRetryAction502 = BillingProviderError;
+const MailboxesRetryAction503 = SenderNotReadyError;
+const MailboxesRetryAction504 = GatewayTimeoutError;
+const MailboxesGetAgentActivityPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesGetAgentActivityQuery = /* @__PURE__ */ Schema.Struct({
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const MailboxesGetAgentActivity200 = MailboxAgentActivity;
+const MailboxesGetAgentActivity401 = UnauthorizedError;
+const MailboxesGetAgentActivity403 = ForbiddenError;
+const MailboxesGetAgentActivity404 = ResourceNotFoundError;
+const MailboxesGetAgentActivity422 = ValidationError;
+const MailboxesGetAgentActivity500 = InternalError;
+const MailboxesGetAgentActivity504 = GatewayTimeoutError;
+const MailboxesListDraftsPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListDraftsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	threadId: Schema.optionalKey(Schema.Union([MailboxThreadId, Schema.Null]))
+});
+const MailboxesListDrafts200 = MailboxDraftPage;
+const MailboxesListDrafts401 = UnauthorizedError;
+const MailboxesListDrafts403 = ForbiddenError;
+const MailboxesListDrafts404 = ResourceNotFoundError;
+const MailboxesListDrafts422 = ValidationError;
+const MailboxesListDrafts500 = InternalError;
+const MailboxesListDrafts504 = GatewayTimeoutError;
+const MailboxesCreateDraftPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesCreateDraftRequestJson = /* @__PURE__ */ Schema.Struct({
+	channel: Schema.optionalKey(Schema.Union([Schema.Literal("email"), Schema.Null])),
+	endpointId: Schema.optionalKey(Schema.Union([MailboxEndpointId, Schema.Null])),
+	to: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	cc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	bcc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	replyTo: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	subject: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	text: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	html: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	attachments: Schema.optionalKey(Schema.Union([Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" })), Schema.Null])),
+	inReplyToMessageId: Schema.optionalKey(Schema.Union([MessageId, Schema.Null]))
+});
+const MailboxesCreateDraft201 = MailboxDraft;
+const MailboxesCreateDraft401 = UnauthorizedError;
+const MailboxesCreateDraft403 = ForbiddenError;
+const MailboxesCreateDraft404 = ResourceNotFoundError;
+const MailboxesCreateDraft422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesCreateDraft500 = InternalError;
+const MailboxesCreateDraft504 = GatewayTimeoutError;
+const MailboxesGetDraftPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	draftId: MailboxDraftId
+});
+const MailboxesGetDraft200 = MailboxDraft;
+const MailboxesGetDraft401 = UnauthorizedError;
+const MailboxesGetDraft403 = ForbiddenError;
+const MailboxesGetDraft404 = ResourceNotFoundError;
+const MailboxesGetDraft422 = ValidationError;
+const MailboxesGetDraft500 = InternalError;
+const MailboxesGetDraft504 = GatewayTimeoutError;
+const MailboxesDeleteDraftPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	draftId: MailboxDraftId
+});
+const MailboxesDeleteDraft200 = SuccessResponse;
+const MailboxesDeleteDraft401 = UnauthorizedError;
+const MailboxesDeleteDraft403 = ForbiddenError;
+const MailboxesDeleteDraft404 = ResourceNotFoundError;
+const MailboxesDeleteDraft422 = ValidationError;
+const MailboxesDeleteDraft500 = InternalError;
+const MailboxesDeleteDraft504 = GatewayTimeoutError;
+const MailboxesUpdateDraftPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	draftId: MailboxDraftId
+});
+const MailboxesUpdateDraftRequestJson = /* @__PURE__ */ Schema.Struct({
+	to: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	cc: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Array(Schema.String), Schema.Null]), Schema.Null])),
+	bcc: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Array(Schema.String), Schema.Null]), Schema.Null])),
+	replyTo: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Array(Schema.String), Schema.Null]), Schema.Null])),
+	subject: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	text: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	html: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	attachments: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" })), Schema.Null]), Schema.Null]))
+});
+const MailboxesUpdateDraft200 = MailboxDraft;
+const MailboxesUpdateDraft401 = UnauthorizedError;
+const MailboxesUpdateDraft403 = ForbiddenError;
+const MailboxesUpdateDraft404 = ResourceNotFoundError;
+const MailboxesUpdateDraft409 = ConflictError;
+const MailboxesUpdateDraft422 = ValidationError;
+const MailboxesUpdateDraft500 = InternalError;
+const MailboxesUpdateDraft504 = GatewayTimeoutError;
+const MailboxesSendDraftPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	draftId: MailboxDraftId
+});
+const MailboxesSendDraftHeaders = /* @__PURE__ */ Schema.Struct({ "idempotency-key": Schema.optionalKey(Schema.Union([Schema.String.annotate({ description: "Optional key that makes a mailbox send idempotent for the calling key or member. Repeating the request with the same key and body returns the original action in its current state. Keep the key after a lost response. Reusing it with different content returns 409. Active actions retain their key; terminal receipts remain replayable for 24 hours." }).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[\\s\\S]{1,255}$")).annotate({ expected: "a string matching the RegExp ^[\\s\\S]{1,255}$" })), Schema.Null])) });
+const MailboxesSendDraft200 = MailboxSendReceipt;
+const MailboxesSendDraft202 = MailboxPendingSendReceipt;
+const MailboxesSendDraft401 = UnauthorizedError;
+const MailboxesSendDraft402 = PaymentRequiredError;
+const MailboxesSendDraft403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesSendDraft404 = ResourceNotFoundError;
+const MailboxesSendDraft409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesSendDraft422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesSendDraft429 = RateLimitedError;
+const MailboxesSendDraft500 = InternalError;
+const MailboxesSendDraft502 = BillingProviderError;
+const MailboxesSendDraft503 = SenderNotReadyError;
+const MailboxesSendDraft504 = GatewayTimeoutError;
+const MailboxesCreateEndpointPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesCreateEndpointRequestJson = /* @__PURE__ */ Schema.Struct({
+	channel: MailboxChannel,
+	address: Schema.String,
+	displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const MailboxesCreateEndpoint201 = Mailbox;
+const MailboxesCreateEndpoint401 = UnauthorizedError;
+const MailboxesCreateEndpoint403 = ForbiddenError;
+const MailboxesCreateEndpoint404 = ResourceNotFoundError;
+const MailboxesCreateEndpoint409 = ConflictError;
+const MailboxesCreateEndpoint422 = /* @__PURE__ */ Schema.Union([ValidationError, MailboxChannelUnsupportedError]);
+const MailboxesCreateEndpoint500 = InternalError;
+const MailboxesCreateEndpoint504 = GatewayTimeoutError;
+const MailboxesRemoveEndpointPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	endpointId: MailboxEndpointId
+});
+const MailboxesRemoveEndpoint200 = Mailbox;
+const MailboxesRemoveEndpoint401 = UnauthorizedError;
+const MailboxesRemoveEndpoint403 = ForbiddenError;
+const MailboxesRemoveEndpoint404 = ResourceNotFoundError;
+const MailboxesRemoveEndpoint422 = ValidationError;
+const MailboxesRemoveEndpoint500 = InternalError;
+const MailboxesRemoveEndpoint504 = GatewayTimeoutError;
+const MailboxesUpdateEndpointPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	endpointId: MailboxEndpointId
+});
+const MailboxesUpdateEndpointRequestJson = /* @__PURE__ */ Schema.Struct({
+	displayName: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	default: Schema.optionalKey(Schema.Union([Schema.Literal(true), Schema.Null]))
+});
+const MailboxesUpdateEndpoint200 = Mailbox;
+const MailboxesUpdateEndpoint401 = UnauthorizedError;
+const MailboxesUpdateEndpoint403 = ForbiddenError;
+const MailboxesUpdateEndpoint404 = ResourceNotFoundError;
+const MailboxesUpdateEndpoint422 = ValidationError;
+const MailboxesUpdateEndpoint500 = InternalError;
+const MailboxesUpdateEndpoint504 = GatewayTimeoutError;
+const MailboxesListEventsPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListEventsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const MailboxesListEvents200 = MailboxEventPage;
+const MailboxesListEvents401 = UnauthorizedError;
+const MailboxesListEvents403 = ForbiddenError;
+const MailboxesListEvents404 = ResourceNotFoundError;
+const MailboxesListEvents422 = ValidationError;
+const MailboxesListEvents500 = InternalError;
+const MailboxesListEvents504 = GatewayTimeoutError;
+const MailboxesListFoldersPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListFolders200 = MailboxFolderCountList;
+const MailboxesListFolders401 = UnauthorizedError;
+const MailboxesListFolders403 = ForbiddenError;
+const MailboxesListFolders404 = ResourceNotFoundError;
+const MailboxesListFolders422 = ValidationError;
+const MailboxesListFolders500 = InternalError;
+const MailboxesListFolders504 = GatewayTimeoutError;
+const MailboxesListGrantsPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListGrantsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const MailboxesListGrants200 = MailboxGrantPage;
+const MailboxesListGrants401 = UnauthorizedError;
+const MailboxesListGrants403 = ForbiddenError;
+const MailboxesListGrants404 = ResourceNotFoundError;
+const MailboxesListGrants422 = ValidationError;
+const MailboxesListGrants500 = InternalError;
+const MailboxesListGrants504 = GatewayTimeoutError;
+const MailboxesCreateGrantPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesCreateGrantRequestJson = /* @__PURE__ */ Schema.Struct({
+	userId: UserId,
+	role: MailboxGrantRole,
+	sendMode: Schema.optionalKey(Schema.Union([MailboxSendMode, Schema.Null]))
+});
+const MailboxesCreateGrant201 = MailboxGrant;
+const MailboxesCreateGrant401 = UnauthorizedError;
+const MailboxesCreateGrant403 = ForbiddenError;
+const MailboxesCreateGrant404 = ResourceNotFoundError;
+const MailboxesCreateGrant409 = ConflictError;
+const MailboxesCreateGrant422 = ValidationError;
+const MailboxesCreateGrant500 = InternalError;
+const MailboxesCreateGrant504 = GatewayTimeoutError;
+const MailboxesRevokeGrantPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	grantId: MailboxGrantId
+});
+const MailboxesRevokeGrant200 = SuccessResponse;
+const MailboxesRevokeGrant401 = UnauthorizedError;
+const MailboxesRevokeGrant403 = ForbiddenError;
+const MailboxesRevokeGrant404 = ResourceNotFoundError;
+const MailboxesRevokeGrant409 = ConflictError;
+const MailboxesRevokeGrant422 = ValidationError;
+const MailboxesRevokeGrant500 = InternalError;
+const MailboxesRevokeGrant504 = GatewayTimeoutError;
+const MailboxesUpdateGrantPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	grantId: MailboxGrantId
+});
+const MailboxesUpdateGrantRequestJson = /* @__PURE__ */ Schema.Struct({
+	role: Schema.optionalKey(Schema.Union([MailboxGrantRole, Schema.Null])),
+	sendMode: Schema.optionalKey(Schema.Union([MailboxSendMode, Schema.Null]))
+});
+const MailboxesUpdateGrant200 = MailboxGrant;
+const MailboxesUpdateGrant401 = UnauthorizedError;
+const MailboxesUpdateGrant403 = ForbiddenError;
+const MailboxesUpdateGrant404 = ResourceNotFoundError;
+const MailboxesUpdateGrant409 = ConflictError;
+const MailboxesUpdateGrant422 = ValidationError;
+const MailboxesUpdateGrant500 = InternalError;
+const MailboxesUpdateGrant504 = GatewayTimeoutError;
+const MailboxesListLabelsPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListLabels200 = MailboxLabelList;
+const MailboxesListLabels401 = UnauthorizedError;
+const MailboxesListLabels403 = ForbiddenError;
+const MailboxesListLabels404 = ResourceNotFoundError;
+const MailboxesListLabels422 = ValidationError;
+const MailboxesListLabels500 = InternalError;
+const MailboxesListLabels504 = GatewayTimeoutError;
+const MailboxesCreateLabelPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesCreateLabelRequestJson = /* @__PURE__ */ Schema.Struct({
+	slug: Schema.String,
+	displayName: Schema.String,
+	color: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Union([
+		Schema.Literal("billing"),
+		Schema.Literal("domain"),
+		Schema.Literal("agent"),
+		Schema.Literal("routing"),
+		Schema.Literal("important"),
+		Schema.Literal("neutral")
+	]), Schema.Null]), Schema.Null]))
+});
+const MailboxesCreateLabel201 = MailboxLabel;
+const MailboxesCreateLabel401 = UnauthorizedError;
+const MailboxesCreateLabel403 = ForbiddenError;
+const MailboxesCreateLabel404 = ResourceNotFoundError;
+const MailboxesCreateLabel409 = ConflictError;
+const MailboxesCreateLabel422 = ValidationError;
+const MailboxesCreateLabel500 = InternalError;
+const MailboxesCreateLabel504 = GatewayTimeoutError;
+const MailboxesDeleteLabelPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	labelId: MailboxLabelId
+});
+const MailboxesDeleteLabel200 = SuccessResponse;
+const MailboxesDeleteLabel401 = UnauthorizedError;
+const MailboxesDeleteLabel403 = ForbiddenError;
+const MailboxesDeleteLabel404 = ResourceNotFoundError;
+const MailboxesDeleteLabel422 = ValidationError;
+const MailboxesDeleteLabel500 = InternalError;
+const MailboxesDeleteLabel504 = GatewayTimeoutError;
+const MailboxesUpdateLabelPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	labelId: MailboxLabelId
+});
+const MailboxesUpdateLabelRequestJson = /* @__PURE__ */ Schema.Struct({
+	displayName: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	color: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Union([
+		Schema.Literal("billing"),
+		Schema.Literal("domain"),
+		Schema.Literal("agent"),
+		Schema.Literal("routing"),
+		Schema.Literal("important"),
+		Schema.Literal("neutral")
+	]), Schema.Null]), Schema.Null]))
+});
+const MailboxesUpdateLabel200 = MailboxLabel;
+const MailboxesUpdateLabel401 = UnauthorizedError;
+const MailboxesUpdateLabel403 = ForbiddenError;
+const MailboxesUpdateLabel404 = ResourceNotFoundError;
+const MailboxesUpdateLabel422 = ValidationError;
+const MailboxesUpdateLabel500 = InternalError;
+const MailboxesUpdateLabel504 = GatewayTimeoutError;
+const MailboxesSendMessagePathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesSendMessageHeaders = /* @__PURE__ */ Schema.Struct({ "idempotency-key": Schema.optionalKey(Schema.Union([Schema.String.annotate({ description: "Optional key that makes a mailbox send idempotent for the calling key or member. Repeating the request with the same key and body returns the original action in its current state. Keep the key after a lost response. Reusing it with different content returns 409. Active actions retain their key; terminal receipts remain replayable for 24 hours." }).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[\\s\\S]{1,255}$")).annotate({ expected: "a string matching the RegExp ^[\\s\\S]{1,255}$" })), Schema.Null])) });
+const MailboxesSendMessageRequestJson = /* @__PURE__ */ Schema.Struct({
+	channel: Schema.optionalKey(Schema.Union([Schema.Literal("email"), Schema.Null])),
+	to: Schema.TupleWithRest(Schema.Tuple([Schema.String]), [Schema.String]),
+	cc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	bcc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	replyTo: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	subject: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+	text: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	html: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	attachments: Schema.optionalKey(Schema.Union([Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" })), Schema.Null]))
+});
+const MailboxesSendMessage200 = MailboxSendReceipt;
+const MailboxesSendMessage202 = MailboxPendingSendReceipt;
+const MailboxesSendMessage401 = UnauthorizedError;
+const MailboxesSendMessage402 = PaymentRequiredError;
+const MailboxesSendMessage403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesSendMessage404 = ResourceNotFoundError;
+const MailboxesSendMessage409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesSendMessage422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesSendMessage429 = RateLimitedError;
+const MailboxesSendMessage500 = InternalError;
+const MailboxesSendMessage502 = BillingProviderError;
+const MailboxesSendMessage503 = SenderNotReadyError;
+const MailboxesSendMessage504 = GatewayTimeoutError;
+const MailboxesGetMessagePathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId
+});
+const MailboxesGetMessage200 = MailboxMessage;
+const MailboxesGetMessage401 = UnauthorizedError;
+const MailboxesGetMessage403 = ForbiddenError;
+const MailboxesGetMessage404 = ResourceNotFoundError;
+const MailboxesGetMessage422 = ValidationError;
+const MailboxesGetMessage500 = InternalError;
+const MailboxesGetMessage504 = GatewayTimeoutError;
+const MailboxesGetMessageAttachmentPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId,
+	attachmentId: AttachmentId
+});
+const MailboxesGetMessageAttachment200 = MailboxDownloadUrl;
+const MailboxesGetMessageAttachment401 = UnauthorizedError;
+const MailboxesGetMessageAttachment403 = ForbiddenError;
+const MailboxesGetMessageAttachment404 = ResourceNotFoundError;
+const MailboxesGetMessageAttachment422 = ValidationError;
+const MailboxesGetMessageAttachment500 = InternalError;
+const MailboxesGetMessageAttachment504 = GatewayTimeoutError;
+const MailboxesCopyMessageAttachmentPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId,
+	attachmentId: AttachmentId
+});
+const MailboxesCopyMessageAttachment201 = MailboxCopiedAttachment;
+const MailboxesCopyMessageAttachment401 = UnauthorizedError;
+const MailboxesCopyMessageAttachment403 = ForbiddenError;
+const MailboxesCopyMessageAttachment404 = ResourceNotFoundError;
+const MailboxesCopyMessageAttachment409 = ConflictError;
+const MailboxesCopyMessageAttachment422 = ValidationError;
+const MailboxesCopyMessageAttachment500 = InternalError;
+const MailboxesCopyMessageAttachment504 = GatewayTimeoutError;
+const MailboxesDiscardMessagePathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId
+});
+const MailboxesDiscardMessage200 = MailboxQuarantinedMessage;
+const MailboxesDiscardMessage401 = UnauthorizedError;
+const MailboxesDiscardMessage403 = ForbiddenError;
+const MailboxesDiscardMessage404 = ResourceNotFoundError;
+const MailboxesDiscardMessage409 = ConflictError;
+const MailboxesDiscardMessage422 = ValidationError;
+const MailboxesDiscardMessage500 = InternalError;
+const MailboxesDiscardMessage502 = BillingProviderError;
+const MailboxesDiscardMessage504 = GatewayTimeoutError;
+const MailboxesForwardPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId
+});
+const MailboxesForwardHeaders = /* @__PURE__ */ Schema.Struct({ "idempotency-key": Schema.optionalKey(Schema.Union([Schema.String.annotate({ description: "Optional key that makes a mailbox send idempotent for the calling key or member. Repeating the request with the same key and body returns the original action in its current state. Keep the key after a lost response. Reusing it with different content returns 409. Active actions retain their key; terminal receipts remain replayable for 24 hours." }).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[\\s\\S]{1,255}$")).annotate({ expected: "a string matching the RegExp ^[\\s\\S]{1,255}$" })), Schema.Null])) });
+const MailboxesForwardRequestJson = /* @__PURE__ */ Schema.Struct({
+	to: Schema.TupleWithRest(Schema.Tuple([Schema.String]), [Schema.String]),
+	cc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	bcc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	text: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	html: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	attachments: Schema.optionalKey(Schema.Union([Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" })), Schema.Null]))
+});
+const MailboxesForward200 = MailboxSendReceipt;
+const MailboxesForward202 = MailboxPendingSendReceipt;
+const MailboxesForward401 = UnauthorizedError;
+const MailboxesForward402 = PaymentRequiredError;
+const MailboxesForward403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesForward404 = ResourceNotFoundError;
+const MailboxesForward409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesForward422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesForward429 = RateLimitedError;
+const MailboxesForward500 = InternalError;
+const MailboxesForward502 = BillingProviderError;
+const MailboxesForward503 = SenderNotReadyError;
+const MailboxesForward504 = GatewayTimeoutError;
+const MailboxesGetMessageRawPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId
+});
+const MailboxesGetMessageRaw200 = MailboxDownloadUrl;
+const MailboxesGetMessageRaw401 = UnauthorizedError;
+const MailboxesGetMessageRaw403 = ForbiddenError;
+const MailboxesGetMessageRaw404 = ResourceNotFoundError;
+const MailboxesGetMessageRaw422 = ValidationError;
+const MailboxesGetMessageRaw500 = InternalError;
+const MailboxesGetMessageRaw504 = GatewayTimeoutError;
+const MailboxesReleaseMessagePathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId
+});
+const MailboxesReleaseMessage200 = MailboxQuarantinedMessage;
+const MailboxesReleaseMessage401 = UnauthorizedError;
+const MailboxesReleaseMessage403 = ForbiddenError;
+const MailboxesReleaseMessage404 = ResourceNotFoundError;
+const MailboxesReleaseMessage409 = ConflictError;
+const MailboxesReleaseMessage422 = ValidationError;
+const MailboxesReleaseMessage500 = InternalError;
+const MailboxesReleaseMessage504 = GatewayTimeoutError;
+const MailboxesReplyPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId
+});
+const MailboxesReplyHeaders = /* @__PURE__ */ Schema.Struct({ "idempotency-key": Schema.optionalKey(Schema.Union([Schema.String.annotate({ description: "Optional key that makes a mailbox send idempotent for the calling key or member. Repeating the request with the same key and body returns the original action in its current state. Keep the key after a lost response. Reusing it with different content returns 409. Active actions retain their key; terminal receipts remain replayable for 24 hours." }).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[\\s\\S]{1,255}$")).annotate({ expected: "a string matching the RegExp ^[\\s\\S]{1,255}$" })), Schema.Null])) });
+const MailboxesReplyRequestJson = /* @__PURE__ */ Schema.Struct({
+	channel: Schema.optionalKey(Schema.Union([Schema.Literal("email"), Schema.Null])),
+	cc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	bcc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	text: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	html: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	attachments: Schema.optionalKey(Schema.Union([Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" })), Schema.Null]))
+});
+const MailboxesReply200 = MailboxSendReceipt;
+const MailboxesReply202 = MailboxPendingSendReceipt;
+const MailboxesReply401 = UnauthorizedError;
+const MailboxesReply402 = PaymentRequiredError;
+const MailboxesReply403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesReply404 = ResourceNotFoundError;
+const MailboxesReply409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesReply422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesReply429 = RateLimitedError;
+const MailboxesReply500 = InternalError;
+const MailboxesReply502 = BillingProviderError;
+const MailboxesReply503 = SenderNotReadyError;
+const MailboxesReply504 = GatewayTimeoutError;
+const MailboxesReplyAllPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	messageId: MessageId
+});
+const MailboxesReplyAllHeaders = /* @__PURE__ */ Schema.Struct({ "idempotency-key": Schema.optionalKey(Schema.Union([Schema.String.annotate({ description: "Optional key that makes a mailbox send idempotent for the calling key or member. Repeating the request with the same key and body returns the original action in its current state. Keep the key after a lost response. Reusing it with different content returns 409. Active actions retain their key; terminal receipts remain replayable for 24 hours." }).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[\\s\\S]{1,255}$")).annotate({ expected: "a string matching the RegExp ^[\\s\\S]{1,255}$" })), Schema.Null])) });
+const MailboxesReplyAllRequestJson = /* @__PURE__ */ Schema.Struct({
+	channel: Schema.optionalKey(Schema.Union([Schema.Literal("email"), Schema.Null])),
+	cc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	bcc: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+	text: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	html: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	attachments: Schema.optionalKey(Schema.Union([Schema.Array(EmailAttachment).check(Schema.isMaxLength(10).annotate({ expected: "a value with a length of at most 10" })), Schema.Null]))
+});
+const MailboxesReplyAll200 = MailboxSendReceipt;
+const MailboxesReplyAll202 = MailboxPendingSendReceipt;
+const MailboxesReplyAll401 = UnauthorizedError;
+const MailboxesReplyAll402 = PaymentRequiredError;
+const MailboxesReplyAll403 = /* @__PURE__ */ Schema.Union([
+	MailboxSendRefusedError,
+	OnboardingReviewRequiredError,
+	ForbiddenError
+]);
+const MailboxesReplyAll404 = ResourceNotFoundError;
+const MailboxesReplyAll409 = /* @__PURE__ */ Schema.Union([MailboxSendConflictError, ConflictError]);
+const MailboxesReplyAll422 = /* @__PURE__ */ Schema.Union([MailboxChannelUnsupportedError, ValidationError]);
+const MailboxesReplyAll429 = RateLimitedError;
+const MailboxesReplyAll500 = InternalError;
+const MailboxesReplyAll502 = BillingProviderError;
+const MailboxesReplyAll503 = SenderNotReadyError;
+const MailboxesReplyAll504 = GatewayTimeoutError;
+const MailboxesPausePathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesPause200 = Mailbox;
+const MailboxesPause401 = UnauthorizedError;
+const MailboxesPause403 = ForbiddenError;
+const MailboxesPause404 = ResourceNotFoundError;
+const MailboxesPause422 = ValidationError;
+const MailboxesPause500 = InternalError;
+const MailboxesPause504 = GatewayTimeoutError;
+const MailboxesListPoliciesPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListPolicies200 = MailboxPolicyList;
+const MailboxesListPolicies401 = UnauthorizedError;
+const MailboxesListPolicies403 = ForbiddenError;
+const MailboxesListPolicies404 = ResourceNotFoundError;
+const MailboxesListPolicies422 = ValidationError;
+const MailboxesListPolicies500 = InternalError;
+const MailboxesListPolicies504 = GatewayTimeoutError;
+const MailboxesCreatePolicyPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesCreatePolicyRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\S[\\s\\S]*\\S$|^\\S$|^$", "u")).annotate({ expected: "a string matching the RegExp ^\\S[\\s\\S]*\\S$|^\\S$|^$" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+	outcome: MailboxPolicyOutcomeKind,
+	reason: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMaxCodePoints(512).annotate({ expected: "a string with at most 512 code points" })).check(Schema.isMaxLength(512).annotate({ expected: "a value with a length of at most 512" })), Schema.Null])),
+	enabled: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null]))
+});
+const MailboxesCreatePolicy201 = MailboxPolicy;
+const MailboxesCreatePolicy401 = UnauthorizedError;
+const MailboxesCreatePolicy403 = ForbiddenError;
+const MailboxesCreatePolicy404 = ResourceNotFoundError;
+const MailboxesCreatePolicy409 = ConflictError;
+const MailboxesCreatePolicy422 = ValidationError;
+const MailboxesCreatePolicy500 = InternalError;
+const MailboxesCreatePolicy504 = GatewayTimeoutError;
+const MailboxesGetPolicyPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	policyId: MailboxPolicyId
+});
+const MailboxesGetPolicy200 = MailboxPolicy;
+const MailboxesGetPolicy401 = UnauthorizedError;
+const MailboxesGetPolicy403 = ForbiddenError;
+const MailboxesGetPolicy404 = ResourceNotFoundError;
+const MailboxesGetPolicy422 = ValidationError;
+const MailboxesGetPolicy500 = InternalError;
+const MailboxesGetPolicy504 = GatewayTimeoutError;
+const MailboxesDeletePolicyPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	policyId: MailboxPolicyId
+});
+const MailboxesDeletePolicy200 = SuccessResponse;
+const MailboxesDeletePolicy401 = UnauthorizedError;
+const MailboxesDeletePolicy403 = ForbiddenError;
+const MailboxesDeletePolicy404 = ResourceNotFoundError;
+const MailboxesDeletePolicy422 = ValidationError;
+const MailboxesDeletePolicy500 = InternalError;
+const MailboxesDeletePolicy504 = GatewayTimeoutError;
+const MailboxesUpdatePolicyPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	policyId: MailboxPolicyId
+});
+const MailboxesUpdatePolicyRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\S[\\s\\S]*\\S$|^\\S$|^$", "u")).annotate({ expected: "a string matching the RegExp ^\\S[\\s\\S]*\\S$|^\\S$|^$" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })), Schema.Null])),
+	outcome: Schema.optionalKey(Schema.Union([MailboxPolicyOutcomeKind, Schema.Null])),
+	reason: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String.check(Schema.isMaxCodePoints(512).annotate({ expected: "a string with at most 512 code points" })).check(Schema.isMaxLength(512).annotate({ expected: "a value with a length of at most 512" })), Schema.Null]), Schema.Null])),
+	enabled: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null]))
+});
+const MailboxesUpdatePolicy200 = MailboxPolicy;
+const MailboxesUpdatePolicy401 = UnauthorizedError;
+const MailboxesUpdatePolicy403 = ForbiddenError;
+const MailboxesUpdatePolicy404 = ResourceNotFoundError;
+const MailboxesUpdatePolicy422 = ValidationError;
+const MailboxesUpdatePolicy500 = InternalError;
+const MailboxesUpdatePolicy504 = GatewayTimeoutError;
+const MailboxesListQuarantinePathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListQuarantineQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const MailboxesListQuarantine200 = MailboxQuarantinePage;
+const MailboxesListQuarantine401 = UnauthorizedError;
+const MailboxesListQuarantine403 = ForbiddenError;
+const MailboxesListQuarantine404 = ResourceNotFoundError;
+const MailboxesListQuarantine422 = ValidationError;
+const MailboxesListQuarantine500 = InternalError;
+const MailboxesListQuarantine504 = GatewayTimeoutError;
+const MailboxesResumePathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesResume200 = Mailbox;
+const MailboxesResume401 = UnauthorizedError;
+const MailboxesResume403 = ForbiddenError;
+const MailboxesResume404 = ResourceNotFoundError;
+const MailboxesResume422 = ValidationError;
+const MailboxesResume500 = InternalError;
+const MailboxesResume504 = GatewayTimeoutError;
+const MailboxesListThreadsPathParams = /* @__PURE__ */ Schema.Struct({ id: MailboxId });
+const MailboxesListThreadsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	q: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	folder: Schema.optionalKey(Schema.Union([MailboxThreadFolder, Schema.Null])),
+	label: Schema.optionalKey(Schema.Union([MailboxLabelId, Schema.Null])),
+	unread: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("true"), Schema.Literal("false")]), Schema.Null])),
+	starred: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("true"), Schema.Literal("false")]), Schema.Null])),
+	snoozed: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("true"), Schema.Literal("false")]), Schema.Null]))
+});
+const MailboxesListThreads200 = MailboxThreadPage;
+const MailboxesListThreads401 = UnauthorizedError;
+const MailboxesListThreads403 = ForbiddenError;
+const MailboxesListThreads404 = ResourceNotFoundError;
+const MailboxesListThreads422 = ValidationError;
+const MailboxesListThreads500 = InternalError;
+const MailboxesListThreads504 = GatewayTimeoutError;
+const MailboxesGetThreadPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesGetThread200 = MailboxThread;
+const MailboxesGetThread401 = UnauthorizedError;
+const MailboxesGetThread403 = ForbiddenError;
+const MailboxesGetThread404 = ResourceNotFoundError;
+const MailboxesGetThread422 = ValidationError;
+const MailboxesGetThread500 = InternalError;
+const MailboxesGetThread504 = GatewayTimeoutError;
+const MailboxesUpdateThreadPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesUpdateThreadRequestJson = /* @__PURE__ */ Schema.Struct({
+	folder: Schema.optionalKey(Schema.Union([MailboxThreadFolder, Schema.Null])),
+	priority: Schema.optionalKey(Schema.Union([MailboxThreadPriority, Schema.Null])),
+	read: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null])),
+	starred: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null])),
+	snoozedUntil: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null]))
+});
+const MailboxesUpdateThread200 = MailboxThreadState;
+const MailboxesUpdateThread401 = UnauthorizedError;
+const MailboxesUpdateThread403 = ForbiddenError;
+const MailboxesUpdateThread404 = ResourceNotFoundError;
+const MailboxesUpdateThread422 = ValidationError;
+const MailboxesUpdateThread500 = InternalError;
+const MailboxesUpdateThread504 = GatewayTimeoutError;
+const MailboxesGetThreadContentPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesGetThreadContentQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const MailboxesGetThreadContent200 = MailboxThreadContentPage;
+const MailboxesGetThreadContent401 = UnauthorizedError;
+const MailboxesGetThreadContent403 = ForbiddenError;
+const MailboxesGetThreadContent404 = ResourceNotFoundError;
+const MailboxesGetThreadContent422 = ValidationError;
+const MailboxesGetThreadContent500 = InternalError;
+const MailboxesGetThreadContent504 = GatewayTimeoutError;
+const MailboxesAddThreadLabelsPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesAddThreadLabelsRequestJson = /* @__PURE__ */ Schema.Struct({ labels: Schema.TupleWithRest(Schema.Tuple([MailboxLabelId]), [MailboxLabelId]) });
+const MailboxesAddThreadLabels200 = MailboxThreadState;
+const MailboxesAddThreadLabels401 = UnauthorizedError;
+const MailboxesAddThreadLabels403 = ForbiddenError;
+const MailboxesAddThreadLabels404 = ResourceNotFoundError;
+const MailboxesAddThreadLabels422 = ValidationError;
+const MailboxesAddThreadLabels500 = InternalError;
+const MailboxesAddThreadLabels504 = GatewayTimeoutError;
+const MailboxesRemoveThreadLabelsPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesRemoveThreadLabelsRequestJson = /* @__PURE__ */ Schema.Struct({ labels: Schema.TupleWithRest(Schema.Tuple([MailboxLabelId]), [MailboxLabelId]) });
+const MailboxesRemoveThreadLabels200 = MailboxThreadState;
+const MailboxesRemoveThreadLabels401 = UnauthorizedError;
+const MailboxesRemoveThreadLabels403 = ForbiddenError;
+const MailboxesRemoveThreadLabels404 = ResourceNotFoundError;
+const MailboxesRemoveThreadLabels422 = ValidationError;
+const MailboxesRemoveThreadLabels500 = InternalError;
+const MailboxesRemoveThreadLabels504 = GatewayTimeoutError;
+const MailboxesListThreadMessagesPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesListThreadMessagesQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const MailboxesListThreadMessages200 = MailboxMessagePage;
+const MailboxesListThreadMessages401 = UnauthorizedError;
+const MailboxesListThreadMessages403 = ForbiddenError;
+const MailboxesListThreadMessages404 = ResourceNotFoundError;
+const MailboxesListThreadMessages422 = ValidationError;
+const MailboxesListThreadMessages500 = InternalError;
+const MailboxesListThreadMessages504 = GatewayTimeoutError;
+const MailboxesListThreadNotesPathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesListThreadNotesQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const MailboxesListThreadNotes200 = MailboxNotePage;
+const MailboxesListThreadNotes401 = UnauthorizedError;
+const MailboxesListThreadNotes403 = ForbiddenError;
+const MailboxesListThreadNotes404 = ResourceNotFoundError;
+const MailboxesListThreadNotes422 = ValidationError;
+const MailboxesListThreadNotes500 = InternalError;
+const MailboxesListThreadNotes504 = GatewayTimeoutError;
+const MailboxesCreateNotePathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId
+});
+const MailboxesCreateNoteRequestJson = /* @__PURE__ */ Schema.Struct({
+	body: Schema.String,
+	color: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	pinned: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null]))
+});
+const MailboxesCreateNote201 = MailboxNote;
+const MailboxesCreateNote401 = UnauthorizedError;
+const MailboxesCreateNote403 = ForbiddenError;
+const MailboxesCreateNote404 = ResourceNotFoundError;
+const MailboxesCreateNote422 = ValidationError;
+const MailboxesCreateNote500 = InternalError;
+const MailboxesCreateNote504 = GatewayTimeoutError;
+const MailboxesDeleteNotePathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId,
+	noteId: MailboxNoteId
+});
+const MailboxesDeleteNote200 = SuccessResponse;
+const MailboxesDeleteNote401 = UnauthorizedError;
+const MailboxesDeleteNote403 = ForbiddenError;
+const MailboxesDeleteNote404 = ResourceNotFoundError;
+const MailboxesDeleteNote422 = ValidationError;
+const MailboxesDeleteNote500 = InternalError;
+const MailboxesDeleteNote504 = GatewayTimeoutError;
+const MailboxesUpdateNotePathParams = /* @__PURE__ */ Schema.Struct({
+	id: MailboxId,
+	threadId: MailboxThreadId,
+	noteId: MailboxNoteId
+});
+const MailboxesUpdateNoteRequestJson = /* @__PURE__ */ Schema.Struct({
+	body: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	color: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	pinned: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null]))
+});
+const MailboxesUpdateNote200 = MailboxNote;
+const MailboxesUpdateNote401 = UnauthorizedError;
+const MailboxesUpdateNote403 = ForbiddenError;
+const MailboxesUpdateNote404 = ResourceNotFoundError;
+const MailboxesUpdateNote422 = ValidationError;
+const MailboxesUpdateNote500 = InternalError;
+const MailboxesUpdateNote504 = GatewayTimeoutError;
+var MailboxesGroup = class extends HttpApiGroup.make("Mailboxes").add(HttpApiEndpoint.get("mailboxesList", "/v1/mailboxes", {
+	query: MailboxesListQuery,
+	success: MailboxesList200,
+	error: [
+		MailboxesList401.pipe(HttpApiSchema.status(401)),
+		MailboxesList403.pipe(HttpApiSchema.status(403)),
+		MailboxesList422.pipe(HttpApiSchema.status(422)),
+		MailboxesList500,
+		MailboxesList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.list").annotate(OpenApi.Summary, "List mailboxes").annotate(OpenApi.Description, "Returns summaries of the mailboxes the caller can read, newest first, filterable by creation time (`after`, `before`). Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. Read a mailbox's endpoints and metadata with `GET /v1/mailboxes/{id}`."), HttpApiEndpoint.post("mailboxesCreate", "/v1/mailboxes", {
+	payload: MailboxesCreateRequestJson,
+	success: MailboxesCreate201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCreate401.pipe(HttpApiSchema.status(401)),
+		MailboxesCreate402.pipe(HttpApiSchema.status(402)),
+		MailboxesCreate403.pipe(HttpApiSchema.status(403)),
+		MailboxesCreate404.pipe(HttpApiSchema.status(404)),
+		MailboxesCreate409.pipe(HttpApiSchema.status(409)),
+		MailboxesCreate422.pipe(HttpApiSchema.status(422)),
+		MailboxesCreate500,
+		MailboxesCreate502.pipe(HttpApiSchema.status(502)),
+		MailboxesCreate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.create").annotate(OpenApi.Summary, "Create a mailbox").annotate(OpenApi.Description, "Creates a mailbox with one endpoint and returns it with status 201; the caller gets an admin grant on it. Email is the channel a mailbox endpoint uses today; another channel is refused (422). An email endpoint's address must be under the organization's Samva-hosted mail domain or a verified domain with receiving enabled, and the mailbox sends from it. The slug defaults to the address's local part. Pass `slug` when that is taken or not a valid slug. The mailbox receives mail from now on; mail that arrived earlier is not added to it. Conflicts if the address or slug is already in use. Returns 402 when the organization is at its plan's mailbox allowance or at its mailbox storage allowance; incoming mail is still received past the storage allowance."), HttpApiEndpoint.get("mailboxesGet", "/v1/mailboxes/:id", {
+	params: MailboxesGetPathParams,
+	success: MailboxesGet200,
+	error: [
+		MailboxesGet401.pipe(HttpApiSchema.status(401)),
+		MailboxesGet403.pipe(HttpApiSchema.status(403)),
+		MailboxesGet404.pipe(HttpApiSchema.status(404)),
+		MailboxesGet422.pipe(HttpApiSchema.status(422)),
+		MailboxesGet500,
+		MailboxesGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.get").annotate(OpenApi.Summary, "Get a mailbox").annotate(OpenApi.Description, "Returns a mailbox with its endpoints and metadata; each endpoint says whether it is the mailbox's default on its channel. Its grants are `GET /v1/mailboxes/{id}/grants` and its send policies `GET /v1/mailboxes/{id}/policies`."), HttpApiEndpoint.delete("mailboxesRemove", "/v1/mailboxes/:id", {
+	params: MailboxesRemovePathParams,
+	success: MailboxesRemove200,
+	error: [
+		MailboxesRemove401.pipe(HttpApiSchema.status(401)),
+		MailboxesRemove403.pipe(HttpApiSchema.status(403)),
+		MailboxesRemove404.pipe(HttpApiSchema.status(404)),
+		MailboxesRemove422.pipe(HttpApiSchema.status(422)),
+		MailboxesRemove500,
+		MailboxesRemove502.pipe(HttpApiSchema.status(502)),
+		MailboxesRemove504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.remove").annotate(OpenApi.Summary, "Delete a mailbox").annotate(OpenApi.Description, "Deletes a mailbox with its endpoints, threads, drafts, and history. The messages it received stay with the organization. The mailbox leaves every API key scope and webhook endpoint filter that named it; a key or endpoint left with no mailbox is disabled."), HttpApiEndpoint.patch("mailboxesUpdate", "/v1/mailboxes/:id", {
+	params: MailboxesUpdatePathParams,
+	payload: MailboxesUpdateRequestJson,
+	success: MailboxesUpdate200,
+	error: [
+		MailboxesUpdate401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdate403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdate404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdate422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdate500,
+		MailboxesUpdate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.update").annotate(OpenApi.Summary, "Update a mailbox").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest. `metadata` merges into the stored metadata by key, and a `null` value deletes that key. Change an endpoint's sender name or default with `PATCH /v1/mailboxes/{id}/endpoints/{endpointId}`."), HttpApiEndpoint.get("mailboxesListActions", "/v1/mailboxes/:id/actions", {
+	params: MailboxesListActionsPathParams,
+	query: MailboxesListActionsQuery,
+	success: MailboxesListActions200,
+	error: [
+		MailboxesListActions401.pipe(HttpApiSchema.status(401)),
+		MailboxesListActions403.pipe(HttpApiSchema.status(403)),
+		MailboxesListActions404.pipe(HttpApiSchema.status(404)),
+		MailboxesListActions422.pipe(HttpApiSchema.status(422)),
+		MailboxesListActions500,
+		MailboxesListActions504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listActions").annotate(OpenApi.Summary, "List mailbox actions").annotate(OpenApi.Description, "Returns the actions proposed on a mailbox, newest first, filterable by `threadId`, `state` (`approvalRequired` lists the sends waiting for a person), and creation time (`after`, `before`). Filters apply together within the mailbox. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.get("mailboxesGetAction", "/v1/mailboxes/:id/actions/:actionId", {
+	params: MailboxesGetActionPathParams,
+	success: MailboxesGetAction200,
+	error: [
+		MailboxesGetAction401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetAction403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetAction404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetAction422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetAction500,
+		MailboxesGetAction504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getAction").annotate(OpenApi.Summary, "Get a mailbox action").annotate(OpenApi.Description, "Returns one action with its current progress. Send actions expose their immutable approved content, deadline, problem, and accepted receipt. A caller with mailbox read access may inspect actions; send-only callers may inspect only their own proposals. Acceptance and mailbox completion do not mean recipient delivery."), HttpApiEndpoint.post("mailboxesApproveAction", "/v1/mailboxes/:id/actions/:actionId/approve", {
+	params: MailboxesApproveActionPathParams,
+	success: [MailboxesApproveAction200, MailboxesApproveAction202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesApproveAction401.pipe(HttpApiSchema.status(401)),
+		MailboxesApproveAction402.pipe(HttpApiSchema.status(402)),
+		MailboxesApproveAction403.pipe(HttpApiSchema.status(403)),
+		MailboxesApproveAction404.pipe(HttpApiSchema.status(404)),
+		MailboxesApproveAction409.pipe(HttpApiSchema.status(409)),
+		MailboxesApproveAction422.pipe(HttpApiSchema.status(422)),
+		MailboxesApproveAction429.pipe(HttpApiSchema.status(429)),
+		MailboxesApproveAction500,
+		MailboxesApproveAction502.pipe(HttpApiSchema.status(502)),
+		MailboxesApproveAction503.pipe(HttpApiSchema.status(503)),
+		MailboxesApproveAction504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.approveAction").annotate(OpenApi.Summary, "Approve a mailbox action").annotate(OpenApi.Description, "Records approval of a send and returns 202 while it is pending. A send is queued for automatic retry within 15 minutes of approval; repeating approval does not extend this deadline. Accepted, completed, and notSent replays return 200. No expiry applies before approval. Only a person signed in or through OAuth may approve, and never the proposer. Non-send approvals execute synchronously and return 200 with their own execution states."), HttpApiEndpoint.post("mailboxesCancelAction", "/v1/mailboxes/:id/actions/:actionId/cancel", {
+	params: MailboxesCancelActionPathParams,
+	success: [MailboxesCancelAction200, MailboxesCancelAction202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesCancelAction401.pipe(HttpApiSchema.status(401)),
+		MailboxesCancelAction402.pipe(HttpApiSchema.status(402)),
+		MailboxesCancelAction403.pipe(HttpApiSchema.status(403)),
+		MailboxesCancelAction404.pipe(HttpApiSchema.status(404)),
+		MailboxesCancelAction409.pipe(HttpApiSchema.status(409)),
+		MailboxesCancelAction422.pipe(HttpApiSchema.status(422)),
+		MailboxesCancelAction429.pipe(HttpApiSchema.status(429)),
+		MailboxesCancelAction500,
+		MailboxesCancelAction502.pipe(HttpApiSchema.status(502)),
+		MailboxesCancelAction503.pipe(HttpApiSchema.status(503)),
+		MailboxesCancelAction504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.cancelAction").annotate(OpenApi.Summary, "Cancel a mailbox send").annotate(OpenApi.Description, "Cancels a definitely unsent action and reopens its draft atomically. Only an authorized person who proposed the send or can approve actions may cancel. Accepted sends return 409 with their winning receipt and cannot be withdrawn. An uncertain send requires reconciliation and cannot be cancelled as unsent."), HttpApiEndpoint.post("mailboxesDenyAction", "/v1/mailboxes/:id/actions/:actionId/deny", {
+	params: MailboxesDenyActionPathParams,
+	payload: MailboxesDenyActionRequestJson,
+	success: MailboxesDenyAction200,
+	error: [
+		MailboxesDenyAction401.pipe(HttpApiSchema.status(401)),
+		MailboxesDenyAction403.pipe(HttpApiSchema.status(403)),
+		MailboxesDenyAction404.pipe(HttpApiSchema.status(404)),
+		MailboxesDenyAction409.pipe(HttpApiSchema.status(409)),
+		MailboxesDenyAction422.pipe(HttpApiSchema.status(422)),
+		MailboxesDenyAction500,
+		MailboxesDenyAction504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.denyAction").annotate(OpenApi.Summary, "Deny a mailbox action").annotate(OpenApi.Description, "Denies an action waiting for approval with a reason and returns it without executing it. Only a person signed in or through OAuth may deny, and never the one who proposed it."), HttpApiEndpoint.post("mailboxesRetryAction", "/v1/mailboxes/:id/actions/:actionId/retry", {
+	params: MailboxesRetryActionPathParams,
+	success: [MailboxesRetryAction200, MailboxesRetryAction202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesRetryAction401.pipe(HttpApiSchema.status(401)),
+		MailboxesRetryAction402.pipe(HttpApiSchema.status(402)),
+		MailboxesRetryAction403.pipe(HttpApiSchema.status(403)),
+		MailboxesRetryAction404.pipe(HttpApiSchema.status(404)),
+		MailboxesRetryAction409.pipe(HttpApiSchema.status(409)),
+		MailboxesRetryAction422.pipe(HttpApiSchema.status(422)),
+		MailboxesRetryAction429.pipe(HttpApiSchema.status(429)),
+		MailboxesRetryAction500,
+		MailboxesRetryAction502.pipe(HttpApiSchema.status(502)),
+		MailboxesRetryAction503.pipe(HttpApiSchema.status(503)),
+		MailboxesRetryAction504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.retryAction").annotate(OpenApi.Summary, "Resume a mailbox send").annotate(OpenApi.Description, "Resumes the same action only after its previous execution is confirmed ended and safe continuation is possible. Only an authorized person who proposed the send or can approve actions may retry. Automatic waits need no manual Retry. This does not grant new approval, reset the original deadline, replace the message identity, or resubmit an accepted or uncertain send."), HttpApiEndpoint.get("mailboxesGetAgentActivity", "/v1/mailboxes/:id/agent-activity", {
+	params: MailboxesGetAgentActivityPathParams,
+	query: MailboxesGetAgentActivityQuery,
+	success: MailboxesGetAgentActivity200,
+	error: [
+		MailboxesGetAgentActivity401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetAgentActivity403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetAgentActivity404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetAgentActivity422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetAgentActivity500,
+		MailboxesGetAgentActivity504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getAgentActivity").annotate(OpenApi.Summary, "Get mailbox activity").annotate(OpenApi.Description, "Counts the actions proposed and events recorded on a mailbox between `after` and `before` (omit both for all time), and the sends waiting for approval now. List the actions and events themselves with `GET /v1/mailboxes/{id}/actions` and `GET /v1/mailboxes/{id}/events`."), HttpApiEndpoint.get("mailboxesListDrafts", "/v1/mailboxes/:id/drafts", {
+	params: MailboxesListDraftsPathParams,
+	query: MailboxesListDraftsQuery,
+	success: MailboxesListDrafts200,
+	error: [
+		MailboxesListDrafts401.pipe(HttpApiSchema.status(401)),
+		MailboxesListDrafts403.pipe(HttpApiSchema.status(403)),
+		MailboxesListDrafts404.pipe(HttpApiSchema.status(404)),
+		MailboxesListDrafts422.pipe(HttpApiSchema.status(422)),
+		MailboxesListDrafts500,
+		MailboxesListDrafts504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listDrafts").annotate(OpenApi.Summary, "List drafts").annotate(OpenApi.Description, "Returns summaries of the caller's unsent drafts in the mailbox, newest first, optionally for one thread. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. Read a draft's body with `GET /v1/mailboxes/{id}/drafts/{draftId}`."), HttpApiEndpoint.post("mailboxesCreateDraft", "/v1/mailboxes/:id/drafts", {
+	params: MailboxesCreateDraftPathParams,
+	payload: MailboxesCreateDraftRequestJson,
+	success: MailboxesCreateDraft201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCreateDraft401.pipe(HttpApiSchema.status(401)),
+		MailboxesCreateDraft403.pipe(HttpApiSchema.status(403)),
+		MailboxesCreateDraft404.pipe(HttpApiSchema.status(404)),
+		MailboxesCreateDraft422.pipe(HttpApiSchema.status(422)),
+		MailboxesCreateDraft500,
+		MailboxesCreateDraft504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.createDraft").annotate(OpenApi.Summary, "Create a draft").annotate(OpenApi.Description, "Saves a draft of a new message, or of a reply when `inReplyToMessageId` names a message in the mailbox, and returns it with status 201. Email drafts are the kind a mailbox saves today; another channel is refused (422). Send it with `POST /v1/mailboxes/{id}/drafts/{draftId}/send`."), HttpApiEndpoint.get("mailboxesGetDraft", "/v1/mailboxes/:id/drafts/:draftId", {
+	params: MailboxesGetDraftPathParams,
+	success: MailboxesGetDraft200,
+	error: [
+		MailboxesGetDraft401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetDraft403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetDraft404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetDraft422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetDraft500,
+		MailboxesGetDraft504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getDraft").annotate(OpenApi.Summary, "Get a draft").annotate(OpenApi.Description, "Returns one of the caller's drafts, or the draft of a send waiting for approval when the caller may approve it."), HttpApiEndpoint.delete("mailboxesDeleteDraft", "/v1/mailboxes/:id/drafts/:draftId", {
+	params: MailboxesDeleteDraftPathParams,
+	success: MailboxesDeleteDraft200,
+	error: [
+		MailboxesDeleteDraft401.pipe(HttpApiSchema.status(401)),
+		MailboxesDeleteDraft403.pipe(HttpApiSchema.status(403)),
+		MailboxesDeleteDraft404.pipe(HttpApiSchema.status(404)),
+		MailboxesDeleteDraft422.pipe(HttpApiSchema.status(422)),
+		MailboxesDeleteDraft500,
+		MailboxesDeleteDraft504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.deleteDraft").annotate(OpenApi.Summary, "Delete a draft").annotate(OpenApi.Description, "Discards an unsent draft."), HttpApiEndpoint.patch("mailboxesUpdateDraft", "/v1/mailboxes/:id/drafts/:draftId", {
+	params: MailboxesUpdateDraftPathParams,
+	payload: MailboxesUpdateDraftRequestJson,
+	success: MailboxesUpdateDraft200,
+	error: [
+		MailboxesUpdateDraft401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdateDraft403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdateDraft404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdateDraft409.pipe(HttpApiSchema.status(409)),
+		MailboxesUpdateDraft422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdateDraft500,
+		MailboxesUpdateDraft504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.updateDraft").annotate(OpenApi.Summary, "Update a draft").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest; `null` clears an optional field. A draft whose send waits for approval cannot change and conflicts."), HttpApiEndpoint.post("mailboxesSendDraft", "/v1/mailboxes/:id/drafts/:draftId/send", {
+	params: MailboxesSendDraftPathParams,
+	headers: MailboxesSendDraftHeaders,
+	success: [MailboxesSendDraft200, MailboxesSendDraft202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesSendDraft401.pipe(HttpApiSchema.status(401)),
+		MailboxesSendDraft402.pipe(HttpApiSchema.status(402)),
+		MailboxesSendDraft403.pipe(HttpApiSchema.status(403)),
+		MailboxesSendDraft404.pipe(HttpApiSchema.status(404)),
+		MailboxesSendDraft409.pipe(HttpApiSchema.status(409)),
+		MailboxesSendDraft422.pipe(HttpApiSchema.status(422)),
+		MailboxesSendDraft429.pipe(HttpApiSchema.status(429)),
+		MailboxesSendDraft500,
+		MailboxesSendDraft502.pipe(HttpApiSchema.status(502)),
+		MailboxesSendDraft503.pipe(HttpApiSchema.status(503)),
+		MailboxesSendDraft504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.sendDraft").annotate(OpenApi.Summary, "Send a draft").annotate(OpenApi.Description, "Sends one of the caller's drafts: a reply draft in its thread, any other draft as a new conversation. A draft needs recipients, a subject, and a body."), HttpApiEndpoint.post("mailboxesCreateEndpoint", "/v1/mailboxes/:id/endpoints", {
+	params: MailboxesCreateEndpointPathParams,
+	payload: MailboxesCreateEndpointRequestJson,
+	success: MailboxesCreateEndpoint201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCreateEndpoint401.pipe(HttpApiSchema.status(401)),
+		MailboxesCreateEndpoint403.pipe(HttpApiSchema.status(403)),
+		MailboxesCreateEndpoint404.pipe(HttpApiSchema.status(404)),
+		MailboxesCreateEndpoint409.pipe(HttpApiSchema.status(409)),
+		MailboxesCreateEndpoint422.pipe(HttpApiSchema.status(422)),
+		MailboxesCreateEndpoint500,
+		MailboxesCreateEndpoint504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.createEndpoint").annotate(OpenApi.Summary, "Add an endpoint to a mailbox").annotate(OpenApi.Description, "Adds an endpoint to a mailbox and returns the mailbox with status 201. It follows the same rules as the endpoint of a new mailbox: email is the channel a mailbox endpoint uses today (422 otherwise), the address must be under the organization's Samva-hosted mail domain or a verified domain with receiving enabled, and no mailbox may already hold it (409). Messages sent to it reach the mailbox from now on. It becomes the default on its channel only when the mailbox has no endpoint there yet."), HttpApiEndpoint.delete("mailboxesRemoveEndpoint", "/v1/mailboxes/:id/endpoints/:endpointId", {
+	params: MailboxesRemoveEndpointPathParams,
+	success: MailboxesRemoveEndpoint200,
+	error: [
+		MailboxesRemoveEndpoint401.pipe(HttpApiSchema.status(401)),
+		MailboxesRemoveEndpoint403.pipe(HttpApiSchema.status(403)),
+		MailboxesRemoveEndpoint404.pipe(HttpApiSchema.status(404)),
+		MailboxesRemoveEndpoint422.pipe(HttpApiSchema.status(422)),
+		MailboxesRemoveEndpoint500,
+		MailboxesRemoveEndpoint504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.removeEndpoint").annotate(OpenApi.Summary, "Remove an endpoint from a mailbox").annotate(OpenApi.Description, "Removes an endpoint from a mailbox and returns the mailbox. Messages sent to it stop reaching the mailbox; its existing threads and messages stay, and replies in them leave from the mailbox's default endpoint on their channel. A mailbox keeps at least one endpoint, so removing the last one is refused (422). When the removed endpoint was the default on its channel, the oldest remaining endpoint there becomes the default."), HttpApiEndpoint.patch("mailboxesUpdateEndpoint", "/v1/mailboxes/:id/endpoints/:endpointId", {
+	params: MailboxesUpdateEndpointPathParams,
+	payload: MailboxesUpdateEndpointRequestJson,
+	success: MailboxesUpdateEndpoint200,
+	error: [
+		MailboxesUpdateEndpoint401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdateEndpoint403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdateEndpoint404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdateEndpoint422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdateEndpoint500,
+		MailboxesUpdateEndpoint504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.updateEndpoint").annotate(OpenApi.Summary, "Update a mailbox endpoint").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest, and returns the mailbox. `displayName` is the name messages sent from the endpoint carry; null falls back to the mailbox's name. `default: true` makes the endpoint the one the mailbox starts new conversations from on its channel; replies always leave from the endpoint of their thread."), HttpApiEndpoint.get("mailboxesListEvents", "/v1/mailboxes/:id/events", {
+	params: MailboxesListEventsPathParams,
+	query: MailboxesListEventsQuery,
+	success: MailboxesListEvents200,
+	error: [
+		MailboxesListEvents401.pipe(HttpApiSchema.status(401)),
+		MailboxesListEvents403.pipe(HttpApiSchema.status(403)),
+		MailboxesListEvents404.pipe(HttpApiSchema.status(404)),
+		MailboxesListEvents422.pipe(HttpApiSchema.status(422)),
+		MailboxesListEvents500,
+		MailboxesListEvents504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listEvents").annotate(OpenApi.Summary, "List mailbox events").annotate(OpenApi.Description, "Returns mailbox audit records, newest first, filterable by when they happened (`after`, `before`). Audit event types: `mailbox.created`, `endpoint.attached`, `endpoint.detached`, `message.received`, `message.released`, `message.sent`, `thread.created`, `action.proposed`, `action.policy_decided`, `action.approval_requested`, `action.approval_resolved`, `action.accepted`, `action.executed`, `action.failed`. Thread and draft changes have no dedicated audit event types. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.get("mailboxesListFolders", "/v1/mailboxes/:id/folders", {
+	params: MailboxesListFoldersPathParams,
+	success: MailboxesListFolders200,
+	error: [
+		MailboxesListFolders401.pipe(HttpApiSchema.status(401)),
+		MailboxesListFolders403.pipe(HttpApiSchema.status(403)),
+		MailboxesListFolders404.pipe(HttpApiSchema.status(404)),
+		MailboxesListFolders422.pipe(HttpApiSchema.status(422)),
+		MailboxesListFolders500,
+		MailboxesListFolders504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listFolders").annotate(OpenApi.Summary, "List mailbox folders").annotate(OpenApi.Description, "Returns each folder that holds a thread with its thread count and the caller's unread count. The folder set is fixed, so the list is never paged."), HttpApiEndpoint.get("mailboxesListGrants", "/v1/mailboxes/:id/grants", {
+	params: MailboxesListGrantsPathParams,
+	query: MailboxesListGrantsQuery,
+	success: MailboxesListGrants200,
+	error: [
+		MailboxesListGrants401.pipe(HttpApiSchema.status(401)),
+		MailboxesListGrants403.pipe(HttpApiSchema.status(403)),
+		MailboxesListGrants404.pipe(HttpApiSchema.status(404)),
+		MailboxesListGrants422.pipe(HttpApiSchema.status(422)),
+		MailboxesListGrants500,
+		MailboxesListGrants504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listGrants").annotate(OpenApi.Summary, "List mailbox grants").annotate(OpenApi.Description, "Returns who can use the mailbox, what each grant allows, and whether its sends wait for approval, newest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("mailboxesCreateGrant", "/v1/mailboxes/:id/grants", {
+	params: MailboxesCreateGrantPathParams,
+	payload: MailboxesCreateGrantRequestJson,
+	success: MailboxesCreateGrant201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCreateGrant401.pipe(HttpApiSchema.status(401)),
+		MailboxesCreateGrant403.pipe(HttpApiSchema.status(403)),
+		MailboxesCreateGrant404.pipe(HttpApiSchema.status(404)),
+		MailboxesCreateGrant409.pipe(HttpApiSchema.status(409)),
+		MailboxesCreateGrant422.pipe(HttpApiSchema.status(422)),
+		MailboxesCreateGrant500,
+		MailboxesCreateGrant504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.createGrant").annotate(OpenApi.Summary, "Grant a member access to a mailbox").annotate(OpenApi.Description, "Shares a mailbox with an organization member and returns the grant with status 201. The member must already belong to the organization. A member who already holds a grant conflicts rather than being rewritten: change an existing grant with `PATCH /v1/mailboxes/{id}/grants/{grantId}`, so a grant is never widened as a side effect of granting. List the current grants with `GET /v1/mailboxes/{id}/grants`."), HttpApiEndpoint.delete("mailboxesRevokeGrant", "/v1/mailboxes/:id/grants/:grantId", {
+	params: MailboxesRevokeGrantPathParams,
+	success: MailboxesRevokeGrant200,
+	error: [
+		MailboxesRevokeGrant401.pipe(HttpApiSchema.status(401)),
+		MailboxesRevokeGrant403.pipe(HttpApiSchema.status(403)),
+		MailboxesRevokeGrant404.pipe(HttpApiSchema.status(404)),
+		MailboxesRevokeGrant409.pipe(HttpApiSchema.status(409)),
+		MailboxesRevokeGrant422.pipe(HttpApiSchema.status(422)),
+		MailboxesRevokeGrant500,
+		MailboxesRevokeGrant504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.revokeGrant").annotate(OpenApi.Summary, "Revoke a mailbox grant").annotate(OpenApi.Description, "Removes a member's access to a mailbox. The last grant that can configure the mailbox cannot be revoked, so a mailbox is never left with nobody able to administer it: grant a teammate the admin role before removing your own."), HttpApiEndpoint.patch("mailboxesUpdateGrant", "/v1/mailboxes/:id/grants/:grantId", {
+	params: MailboxesUpdateGrantPathParams,
+	payload: MailboxesUpdateGrantRequestJson,
+	success: MailboxesUpdateGrant200,
+	error: [
+		MailboxesUpdateGrant401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdateGrant403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdateGrant404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdateGrant409.pipe(HttpApiSchema.status(409)),
+		MailboxesUpdateGrant422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdateGrant500,
+		MailboxesUpdateGrant504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.updateGrant").annotate(OpenApi.Summary, "Update a mailbox grant").annotate(OpenApi.Description, "Changes a member's role, send mode, or both on a mailbox and returns the updated grant. A field left out keeps its value; naming neither is a validation error. Taking admin from the last grant that can configure the mailbox conflicts, as revoking it does. The change applies to the member's next request on every surface."), HttpApiEndpoint.get("mailboxesListLabels", "/v1/mailboxes/:id/labels", {
+	params: MailboxesListLabelsPathParams,
+	success: MailboxesListLabels200,
+	error: [
+		MailboxesListLabels401.pipe(HttpApiSchema.status(401)),
+		MailboxesListLabels403.pipe(HttpApiSchema.status(403)),
+		MailboxesListLabels404.pipe(HttpApiSchema.status(404)),
+		MailboxesListLabels422.pipe(HttpApiSchema.status(422)),
+		MailboxesListLabels500,
+		MailboxesListLabels504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listLabels").annotate(OpenApi.Summary, "List mailbox labels").annotate(OpenApi.Description, "Returns every label defined on a mailbox, ordered by name. A mailbox holds at most 100 labels, so the list is never paged."), HttpApiEndpoint.post("mailboxesCreateLabel", "/v1/mailboxes/:id/labels", {
+	params: MailboxesCreateLabelPathParams,
+	payload: MailboxesCreateLabelRequestJson,
+	success: MailboxesCreateLabel201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCreateLabel401.pipe(HttpApiSchema.status(401)),
+		MailboxesCreateLabel403.pipe(HttpApiSchema.status(403)),
+		MailboxesCreateLabel404.pipe(HttpApiSchema.status(404)),
+		MailboxesCreateLabel409.pipe(HttpApiSchema.status(409)),
+		MailboxesCreateLabel422.pipe(HttpApiSchema.status(422)),
+		MailboxesCreateLabel500,
+		MailboxesCreateLabel504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.createLabel").annotate(OpenApi.Summary, "Create a mailbox label").annotate(OpenApi.Description, "Creates a label on a mailbox and returns it with status 201. Slugs are unique within the mailbox, and a mailbox holds at most 100 labels; either limit conflicts."), HttpApiEndpoint.delete("mailboxesDeleteLabel", "/v1/mailboxes/:id/labels/:labelId", {
+	params: MailboxesDeleteLabelPathParams,
+	success: MailboxesDeleteLabel200,
+	error: [
+		MailboxesDeleteLabel401.pipe(HttpApiSchema.status(401)),
+		MailboxesDeleteLabel403.pipe(HttpApiSchema.status(403)),
+		MailboxesDeleteLabel404.pipe(HttpApiSchema.status(404)),
+		MailboxesDeleteLabel422.pipe(HttpApiSchema.status(422)),
+		MailboxesDeleteLabel500,
+		MailboxesDeleteLabel504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.deleteLabel").annotate(OpenApi.Summary, "Delete a mailbox label").annotate(OpenApi.Description, "Deletes a label and removes it from every thread that carries it."), HttpApiEndpoint.patch("mailboxesUpdateLabel", "/v1/mailboxes/:id/labels/:labelId", {
+	params: MailboxesUpdateLabelPathParams,
+	payload: MailboxesUpdateLabelRequestJson,
+	success: MailboxesUpdateLabel200,
+	error: [
+		MailboxesUpdateLabel401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdateLabel403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdateLabel404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdateLabel422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdateLabel500,
+		MailboxesUpdateLabel504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.updateLabel").annotate(OpenApi.Summary, "Update a mailbox label").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest."), HttpApiEndpoint.post("mailboxesSendMessage", "/v1/mailboxes/:id/messages", {
+	params: MailboxesSendMessagePathParams,
+	headers: MailboxesSendMessageHeaders,
+	payload: MailboxesSendMessageRequestJson,
+	success: [MailboxesSendMessage200, MailboxesSendMessage202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesSendMessage401.pipe(HttpApiSchema.status(401)),
+		MailboxesSendMessage402.pipe(HttpApiSchema.status(402)),
+		MailboxesSendMessage403.pipe(HttpApiSchema.status(403)),
+		MailboxesSendMessage404.pipe(HttpApiSchema.status(404)),
+		MailboxesSendMessage409.pipe(HttpApiSchema.status(409)),
+		MailboxesSendMessage422.pipe(HttpApiSchema.status(422)),
+		MailboxesSendMessage429.pipe(HttpApiSchema.status(429)),
+		MailboxesSendMessage500,
+		MailboxesSendMessage502.pipe(HttpApiSchema.status(502)),
+		MailboxesSendMessage503.pipe(HttpApiSchema.status(503)),
+		MailboxesSendMessage504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.sendMessage").annotate(OpenApi.Summary, "Send a new message").annotate(OpenApi.Description, "Starts a new conversation from the mailbox's default endpoint on the channel the body names (email when omitted); a channel the mailbox cannot send on yet is refused (422). Records a send action and returns 202 with its current receipt and a Location for action status. An installation, grant, or policy may require approval; otherwise the send is queued. Observe the same action through acceptance and mailbox completion. A policy refusal returns 403 with the recorded receipt."), HttpApiEndpoint.get("mailboxesGetMessage", "/v1/mailboxes/:id/messages/:messageId", {
+	params: MailboxesGetMessagePathParams,
+	success: MailboxesGetMessage200,
+	error: [
+		MailboxesGetMessage401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetMessage403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetMessage404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetMessage422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetMessage500,
+		MailboxesGetMessage504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getMessage").annotate(OpenApi.Summary, "Get a mailbox message").annotate(OpenApi.Description, "Returns a message in the mailbox, discriminated by `channel`. An email has its text, sanitized HTML, `replyText` (what the sender wrote, without quoted history), authentication verdicts, and attachments."), HttpApiEndpoint.get("mailboxesGetMessageAttachment", "/v1/mailboxes/:id/messages/:messageId/attachments/:attachmentId", {
+	params: MailboxesGetMessageAttachmentPathParams,
+	success: MailboxesGetMessageAttachment200,
+	error: [
+		MailboxesGetMessageAttachment401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetMessageAttachment403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetMessageAttachment404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetMessageAttachment422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetMessageAttachment500,
+		MailboxesGetMessageAttachment504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getMessageAttachment").annotate(OpenApi.Summary, "Get a message attachment").annotate(OpenApi.Description, "Returns a short-lived download URL for one of the message's attachments."), HttpApiEndpoint.post("mailboxesCopyMessageAttachment", "/v1/mailboxes/:id/messages/:messageId/attachments/:attachmentId/copy", {
+	params: MailboxesCopyMessageAttachmentPathParams,
+	success: MailboxesCopyMessageAttachment201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCopyMessageAttachment401.pipe(HttpApiSchema.status(401)),
+		MailboxesCopyMessageAttachment403.pipe(HttpApiSchema.status(403)),
+		MailboxesCopyMessageAttachment404.pipe(HttpApiSchema.status(404)),
+		MailboxesCopyMessageAttachment409.pipe(HttpApiSchema.status(409)),
+		MailboxesCopyMessageAttachment422.pipe(HttpApiSchema.status(422)),
+		MailboxesCopyMessageAttachment500,
+		MailboxesCopyMessageAttachment504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.copyMessageAttachment").annotate(OpenApi.Summary, "Copy a message attachment").annotate(OpenApi.Description, "Copies one of a received message's attachments into the organization's media and returns it as a draft attachment (`mediaId`), so a draft can carry it. A draft that forwards a message saves each original attachment this way."), HttpApiEndpoint.post("mailboxesDiscardMessage", "/v1/mailboxes/:id/messages/:messageId/discard", {
+	params: MailboxesDiscardMessagePathParams,
+	success: MailboxesDiscardMessage200,
+	error: [
+		MailboxesDiscardMessage401.pipe(HttpApiSchema.status(401)),
+		MailboxesDiscardMessage403.pipe(HttpApiSchema.status(403)),
+		MailboxesDiscardMessage404.pipe(HttpApiSchema.status(404)),
+		MailboxesDiscardMessage409.pipe(HttpApiSchema.status(409)),
+		MailboxesDiscardMessage422.pipe(HttpApiSchema.status(422)),
+		MailboxesDiscardMessage500,
+		MailboxesDiscardMessage502.pipe(HttpApiSchema.status(502)),
+		MailboxesDiscardMessage504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.discardMessage").annotate(OpenApi.Summary, "Discard a quarantined message").annotate(OpenApi.Description, "Removes a held message from the mailbox's quarantine for good: it leaves the quarantine list, never reaches a thread, and can no longer be released. Quarantined and isolated (malware) messages can both be discarded. Publishes one `mailbox.message.discarded` event; discarding it again returns the same result and publishes nothing. A released message is in its thread and cannot be discarded: 409. Only a person can discard; API keys never hold `quarantine.release`."), HttpApiEndpoint.post("mailboxesForward", "/v1/mailboxes/:id/messages/:messageId/forward", {
+	params: MailboxesForwardPathParams,
+	headers: MailboxesForwardHeaders,
+	payload: MailboxesForwardRequestJson,
+	success: [MailboxesForward200, MailboxesForward202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesForward401.pipe(HttpApiSchema.status(401)),
+		MailboxesForward402.pipe(HttpApiSchema.status(402)),
+		MailboxesForward403.pipe(HttpApiSchema.status(403)),
+		MailboxesForward404.pipe(HttpApiSchema.status(404)),
+		MailboxesForward409.pipe(HttpApiSchema.status(409)),
+		MailboxesForward422.pipe(HttpApiSchema.status(422)),
+		MailboxesForward429.pipe(HttpApiSchema.status(429)),
+		MailboxesForward500,
+		MailboxesForward502.pipe(HttpApiSchema.status(502)),
+		MailboxesForward503.pipe(HttpApiSchema.status(503)),
+		MailboxesForward504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.forward").annotate(OpenApi.Summary, "Forward a message").annotate(OpenApi.Description, "Forwards an email to new recipients as a new conversation from the thread's endpoint, with the original quoted below the caller's text and its attachments attached ahead of any the caller adds. The combined attachments must fit the email attachment limits."), HttpApiEndpoint.get("mailboxesGetMessageRaw", "/v1/mailboxes/:id/messages/:messageId/raw", {
+	params: MailboxesGetMessageRawPathParams,
+	success: MailboxesGetMessageRaw200,
+	error: [
+		MailboxesGetMessageRaw401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetMessageRaw403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetMessageRaw404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetMessageRaw422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetMessageRaw500,
+		MailboxesGetMessageRaw504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getMessageRaw").annotate(OpenApi.Summary, "Get a message's raw MIME").annotate(OpenApi.Description, "Returns a short-lived URL for the message exactly as it was received (`message/rfc822`). Sent messages have no stored MIME."), HttpApiEndpoint.post("mailboxesReleaseMessage", "/v1/mailboxes/:id/messages/:messageId/release", {
+	params: MailboxesReleaseMessagePathParams,
+	success: MailboxesReleaseMessage200,
+	error: [
+		MailboxesReleaseMessage401.pipe(HttpApiSchema.status(401)),
+		MailboxesReleaseMessage403.pipe(HttpApiSchema.status(403)),
+		MailboxesReleaseMessage404.pipe(HttpApiSchema.status(404)),
+		MailboxesReleaseMessage409.pipe(HttpApiSchema.status(409)),
+		MailboxesReleaseMessage422.pipe(HttpApiSchema.status(422)),
+		MailboxesReleaseMessage500,
+		MailboxesReleaseMessage504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.releaseMessage").annotate(OpenApi.Summary, "Release a quarantined message").annotate(OpenApi.Description, "Delivers a quarantined message into the thread it would have joined and publishes one `mailbox.message.released` event. Releasing it again returns the same result and publishes nothing. Only a person can release; API keys never hold `quarantine.release`. Isolated (malware) messages and discarded messages cannot be released: 409."), HttpApiEndpoint.post("mailboxesReply", "/v1/mailboxes/:id/messages/:messageId/reply", {
+	params: MailboxesReplyPathParams,
+	headers: MailboxesReplyHeaders,
+	payload: MailboxesReplyRequestJson,
+	success: [MailboxesReply200, MailboxesReply202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesReply401.pipe(HttpApiSchema.status(401)),
+		MailboxesReply402.pipe(HttpApiSchema.status(402)),
+		MailboxesReply403.pipe(HttpApiSchema.status(403)),
+		MailboxesReply404.pipe(HttpApiSchema.status(404)),
+		MailboxesReply409.pipe(HttpApiSchema.status(409)),
+		MailboxesReply422.pipe(HttpApiSchema.status(422)),
+		MailboxesReply429.pipe(HttpApiSchema.status(429)),
+		MailboxesReply500,
+		MailboxesReply502.pipe(HttpApiSchema.status(502)),
+		MailboxesReply503.pipe(HttpApiSchema.status(503)),
+		MailboxesReply504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.reply").annotate(OpenApi.Summary, "Reply to a message").annotate(OpenApi.Description, "Replies to the message's Reply-To address, or its sender, in the same thread and from the thread's endpoint. The server sets the recipients, subject, and threading headers. The body's `channel` must match the thread's."), HttpApiEndpoint.post("mailboxesReplyAll", "/v1/mailboxes/:id/messages/:messageId/reply-all", {
+	params: MailboxesReplyAllPathParams,
+	headers: MailboxesReplyAllHeaders,
+	payload: MailboxesReplyAllRequestJson,
+	success: [MailboxesReplyAll200, MailboxesReplyAll202.pipe(HttpApiSchema.status(202))],
+	error: [
+		MailboxesReplyAll401.pipe(HttpApiSchema.status(401)),
+		MailboxesReplyAll402.pipe(HttpApiSchema.status(402)),
+		MailboxesReplyAll403.pipe(HttpApiSchema.status(403)),
+		MailboxesReplyAll404.pipe(HttpApiSchema.status(404)),
+		MailboxesReplyAll409.pipe(HttpApiSchema.status(409)),
+		MailboxesReplyAll422.pipe(HttpApiSchema.status(422)),
+		MailboxesReplyAll429.pipe(HttpApiSchema.status(429)),
+		MailboxesReplyAll500,
+		MailboxesReplyAll502.pipe(HttpApiSchema.status(502)),
+		MailboxesReplyAll503.pipe(HttpApiSchema.status(503)),
+		MailboxesReplyAll504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.replyAll").annotate(OpenApi.Summary, "Reply to all recipients of a message").annotate(OpenApi.Description, "Replies to the sender and every other recipient of the message except the mailbox itself, in the same thread and from the thread's endpoint."), HttpApiEndpoint.post("mailboxesPause", "/v1/mailboxes/:id/pause", {
+	params: MailboxesPausePathParams,
+	success: MailboxesPause200,
+	error: [
+		MailboxesPause401.pipe(HttpApiSchema.status(401)),
+		MailboxesPause403.pipe(HttpApiSchema.status(403)),
+		MailboxesPause404.pipe(HttpApiSchema.status(404)),
+		MailboxesPause422.pipe(HttpApiSchema.status(422)),
+		MailboxesPause500,
+		MailboxesPause504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.pause").annotate(OpenApi.Summary, "Pause a mailbox").annotate(OpenApi.Description, "Stops the mailbox sending and stops new inbound mail reaching it. Mail that arrives while it is paused is not added when it resumes. Resume it with `POST /v1/mailboxes/{id}/resume`."), HttpApiEndpoint.get("mailboxesListPolicies", "/v1/mailboxes/:id/policies", {
+	params: MailboxesListPoliciesPathParams,
+	success: MailboxesListPolicies200,
+	error: [
+		MailboxesListPolicies401.pipe(HttpApiSchema.status(401)),
+		MailboxesListPolicies403.pipe(HttpApiSchema.status(403)),
+		MailboxesListPolicies404.pipe(HttpApiSchema.status(404)),
+		MailboxesListPolicies422.pipe(HttpApiSchema.status(422)),
+		MailboxesListPolicies500,
+		MailboxesListPolicies504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listPolicies").annotate(OpenApi.Summary, "List mailbox policies").annotate(OpenApi.Description, "Returns every send policy on a mailbox, oldest first. A mailbox holds at most 20 policies, so the list is never paged. Each enabled policy holds (`requireApproval`) or refuses (`deny`) every send from the mailbox; `deny` wins when both apply."), HttpApiEndpoint.post("mailboxesCreatePolicy", "/v1/mailboxes/:id/policies", {
+	params: MailboxesCreatePolicyPathParams,
+	payload: MailboxesCreatePolicyRequestJson,
+	success: MailboxesCreatePolicy201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCreatePolicy401.pipe(HttpApiSchema.status(401)),
+		MailboxesCreatePolicy403.pipe(HttpApiSchema.status(403)),
+		MailboxesCreatePolicy404.pipe(HttpApiSchema.status(404)),
+		MailboxesCreatePolicy409.pipe(HttpApiSchema.status(409)),
+		MailboxesCreatePolicy422.pipe(HttpApiSchema.status(422)),
+		MailboxesCreatePolicy500,
+		MailboxesCreatePolicy504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.createPolicy").annotate(OpenApi.Summary, "Create a mailbox policy").annotate(OpenApi.Description, "Adds a send policy to a mailbox and returns it with status 201. It applies to every send proposed after it is created, whoever proposes it. A mailbox that already holds 20 policies conflicts."), HttpApiEndpoint.get("mailboxesGetPolicy", "/v1/mailboxes/:id/policies/:policyId", {
+	params: MailboxesGetPolicyPathParams,
+	success: MailboxesGetPolicy200,
+	error: [
+		MailboxesGetPolicy401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetPolicy403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetPolicy404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetPolicy422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetPolicy500,
+		MailboxesGetPolicy504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getPolicy").annotate(OpenApi.Summary, "Get a mailbox policy").annotate(OpenApi.Description, "Returns one send policy."), HttpApiEndpoint.delete("mailboxesDeletePolicy", "/v1/mailboxes/:id/policies/:policyId", {
+	params: MailboxesDeletePolicyPathParams,
+	success: MailboxesDeletePolicy200,
+	error: [
+		MailboxesDeletePolicy401.pipe(HttpApiSchema.status(401)),
+		MailboxesDeletePolicy403.pipe(HttpApiSchema.status(403)),
+		MailboxesDeletePolicy404.pipe(HttpApiSchema.status(404)),
+		MailboxesDeletePolicy422.pipe(HttpApiSchema.status(422)),
+		MailboxesDeletePolicy500,
+		MailboxesDeletePolicy504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.deletePolicy").annotate(OpenApi.Summary, "Delete a mailbox policy").annotate(OpenApi.Description, "Deletes a send policy. Sends it already holds stay held until a person approves or denies them."), HttpApiEndpoint.patch("mailboxesUpdatePolicy", "/v1/mailboxes/:id/policies/:policyId", {
+	params: MailboxesUpdatePolicyPathParams,
+	payload: MailboxesUpdatePolicyRequestJson,
+	success: MailboxesUpdatePolicy200,
+	error: [
+		MailboxesUpdatePolicy401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdatePolicy403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdatePolicy404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdatePolicy422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdatePolicy500,
+		MailboxesUpdatePolicy504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.updatePolicy").annotate(OpenApi.Summary, "Update a mailbox policy").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest. Set `enabled` to `false` to stop a policy applying without deleting it."), HttpApiEndpoint.get("mailboxesListQuarantine", "/v1/mailboxes/:id/quarantine", {
+	params: MailboxesListQuarantinePathParams,
+	query: MailboxesListQuarantineQuery,
+	success: MailboxesListQuarantine200,
+	error: [
+		MailboxesListQuarantine401.pipe(HttpApiSchema.status(401)),
+		MailboxesListQuarantine403.pipe(HttpApiSchema.status(403)),
+		MailboxesListQuarantine404.pipe(HttpApiSchema.status(404)),
+		MailboxesListQuarantine422.pipe(HttpApiSchema.status(422)),
+		MailboxesListQuarantine500,
+		MailboxesListQuarantine504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listQuarantine").annotate(OpenApi.Summary, "List quarantined messages").annotate(OpenApi.Description, "Returns the messages this mailbox holds instead of delivering, most recently held first: suspected spam, phishing, fraud, or prompt injection (`quarantined`), and malware (`isolated`). Each is metadata only; a held message appears in no thread, search, or `mailbox.message.received` event until a person releases it. `after` and `before` filter by when the message was held. Needs `quarantine.read`."), HttpApiEndpoint.post("mailboxesResume", "/v1/mailboxes/:id/resume", {
+	params: MailboxesResumePathParams,
+	success: MailboxesResume200,
+	error: [
+		MailboxesResume401.pipe(HttpApiSchema.status(401)),
+		MailboxesResume403.pipe(HttpApiSchema.status(403)),
+		MailboxesResume404.pipe(HttpApiSchema.status(404)),
+		MailboxesResume422.pipe(HttpApiSchema.status(422)),
+		MailboxesResume500,
+		MailboxesResume504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.resume").annotate(OpenApi.Summary, "Resume a mailbox").annotate(OpenApi.Description, "Lets a paused mailbox send and receive again."), HttpApiEndpoint.get("mailboxesListThreads", "/v1/mailboxes/:id/threads", {
+	params: MailboxesListThreadsPathParams,
+	query: MailboxesListThreadsQuery,
+	success: MailboxesListThreads200,
+	error: [
+		MailboxesListThreads401.pipe(HttpApiSchema.status(401)),
+		MailboxesListThreads403.pipe(HttpApiSchema.status(403)),
+		MailboxesListThreads404.pipe(HttpApiSchema.status(404)),
+		MailboxesListThreads422.pipe(HttpApiSchema.status(422)),
+		MailboxesListThreads500,
+		MailboxesListThreads504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listThreads").annotate(OpenApi.Summary, "List threads in a mailbox").annotate(OpenApi.Description, "Returns thread summaries, most recent activity first. `after` and `before` filter by last activity, so an agent polling for new mail passes the last time it looked. `q` is a full-text search over subjects, senders, and message text; `folder`, `label`, `unread`, and `starred` narrow the list. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. A thread that gains activity while you page moves ahead of the cursor, so a walk lists each thread at most once."), HttpApiEndpoint.get("mailboxesGetThread", "/v1/mailboxes/:id/threads/:threadId", {
+	params: MailboxesGetThreadPathParams,
+	success: MailboxesGetThread200,
+	error: [
+		MailboxesGetThread401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetThread403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetThread404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetThread422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetThread500,
+		MailboxesGetThread504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getThread").annotate(OpenApi.Summary, "Get a mailbox thread").annotate(OpenApi.Description, "Returns a thread with its participants and where it stands. Read its messages with `GET .../threads/{threadId}/messages` and their bodies with `GET .../threads/{threadId}/content`."), HttpApiEndpoint.patch("mailboxesUpdateThread", "/v1/mailboxes/:id/threads/:threadId", {
+	params: MailboxesUpdateThreadPathParams,
+	payload: MailboxesUpdateThreadRequestJson,
+	success: MailboxesUpdateThread200,
+	error: [
+		MailboxesUpdateThread401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdateThread403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdateThread404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdateThread422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdateThread500,
+		MailboxesUpdateThread504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.updateThread").annotate(OpenApi.Summary, "Update a mailbox thread").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest. `folder` and `priority` are shared with everyone on the mailbox; `read`, `starred`, and `snoozedUntil` are the caller's own. Labels are not updated here: use `POST` and `DELETE` on `/v1/mailboxes/{id}/threads/{threadId}/labels`. Returns where the thread stands, not its messages: read those with `GET .../threads/{threadId}`."), HttpApiEndpoint.get("mailboxesGetThreadContent", "/v1/mailboxes/:id/threads/:threadId/content", {
+	params: MailboxesGetThreadContentPathParams,
+	query: MailboxesGetThreadContentQuery,
+	success: MailboxesGetThreadContent200,
+	error: [
+		MailboxesGetThreadContent401.pipe(HttpApiSchema.status(401)),
+		MailboxesGetThreadContent403.pipe(HttpApiSchema.status(403)),
+		MailboxesGetThreadContent404.pipe(HttpApiSchema.status(404)),
+		MailboxesGetThreadContent422.pipe(HttpApiSchema.status(422)),
+		MailboxesGetThreadContent500,
+		MailboxesGetThreadContent504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.getThreadContent").annotate(OpenApi.Summary, "Read a mailbox thread").annotate(OpenApi.Description, "Returns the thread's messages with their text, sanitized HTML, `replyText` (what each sender wrote, without quoted history), authentication verdicts, and attachments, oldest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("mailboxesAddThreadLabels", "/v1/mailboxes/:id/threads/:threadId/labels", {
+	params: MailboxesAddThreadLabelsPathParams,
+	payload: MailboxesAddThreadLabelsRequestJson,
+	success: MailboxesAddThreadLabels200,
+	error: [
+		MailboxesAddThreadLabels401.pipe(HttpApiSchema.status(401)),
+		MailboxesAddThreadLabels403.pipe(HttpApiSchema.status(403)),
+		MailboxesAddThreadLabels404.pipe(HttpApiSchema.status(404)),
+		MailboxesAddThreadLabels422.pipe(HttpApiSchema.status(422)),
+		MailboxesAddThreadLabels500,
+		MailboxesAddThreadLabels504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.addThreadLabels").annotate(OpenApi.Summary, "Add thread labels").annotate(OpenApi.Description, "Adds the given mailbox labels to the thread, keeping the labels it already has, and returns where the thread stands. Every id must be one of the mailbox's labels."), HttpApiEndpoint.delete("mailboxesRemoveThreadLabels", "/v1/mailboxes/:id/threads/:threadId/labels", {
+	params: MailboxesRemoveThreadLabelsPathParams,
+	payload: MailboxesRemoveThreadLabelsRequestJson,
+	success: MailboxesRemoveThreadLabels200,
+	error: [
+		MailboxesRemoveThreadLabels401.pipe(HttpApiSchema.status(401)),
+		MailboxesRemoveThreadLabels403.pipe(HttpApiSchema.status(403)),
+		MailboxesRemoveThreadLabels404.pipe(HttpApiSchema.status(404)),
+		MailboxesRemoveThreadLabels422.pipe(HttpApiSchema.status(422)),
+		MailboxesRemoveThreadLabels500,
+		MailboxesRemoveThreadLabels504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.removeThreadLabels").annotate(OpenApi.Summary, "Remove thread labels").annotate(OpenApi.Description, "Removes the given labels from the thread and returns where the thread stands. A label the thread does not carry is ignored."), HttpApiEndpoint.get("mailboxesListThreadMessages", "/v1/mailboxes/:id/threads/:threadId/messages", {
+	params: MailboxesListThreadMessagesPathParams,
+	query: MailboxesListThreadMessagesQuery,
+	success: MailboxesListThreadMessages200,
+	error: [
+		MailboxesListThreadMessages401.pipe(HttpApiSchema.status(401)),
+		MailboxesListThreadMessages403.pipe(HttpApiSchema.status(403)),
+		MailboxesListThreadMessages404.pipe(HttpApiSchema.status(404)),
+		MailboxesListThreadMessages422.pipe(HttpApiSchema.status(422)),
+		MailboxesListThreadMessages500,
+		MailboxesListThreadMessages504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listThreadMessages").annotate(OpenApi.Summary, "List messages in a mailbox thread").annotate(OpenApi.Description, "Returns the thread's message summaries, oldest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. Read the bodies with `GET .../threads/{threadId}/content` or one message with `GET /v1/mailboxes/{id}/messages/{messageId}`."), HttpApiEndpoint.get("mailboxesListThreadNotes", "/v1/mailboxes/:id/threads/:threadId/notes", {
+	params: MailboxesListThreadNotesPathParams,
+	query: MailboxesListThreadNotesQuery,
+	success: MailboxesListThreadNotes200,
+	error: [
+		MailboxesListThreadNotes401.pipe(HttpApiSchema.status(401)),
+		MailboxesListThreadNotes403.pipe(HttpApiSchema.status(403)),
+		MailboxesListThreadNotes404.pipe(HttpApiSchema.status(404)),
+		MailboxesListThreadNotes422.pipe(HttpApiSchema.status(422)),
+		MailboxesListThreadNotes500,
+		MailboxesListThreadNotes504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.listThreadNotes").annotate(OpenApi.Summary, "List notes in a mailbox thread").annotate(OpenApi.Description, "Returns the internal notes on a thread with their bodies, oldest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("mailboxesCreateNote", "/v1/mailboxes/:id/threads/:threadId/notes", {
+	params: MailboxesCreateNotePathParams,
+	payload: MailboxesCreateNoteRequestJson,
+	success: MailboxesCreateNote201.pipe(HttpApiSchema.status(201)),
+	error: [
+		MailboxesCreateNote401.pipe(HttpApiSchema.status(401)),
+		MailboxesCreateNote403.pipe(HttpApiSchema.status(403)),
+		MailboxesCreateNote404.pipe(HttpApiSchema.status(404)),
+		MailboxesCreateNote422.pipe(HttpApiSchema.status(422)),
+		MailboxesCreateNote500,
+		MailboxesCreateNote504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.createNote").annotate(OpenApi.Summary, "Create a mailbox note").annotate(OpenApi.Description, "Adds an internal note to a thread and returns it with status 201. Notes are visible to everyone on the mailbox and never sent."), HttpApiEndpoint.delete("mailboxesDeleteNote", "/v1/mailboxes/:id/threads/:threadId/notes/:noteId", {
+	params: MailboxesDeleteNotePathParams,
+	success: MailboxesDeleteNote200,
+	error: [
+		MailboxesDeleteNote401.pipe(HttpApiSchema.status(401)),
+		MailboxesDeleteNote403.pipe(HttpApiSchema.status(403)),
+		MailboxesDeleteNote404.pipe(HttpApiSchema.status(404)),
+		MailboxesDeleteNote422.pipe(HttpApiSchema.status(422)),
+		MailboxesDeleteNote500,
+		MailboxesDeleteNote504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.deleteNote").annotate(OpenApi.Summary, "Delete a mailbox note").annotate(OpenApi.Description, "Deletes a note. Only the note's author may."), HttpApiEndpoint.patch("mailboxesUpdateNote", "/v1/mailboxes/:id/threads/:threadId/notes/:noteId", {
+	params: MailboxesUpdateNotePathParams,
+	payload: MailboxesUpdateNoteRequestJson,
+	success: MailboxesUpdateNote200,
+	error: [
+		MailboxesUpdateNote401.pipe(HttpApiSchema.status(401)),
+		MailboxesUpdateNote403.pipe(HttpApiSchema.status(403)),
+		MailboxesUpdateNote404.pipe(HttpApiSchema.status(404)),
+		MailboxesUpdateNote422.pipe(HttpApiSchema.status(422)),
+		MailboxesUpdateNote500,
+		MailboxesUpdateNote504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "mailboxes.updateNote").annotate(OpenApi.Summary, "Update a mailbox note").annotate(OpenApi.Description, "Updates the fields you name and keeps the rest. Only the note's author may.")).annotate(OpenApi.Description, "Mailboxes: endpoints, threads, messages, drafts, and governed sends") {};
+//#endregion
+export { Mailbox, MailboxAction, MailboxActionPage, MailboxAgentActivity, MailboxCopiedAttachment, MailboxDownloadUrl, MailboxDraft, MailboxDraftPage, MailboxDraftState, MailboxDraftSummary, MailboxEndpoint, MailboxEvent, MailboxEventId, MailboxEventPage, MailboxFolderCount, MailboxFolderCountList, MailboxGrant, MailboxGrantId, MailboxGrantPage, MailboxLabel, MailboxLabelList, MailboxMessage, MailboxMessageAuthentication, MailboxMessagePage, MailboxMessageRecipient, MailboxMessageSender, MailboxMessageSummary, MailboxNonSendAction, MailboxNote, MailboxNoteId, MailboxNotePage, MailboxPage, MailboxPendingAction, MailboxPendingSendReceipt, MailboxPolicy, MailboxPolicyList, MailboxQuarantinePage, MailboxQuarantinedMessage, MailboxSendAction, MailboxSendSnapshot, MailboxStatus, MailboxSummary, MailboxThread, MailboxThreadContentPage, MailboxThreadPage, MailboxThreadParticipant, MailboxThreadSender, MailboxThreadState, MailboxThreadSummary, MailboxesAddThreadLabels200, MailboxesAddThreadLabels401, MailboxesAddThreadLabels403, MailboxesAddThreadLabels404, MailboxesAddThreadLabels422, MailboxesAddThreadLabels500, MailboxesAddThreadLabels504, MailboxesAddThreadLabelsPathParams, MailboxesAddThreadLabelsRequestJson, MailboxesApproveAction200, MailboxesApproveAction202, MailboxesApproveAction401, MailboxesApproveAction402, MailboxesApproveAction403, MailboxesApproveAction404, MailboxesApproveAction409, MailboxesApproveAction422, MailboxesApproveAction429, MailboxesApproveAction500, MailboxesApproveAction502, MailboxesApproveAction503, MailboxesApproveAction504, MailboxesApproveActionPathParams, MailboxesCancelAction200, MailboxesCancelAction202, MailboxesCancelAction401, MailboxesCancelAction402, MailboxesCancelAction403, MailboxesCancelAction404, MailboxesCancelAction409, MailboxesCancelAction422, MailboxesCancelAction429, MailboxesCancelAction500, MailboxesCancelAction502, MailboxesCancelAction503, MailboxesCancelAction504, MailboxesCancelActionPathParams, MailboxesCopyMessageAttachment201, MailboxesCopyMessageAttachment401, MailboxesCopyMessageAttachment403, MailboxesCopyMessageAttachment404, MailboxesCopyMessageAttachment409, MailboxesCopyMessageAttachment422, MailboxesCopyMessageAttachment500, MailboxesCopyMessageAttachment504, MailboxesCopyMessageAttachmentPathParams, MailboxesCreate201, MailboxesCreate401, MailboxesCreate402, MailboxesCreate403, MailboxesCreate404, MailboxesCreate409, MailboxesCreate422, MailboxesCreate500, MailboxesCreate502, MailboxesCreate504, MailboxesCreateDraft201, MailboxesCreateDraft401, MailboxesCreateDraft403, MailboxesCreateDraft404, MailboxesCreateDraft422, MailboxesCreateDraft500, MailboxesCreateDraft504, MailboxesCreateDraftPathParams, MailboxesCreateDraftRequestJson, MailboxesCreateEndpoint201, MailboxesCreateEndpoint401, MailboxesCreateEndpoint403, MailboxesCreateEndpoint404, MailboxesCreateEndpoint409, MailboxesCreateEndpoint422, MailboxesCreateEndpoint500, MailboxesCreateEndpoint504, MailboxesCreateEndpointPathParams, MailboxesCreateEndpointRequestJson, MailboxesCreateGrant201, MailboxesCreateGrant401, MailboxesCreateGrant403, MailboxesCreateGrant404, MailboxesCreateGrant409, MailboxesCreateGrant422, MailboxesCreateGrant500, MailboxesCreateGrant504, MailboxesCreateGrantPathParams, MailboxesCreateGrantRequestJson, MailboxesCreateLabel201, MailboxesCreateLabel401, MailboxesCreateLabel403, MailboxesCreateLabel404, MailboxesCreateLabel409, MailboxesCreateLabel422, MailboxesCreateLabel500, MailboxesCreateLabel504, MailboxesCreateLabelPathParams, MailboxesCreateLabelRequestJson, MailboxesCreateNote201, MailboxesCreateNote401, MailboxesCreateNote403, MailboxesCreateNote404, MailboxesCreateNote422, MailboxesCreateNote500, MailboxesCreateNote504, MailboxesCreateNotePathParams, MailboxesCreateNoteRequestJson, MailboxesCreatePolicy201, MailboxesCreatePolicy401, MailboxesCreatePolicy403, MailboxesCreatePolicy404, MailboxesCreatePolicy409, MailboxesCreatePolicy422, MailboxesCreatePolicy500, MailboxesCreatePolicy504, MailboxesCreatePolicyPathParams, MailboxesCreatePolicyRequestJson, MailboxesCreateRequestJson, MailboxesDeleteDraft200, MailboxesDeleteDraft401, MailboxesDeleteDraft403, MailboxesDeleteDraft404, MailboxesDeleteDraft422, MailboxesDeleteDraft500, MailboxesDeleteDraft504, MailboxesDeleteDraftPathParams, MailboxesDeleteLabel200, MailboxesDeleteLabel401, MailboxesDeleteLabel403, MailboxesDeleteLabel404, MailboxesDeleteLabel422, MailboxesDeleteLabel500, MailboxesDeleteLabel504, MailboxesDeleteLabelPathParams, MailboxesDeleteNote200, MailboxesDeleteNote401, MailboxesDeleteNote403, MailboxesDeleteNote404, MailboxesDeleteNote422, MailboxesDeleteNote500, MailboxesDeleteNote504, MailboxesDeleteNotePathParams, MailboxesDeletePolicy200, MailboxesDeletePolicy401, MailboxesDeletePolicy403, MailboxesDeletePolicy404, MailboxesDeletePolicy422, MailboxesDeletePolicy500, MailboxesDeletePolicy504, MailboxesDeletePolicyPathParams, MailboxesDenyAction200, MailboxesDenyAction401, MailboxesDenyAction403, MailboxesDenyAction404, MailboxesDenyAction409, MailboxesDenyAction422, MailboxesDenyAction500, MailboxesDenyAction504, MailboxesDenyActionPathParams, MailboxesDenyActionRequestJson, MailboxesDiscardMessage200, MailboxesDiscardMessage401, MailboxesDiscardMessage403, MailboxesDiscardMessage404, MailboxesDiscardMessage409, MailboxesDiscardMessage422, MailboxesDiscardMessage500, MailboxesDiscardMessage502, MailboxesDiscardMessage504, MailboxesDiscardMessagePathParams, MailboxesForward200, MailboxesForward202, MailboxesForward401, MailboxesForward402, MailboxesForward403, MailboxesForward404, MailboxesForward409, MailboxesForward422, MailboxesForward429, MailboxesForward500, MailboxesForward502, MailboxesForward503, MailboxesForward504, MailboxesForwardHeaders, MailboxesForwardPathParams, MailboxesForwardRequestJson, MailboxesGet200, MailboxesGet401, MailboxesGet403, MailboxesGet404, MailboxesGet422, MailboxesGet500, MailboxesGet504, MailboxesGetAction200, MailboxesGetAction401, MailboxesGetAction403, MailboxesGetAction404, MailboxesGetAction422, MailboxesGetAction500, MailboxesGetAction504, MailboxesGetActionPathParams, MailboxesGetAgentActivity200, MailboxesGetAgentActivity401, MailboxesGetAgentActivity403, MailboxesGetAgentActivity404, MailboxesGetAgentActivity422, MailboxesGetAgentActivity500, MailboxesGetAgentActivity504, MailboxesGetAgentActivityPathParams, MailboxesGetAgentActivityQuery, MailboxesGetDraft200, MailboxesGetDraft401, MailboxesGetDraft403, MailboxesGetDraft404, MailboxesGetDraft422, MailboxesGetDraft500, MailboxesGetDraft504, MailboxesGetDraftPathParams, MailboxesGetMessage200, MailboxesGetMessage401, MailboxesGetMessage403, MailboxesGetMessage404, MailboxesGetMessage422, MailboxesGetMessage500, MailboxesGetMessage504, MailboxesGetMessageAttachment200, MailboxesGetMessageAttachment401, MailboxesGetMessageAttachment403, MailboxesGetMessageAttachment404, MailboxesGetMessageAttachment422, MailboxesGetMessageAttachment500, MailboxesGetMessageAttachment504, MailboxesGetMessageAttachmentPathParams, MailboxesGetMessagePathParams, MailboxesGetMessageRaw200, MailboxesGetMessageRaw401, MailboxesGetMessageRaw403, MailboxesGetMessageRaw404, MailboxesGetMessageRaw422, MailboxesGetMessageRaw500, MailboxesGetMessageRaw504, MailboxesGetMessageRawPathParams, MailboxesGetPathParams, MailboxesGetPolicy200, MailboxesGetPolicy401, MailboxesGetPolicy403, MailboxesGetPolicy404, MailboxesGetPolicy422, MailboxesGetPolicy500, MailboxesGetPolicy504, MailboxesGetPolicyPathParams, MailboxesGetThread200, MailboxesGetThread401, MailboxesGetThread403, MailboxesGetThread404, MailboxesGetThread422, MailboxesGetThread500, MailboxesGetThread504, MailboxesGetThreadContent200, MailboxesGetThreadContent401, MailboxesGetThreadContent403, MailboxesGetThreadContent404, MailboxesGetThreadContent422, MailboxesGetThreadContent500, MailboxesGetThreadContent504, MailboxesGetThreadContentPathParams, MailboxesGetThreadContentQuery, MailboxesGetThreadPathParams, MailboxesGroup, MailboxesList200, MailboxesList401, MailboxesList403, MailboxesList422, MailboxesList500, MailboxesList504, MailboxesListActions200, MailboxesListActions401, MailboxesListActions403, MailboxesListActions404, MailboxesListActions422, MailboxesListActions500, MailboxesListActions504, MailboxesListActionsPathParams, MailboxesListActionsQuery, MailboxesListDrafts200, MailboxesListDrafts401, MailboxesListDrafts403, MailboxesListDrafts404, MailboxesListDrafts422, MailboxesListDrafts500, MailboxesListDrafts504, MailboxesListDraftsPathParams, MailboxesListDraftsQuery, MailboxesListEvents200, MailboxesListEvents401, MailboxesListEvents403, MailboxesListEvents404, MailboxesListEvents422, MailboxesListEvents500, MailboxesListEvents504, MailboxesListEventsPathParams, MailboxesListEventsQuery, MailboxesListFolders200, MailboxesListFolders401, MailboxesListFolders403, MailboxesListFolders404, MailboxesListFolders422, MailboxesListFolders500, MailboxesListFolders504, MailboxesListFoldersPathParams, MailboxesListGrants200, MailboxesListGrants401, MailboxesListGrants403, MailboxesListGrants404, MailboxesListGrants422, MailboxesListGrants500, MailboxesListGrants504, MailboxesListGrantsPathParams, MailboxesListGrantsQuery, MailboxesListLabels200, MailboxesListLabels401, MailboxesListLabels403, MailboxesListLabels404, MailboxesListLabels422, MailboxesListLabels500, MailboxesListLabels504, MailboxesListLabelsPathParams, MailboxesListPolicies200, MailboxesListPolicies401, MailboxesListPolicies403, MailboxesListPolicies404, MailboxesListPolicies422, MailboxesListPolicies500, MailboxesListPolicies504, MailboxesListPoliciesPathParams, MailboxesListQuarantine200, MailboxesListQuarantine401, MailboxesListQuarantine403, MailboxesListQuarantine404, MailboxesListQuarantine422, MailboxesListQuarantine500, MailboxesListQuarantine504, MailboxesListQuarantinePathParams, MailboxesListQuarantineQuery, MailboxesListQuery, MailboxesListThreadMessages200, MailboxesListThreadMessages401, MailboxesListThreadMessages403, MailboxesListThreadMessages404, MailboxesListThreadMessages422, MailboxesListThreadMessages500, MailboxesListThreadMessages504, MailboxesListThreadMessagesPathParams, MailboxesListThreadMessagesQuery, MailboxesListThreadNotes200, MailboxesListThreadNotes401, MailboxesListThreadNotes403, MailboxesListThreadNotes404, MailboxesListThreadNotes422, MailboxesListThreadNotes500, MailboxesListThreadNotes504, MailboxesListThreadNotesPathParams, MailboxesListThreadNotesQuery, MailboxesListThreads200, MailboxesListThreads401, MailboxesListThreads403, MailboxesListThreads404, MailboxesListThreads422, MailboxesListThreads500, MailboxesListThreads504, MailboxesListThreadsPathParams, MailboxesListThreadsQuery, MailboxesPause200, MailboxesPause401, MailboxesPause403, MailboxesPause404, MailboxesPause422, MailboxesPause500, MailboxesPause504, MailboxesPausePathParams, MailboxesReleaseMessage200, MailboxesReleaseMessage401, MailboxesReleaseMessage403, MailboxesReleaseMessage404, MailboxesReleaseMessage409, MailboxesReleaseMessage422, MailboxesReleaseMessage500, MailboxesReleaseMessage504, MailboxesReleaseMessagePathParams, MailboxesRemove200, MailboxesRemove401, MailboxesRemove403, MailboxesRemove404, MailboxesRemove422, MailboxesRemove500, MailboxesRemove502, MailboxesRemove504, MailboxesRemoveEndpoint200, MailboxesRemoveEndpoint401, MailboxesRemoveEndpoint403, MailboxesRemoveEndpoint404, MailboxesRemoveEndpoint422, MailboxesRemoveEndpoint500, MailboxesRemoveEndpoint504, MailboxesRemoveEndpointPathParams, MailboxesRemovePathParams, MailboxesRemoveThreadLabels200, MailboxesRemoveThreadLabels401, MailboxesRemoveThreadLabels403, MailboxesRemoveThreadLabels404, MailboxesRemoveThreadLabels422, MailboxesRemoveThreadLabels500, MailboxesRemoveThreadLabels504, MailboxesRemoveThreadLabelsPathParams, MailboxesRemoveThreadLabelsRequestJson, MailboxesReply200, MailboxesReply202, MailboxesReply401, MailboxesReply402, MailboxesReply403, MailboxesReply404, MailboxesReply409, MailboxesReply422, MailboxesReply429, MailboxesReply500, MailboxesReply502, MailboxesReply503, MailboxesReply504, MailboxesReplyAll200, MailboxesReplyAll202, MailboxesReplyAll401, MailboxesReplyAll402, MailboxesReplyAll403, MailboxesReplyAll404, MailboxesReplyAll409, MailboxesReplyAll422, MailboxesReplyAll429, MailboxesReplyAll500, MailboxesReplyAll502, MailboxesReplyAll503, MailboxesReplyAll504, MailboxesReplyAllHeaders, MailboxesReplyAllPathParams, MailboxesReplyAllRequestJson, MailboxesReplyHeaders, MailboxesReplyPathParams, MailboxesReplyRequestJson, MailboxesResume200, MailboxesResume401, MailboxesResume403, MailboxesResume404, MailboxesResume422, MailboxesResume500, MailboxesResume504, MailboxesResumePathParams, MailboxesRetryAction200, MailboxesRetryAction202, MailboxesRetryAction401, MailboxesRetryAction402, MailboxesRetryAction403, MailboxesRetryAction404, MailboxesRetryAction409, MailboxesRetryAction422, MailboxesRetryAction429, MailboxesRetryAction500, MailboxesRetryAction502, MailboxesRetryAction503, MailboxesRetryAction504, MailboxesRetryActionPathParams, MailboxesRevokeGrant200, MailboxesRevokeGrant401, MailboxesRevokeGrant403, MailboxesRevokeGrant404, MailboxesRevokeGrant409, MailboxesRevokeGrant422, MailboxesRevokeGrant500, MailboxesRevokeGrant504, MailboxesRevokeGrantPathParams, MailboxesSendDraft200, MailboxesSendDraft202, MailboxesSendDraft401, MailboxesSendDraft402, MailboxesSendDraft403, MailboxesSendDraft404, MailboxesSendDraft409, MailboxesSendDraft422, MailboxesSendDraft429, MailboxesSendDraft500, MailboxesSendDraft502, MailboxesSendDraft503, MailboxesSendDraft504, MailboxesSendDraftHeaders, MailboxesSendDraftPathParams, MailboxesSendMessage200, MailboxesSendMessage202, MailboxesSendMessage401, MailboxesSendMessage402, MailboxesSendMessage403, MailboxesSendMessage404, MailboxesSendMessage409, MailboxesSendMessage422, MailboxesSendMessage429, MailboxesSendMessage500, MailboxesSendMessage502, MailboxesSendMessage503, MailboxesSendMessage504, MailboxesSendMessageHeaders, MailboxesSendMessagePathParams, MailboxesSendMessageRequestJson, MailboxesUpdate200, MailboxesUpdate401, MailboxesUpdate403, MailboxesUpdate404, MailboxesUpdate422, MailboxesUpdate500, MailboxesUpdate504, MailboxesUpdateDraft200, MailboxesUpdateDraft401, MailboxesUpdateDraft403, MailboxesUpdateDraft404, MailboxesUpdateDraft409, MailboxesUpdateDraft422, MailboxesUpdateDraft500, MailboxesUpdateDraft504, MailboxesUpdateDraftPathParams, MailboxesUpdateDraftRequestJson, MailboxesUpdateEndpoint200, MailboxesUpdateEndpoint401, MailboxesUpdateEndpoint403, MailboxesUpdateEndpoint404, MailboxesUpdateEndpoint422, MailboxesUpdateEndpoint500, MailboxesUpdateEndpoint504, MailboxesUpdateEndpointPathParams, MailboxesUpdateEndpointRequestJson, MailboxesUpdateGrant200, MailboxesUpdateGrant401, MailboxesUpdateGrant403, MailboxesUpdateGrant404, MailboxesUpdateGrant409, MailboxesUpdateGrant422, MailboxesUpdateGrant500, MailboxesUpdateGrant504, MailboxesUpdateGrantPathParams, MailboxesUpdateGrantRequestJson, MailboxesUpdateLabel200, MailboxesUpdateLabel401, MailboxesUpdateLabel403, MailboxesUpdateLabel404, MailboxesUpdateLabel422, MailboxesUpdateLabel500, MailboxesUpdateLabel504, MailboxesUpdateLabelPathParams, MailboxesUpdateLabelRequestJson, MailboxesUpdateNote200, MailboxesUpdateNote401, MailboxesUpdateNote403, MailboxesUpdateNote404, MailboxesUpdateNote422, MailboxesUpdateNote500, MailboxesUpdateNote504, MailboxesUpdateNotePathParams, MailboxesUpdateNoteRequestJson, MailboxesUpdatePathParams, MailboxesUpdatePolicy200, MailboxesUpdatePolicy401, MailboxesUpdatePolicy403, MailboxesUpdatePolicy404, MailboxesUpdatePolicy422, MailboxesUpdatePolicy500, MailboxesUpdatePolicy504, MailboxesUpdatePolicyPathParams, MailboxesUpdatePolicyRequestJson, MailboxesUpdateRequestJson, MailboxesUpdateThread200, MailboxesUpdateThread401, MailboxesUpdateThread403, MailboxesUpdateThread404, MailboxesUpdateThread422, MailboxesUpdateThread500, MailboxesUpdateThread504, MailboxesUpdateThreadPathParams, MailboxesUpdateThreadRequestJson };
+
+//# sourceMappingURL=mailboxes.js.map