@sendmux/management 0.0.0-bootstrap.0

package/dist/generated/types.gen.d.ts

@@ -0,0 +1,2927 @@
+export type ClientOptions = {
+    baseUrl: 'https://app.sendmux.ai/api/v1' | (string & {});
+};
+export type WebhookUpdateBody = {
+    /**
+     * When toggled from false to true, also clears the `failing` flag — retry deliveries resume on the next matching event.
+     */
+    enabled?: boolean;
+    /**
+     * Replaces the full event-type list. At least one must be provided.
+     */
+    event_types?: Array<'message.delivered' | 'message.bounced' | 'message.complained' | 'message.rejected' | 'message.delivery_delayed' | 'message.received' | 'message.received.spam' | 'sendmux.test'>;
+    filters?: WebhookFilters & unknown;
+    /**
+     * Replace the human-friendly label. Send `null` to clear it; omit to leave unchanged.
+     */
+    name?: string | null;
+    /**
+     * New HTTPS endpoint. Must be https://.
+     */
+    url?: string;
+};
+/**
+ * Optional delivery scope. Empty mailbox_ids means all team mailboxes.
+ */
+export type WebhookFilters = {
+    /**
+     * Mailbox public IDs to receive events for. Empty means all mailboxes in the team.
+     */
+    mailbox_ids: Array<string>;
+};
+export type WebhookTestResponse = {
+    /**
+     * The event_id attached to the X-Sendmux-Event-Id header of the test delivery.
+     */
+    event_id: string;
+};
+export type WebhookSubscriptionWithSecretResponse = SuccessEnvelope & {
+    data: WebhookSubscriptionWithSecret;
+    meta?: ResponseMeta;
+};
+export type ResponseMeta = {
+    request_id: string;
+};
+export type WebhookSubscription = {
+    /**
+     * ISO 8601 creation timestamp
+     */
+    created_at: string;
+    /**
+     * When false, no events are delivered to this subscription.
+     */
+    enabled: boolean;
+    /**
+     * Event types this subscription receives.
+     */
+    event_types: Array<'message.delivered' | 'message.bounced' | 'message.complained' | 'message.rejected' | 'message.delivery_delayed' | 'message.received' | 'message.received.spam' | 'sendmux.test'>;
+    /**
+     * True when the 24-hour retry window has been exhausted for this subscription. Reset by updating the subscription (e.g. fixing the URL) and re-enabling.
+     */
+    failing: boolean;
+    filters: WebhookFilters;
+    /**
+     * Webhook public ID
+     */
+    id: string;
+    /**
+     * Optional human-friendly label used in dashboard list/detail pages. May be `null` for subscriptions created without a name.
+     */
+    name: string | null;
+    /**
+     * ISO 8601 last-modified timestamp
+     */
+    updated_at: string;
+    /**
+     * HTTPS endpoint that receives signed event POSTs.
+     */
+    url: string;
+};
+export type WebhookSubscriptionWithSecret = WebhookSubscription & {
+    /**
+     * Signing secret used to verify the HMAC-SHA256 signature on every event POST. This is the ONLY response containing the raw secret — store it securely; it cannot be retrieved later. Use POST /webhooks/{id}/rotate-secret to issue a new one.
+     */
+    secret: string;
+};
+export type SuccessEnvelope = {
+    meta: {
+        [key: string]: unknown;
+    };
+    ok: true;
+};
+export type WebhookSubscriptionResponse = SuccessEnvelope & {
+    data: WebhookSubscription;
+    meta?: ResponseMeta;
+};
+export type WebhookSubscriptionCursorListResponse = SuccessEnvelope & {
+    data: Array<WebhookSubscription>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type CursorPagination = {
+    has_more: boolean;
+    next_cursor?: string;
+};
+/**
+ * The JSON request body delivered to the webhook endpoint.
+ */
+export type WebhookEventPayload = {
+    data: WebhookEventData;
+    /**
+     * Stable per-event identifier. Also sent in the X-Sendmux-Event-Id header.
+     */
+    id: string;
+    /**
+     * When the event occurred.
+     */
+    occurred_at: string;
+    /**
+     * Team that owns the event.
+     */
+    team_public_id: string;
+    /**
+     * Dotted event type. Same value as the X-Sendmux-Event-Type header.
+     */
+    type: 'message.delivered' | 'message.bounced' | 'message.complained' | 'message.rejected' | 'message.delivery_delayed' | 'message.received' | 'message.received.spam' | 'sendmux.test';
+};
+export type WebhookEventData = {
+    /**
+     * More specific bounce category when available.
+     */
+    bounce_subtype: string | null;
+    /**
+     * Bounce category for `message.bounced` events.
+     */
+    bounce_type: 'Permanent' | 'Transient' | 'Undetermined';
+    /**
+     * More specific complaint category when available.
+     */
+    complaint_subtype: string | null;
+    /**
+     * Complaint category for `message.complained` events.
+     */
+    complaint_type: string | null;
+    /**
+     * When delivery retries are expected to stop, when provided.
+     */
+    delay_expires_at: string | null;
+    /**
+     * Delay category for `message.delivery_delayed` events.
+     */
+    delay_type: string | null;
+    /**
+     * Only populated for inbound mailbox events.
+     */
+    is_spam: boolean | null;
+    /**
+     * Mailbox public ID for inbound mailbox events when resolved.
+     */
+    mailbox_id: string | null;
+    /**
+     * Message identifier from the event source.
+     */
+    message_id: string | null;
+    /**
+     * `provider` for sending feedback IDs; `rfc5322` for inbound email Message-ID header values.
+     */
+    message_id_kind: 'provider' | 'rfc5322';
+    /**
+     * All affected recipients. Empty for synthetic test events.
+     */
+    recipients: Array<string>;
+    /**
+     * Reject reason for `message.rejected` events.
+     */
+    reject_reason: string | null;
+    /**
+     * Sender/envelope-from address when available.
+     */
+    sender: string | null;
+    /**
+     * Sendmux message correlation ID for outbound sending feedback when available.
+     */
+    sendmux_message_id: string | null;
+    /**
+     * Target webhook ID for synthetic `sendmux.test` payloads.
+     */
+    webhook_id: string | null;
+};
+export type WebhookDeliveryPayloadResponse = SuccessEnvelope & {
+    data: WebhookDeliveryPayload;
+    meta?: ResponseMeta;
+};
+export type WebhookDeliveryPayload = {
+    /**
+     * ISO 8601 attempt timestamp
+     */
+    created_at: string;
+    /**
+     * 1-based retry attempt number.
+     */
+    delivery_attempt: number;
+    /**
+     * Webhook event ID
+     */
+    event_id: string;
+    /**
+     * Event types a webhook may subscribe to. `sendmux.test` is accepted so you can verify end-to-end delivery via POST /webhooks/{id}/test.
+     */
+    event_type: 'message.delivered' | 'message.bounced' | 'message.complained' | 'message.rejected' | 'message.delivery_delayed' | 'message.received' | 'message.received.spam' | 'sendmux.test';
+    /**
+     * Timestamp when this retained payload expires.
+     */
+    expires_at: string;
+    /**
+     * Delivery-attempt public ID
+     */
+    id: string;
+    payload: WebhookEventPayload;
+};
+export type WebhookDeliveryAttemptCursorListResponse = SuccessEnvelope & {
+    data: Array<WebhookDeliveryAttempt>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type WebhookDeliveryAttempt = {
+    /**
+     * ISO 8601 attempt timestamp
+     */
+    created_at: string;
+    /**
+     * 1-based retry attempt number.
+     */
+    delivery_attempt: number;
+    /**
+     * Public-safe network error category when no HTTP response was received.
+     */
+    error_message: string | null;
+    /**
+     * Webhook event ID
+     */
+    event_id: string;
+    /**
+     * Event types a webhook may subscribe to. `sendmux.test` is accepted so you can verify end-to-end delivery via POST /webhooks/{id}/test.
+     */
+    event_type: 'message.delivered' | 'message.bounced' | 'message.complained' | 'message.rejected' | 'message.delivery_delayed' | 'message.received' | 'message.received.spam' | 'sendmux.test';
+    /**
+     * Delivery-attempt public ID
+     */
+    id: string;
+    /**
+     * Maximum attempts before the subscription is marked failing.
+     */
+    max_attempts: number;
+    /**
+     * Next retry timestamp when result is retrying; otherwise null.
+     */
+    next_retry_at: string | null;
+    /**
+     * True while the delivered request payload can still be fetched.
+     */
+    payload_available: boolean;
+    /**
+     * Timestamp when the retained request payload expires.
+     */
+    payload_expires_at: string;
+    /**
+     * Size of the delivered request payload in bytes.
+     */
+    request_payload_bytes: number;
+    /**
+     * SHA-256 digest of the delivered request payload.
+     */
+    request_payload_sha256: string | null;
+    /**
+     * Truncated endpoint response preview, if any.
+     */
+    response_body: string | null;
+    /**
+     * End-to-end delivery latency in milliseconds.
+     */
+    response_ms: number;
+    /**
+     * HTTP status returned by the endpoint, or null for network/timeout failures.
+     */
+    response_status: number | null;
+    /**
+     * Delivery result for this attempt.
+     */
+    result: 'success' | 'retrying' | 'failed' | 'permanent_failure';
+};
+export type WebhookDeletedResponse = SuccessEnvelope & {
+    data: {
+        deleted: true;
+        id: string;
+    };
+    meta?: ResponseMeta;
+};
+export type WebhookCreateBody = {
+    /**
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * At least one event type must be provided.
+     */
+    event_types: Array<'message.delivered' | 'message.bounced' | 'message.complained' | 'message.rejected' | 'message.delivery_delayed' | 'message.received' | 'message.received.spam' | 'sendmux.test'>;
+    filters?: WebhookFilters & unknown;
+    /**
+     * Optional human-friendly label (max 255 chars). Surfaced in dashboard list/detail views.
+     */
+    name?: string;
+    /**
+     * HTTPS endpoint that will receive event POSTs. Must be https:// — plain HTTP is rejected.
+     */
+    url: string;
+};
+export type UpdateMailboxBody = {
+    display_name?: string | null;
+    /**
+     * Storage quota in bytes. Allowed values: 1073741824 (1 GB), 5368709120 (5 GB), 53687091200 (50 GB).
+     */
+    quota_bytes?: number;
+    send_scope?: {
+        group_public_ids?: Array<string>;
+        provider_public_ids?: Array<string>;
+        type: 'all' | 'providers' | 'group';
+    };
+};
+export type TransactionCursorListResponse = SuccessEnvelope & {
+    data: Array<Transaction>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type Transaction = {
+    /**
+     * DECIMAL(19,6) amount
+     */
+    amount: string;
+    balance_after: string | null;
+    balance_before: string | null;
+    /**
+     * ISO 8601 timestamp
+     */
+    created_at: string;
+    description: string;
+    /**
+     * Transaction public ID
+     */
+    id: string;
+    /**
+     * Item count (for USAGE transactions)
+     */
+    quantity: number | null;
+    type: 'PURCHASE' | 'USAGE' | 'AUTO_TOPUP' | 'REFUND' | 'ADJUSTMENT';
+};
+export type SpendSummaryResponse = SuccessEnvelope & {
+    data: SpendSummary;
+    meta?: ResponseMeta;
+};
+export type SpendSummary = {
+    currency: 'USD';
+    period_days: number;
+    total_consumed: string;
+    total_purchased: string;
+    transaction_count: number;
+};
+export type SharedAmazonSesLimitRequestPageResponse = SuccessEnvelope & {
+    data: SharedAmazonSesLimitRequestPage;
+    meta?: ResponseMeta;
+};
+export type SharedAmazonSesLimitRequest = {
+    approved_daily_limit: number | null;
+    created_at: string;
+    current_daily_limit: number;
+    current_daily_sent: number;
+    decided_at: string | null;
+    decision_note: string | null;
+    id: string;
+    status: 'pending' | 'approved' | 'denied';
+} | null;
+export type SharedAmazonSesLimit = {
+    can_request_increase: boolean;
+    daily_limit: number | null;
+    is_near_limit: boolean;
+    pending_request_id: string | null;
+    provider_id: string | null;
+    sent_today: number;
+    threshold_usage: number | null;
+    usage_ratio: number | null;
+};
+export type SharedAmazonSesLimitRequestPage = {
+    limit: SharedAmazonSesLimit;
+    pending_request: SharedAmazonSesLimitRequest;
+};
+export type SharedAmazonSesLimitRequestCreateResponse = SuccessEnvelope & {
+    data: SharedAmazonSesLimitRequestCreate;
+    meta?: ResponseMeta;
+};
+export type SharedAmazonSesLimitRequestCreate = {
+    limit: SharedAmazonSesLimit;
+    request: SharedAmazonSesLimitRequest & {
+        [key: string]: unknown;
+    };
+};
+export type SetFilterStateBody = {
+    mode: 'off' | 'allowlist' | 'denylist';
+    /**
+     * Replacement rule set. Maximum 1000 rules per request. An empty array is valid (no rules).
+     */
+    rules: Array<FilterRule>;
+};
+export type FilterRule = {
+    /**
+     * Free-form caption for the rule (≤255 chars). UI-only metadata — never consulted at match time. `null` when absent.
+     */
+    note?: string | null;
+    /**
+     * Email address or bare domain name. Validated against RFC 5321/1035 regexes.
+     */
+    pattern: string;
+    /**
+     * Rule type
+     */
+    type: 'allow' | 'deny';
+};
+export type SendingAccountLimitRequestResponse = SuccessEnvelope & {
+    data: SendingAccountLimitRequest;
+    meta?: ResponseMeta;
+};
+export type ResourceLimitSnapshot = {
+    can_request_increase: boolean;
+    is_at_limit: boolean;
+    is_near_limit: boolean;
+    max_allowed: number;
+    pending_request_id: string | null;
+    reserved: number;
+    resource_type: string;
+    threshold_usage: number;
+    usage: number;
+    usage_ratio: number;
+};
+export type SendingAccountLimitRequest = {
+    limit: ResourceLimitSnapshot;
+    request_id: string;
+};
+export type ProviderUsageResponse = SuccessEnvelope & {
+    data: ProviderUsage;
+    meta?: ResponseMeta;
+};
+export type ProviderUsageItem = {
+    failed_7d: number;
+    pending_7d: number;
+    provider_id: string;
+    rejected_7d: number;
+    sent_7d: number;
+    sent_today: number;
+    total_7d: number;
+};
+export type ProviderUsage = {
+    providers: Array<ProviderUsageItem>;
+    window_days: 7;
+};
+export type ProviderUpdateBody = {
+    from_email?: string | null;
+    from_name?: string | null;
+    name?: string;
+    percentage?: number;
+    quotas?: {
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_day?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_hour?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_minute?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_second?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+    };
+    reply_to_email?: string | null;
+    reply_to_name?: string | null;
+    smtp_host?: string;
+    smtp_password?: string;
+    smtp_port?: number;
+    smtp_protocol?: 'tls' | 'ssl' | 'none' | 'starttls';
+    smtp_username?: string;
+    tracking_domain?: string | null;
+};
+export type ProviderQuotaRange = {
+    max: number;
+    min: number;
+} | null;
+export type ProviderTypeCounts = {
+    /**
+     * Number of shared Amazon SES accounts
+     */
+    amazon_ses: number;
+    /**
+     * Number of Gmail API accounts
+     */
+    gmail_api: number;
+    /**
+     * Number of Outlook API accounts
+     */
+    outlook_api: number;
+    /**
+     * Number of SMTP accounts
+     */
+    smtp: number;
+};
+export type ProviderTestResultResponse = SuccessEnvelope & {
+    data: ProviderTestResult;
+    meta?: ResponseMeta;
+};
+export type ProviderTestResult = {
+    latency_ms: number;
+    message: string;
+    success: boolean;
+    tested_at: string;
+};
+export type ProviderStatusCounts = {
+    active: number;
+    error: number;
+    inactive: number;
+    pending: number;
+};
+export type ProviderStatsResponse = SuccessEnvelope & {
+    data: ProviderStats;
+    meta?: ResponseMeta;
+};
+export type ProviderStats = {
+    /**
+     * Accounts with status 'active'
+     */
+    active: number;
+    by_status: ProviderStatusCounts;
+    by_type: ProviderTypeCounts;
+    /**
+     * Accounts with status 'error'
+     */
+    error: number;
+    /**
+     * Accounts with status 'inactive'
+     */
+    inactive: number;
+    /**
+     * Accounts with status 'pending'
+     */
+    pending: number;
+    /**
+     * Total number of sending accounts
+     */
+    total: number;
+};
+export type ProviderQuotas = {
+    per_day: ProviderQuotaRange;
+    per_hour: ProviderQuotaRange;
+    per_minute: ProviderQuotaRange;
+    per_second: ProviderQuotaRange;
+};
+export type ProviderLimitsResponse = SuccessEnvelope & {
+    data: ProviderLimits;
+    meta?: ResponseMeta;
+};
+export type ProviderLimits = {
+    sending_accounts: ResourceLimitSnapshot;
+    shared_amazon_ses: SharedAmazonSesLimit;
+};
+export type ProviderItemResponse = SuccessEnvelope & {
+    data: ProviderItem;
+    meta?: ResponseMeta;
+};
+export type ProviderAllowedActions = {
+    activate: boolean;
+    deactivate: boolean;
+    delete: boolean;
+    test: boolean;
+    update: boolean;
+};
+export type ProviderItem = {
+    allowed_actions: ProviderAllowedActions;
+    /**
+     * ISO 8601 creation timestamp
+     */
+    created_at: string;
+    /**
+     * Default From email address.
+     */
+    from_email: string | null;
+    /**
+     * Default From display name.
+     */
+    from_name: string | null;
+    /**
+     * Whether an OAuth account has an active connection token.
+     */
+    has_refresh_token: boolean;
+    /**
+     * Whether a custom SMTP password is stored.
+     */
+    has_smtp_password: boolean;
+    /**
+     * Sending account public ID
+     */
+    id: string;
+    /**
+     * Whether this account is enabled for sending.
+     */
+    is_active: boolean;
+    /**
+     * False when the account is platform-managed.
+     */
+    is_editable: boolean;
+    /**
+     * True for the team's shared Amazon SES account.
+     */
+    is_shared: boolean;
+    /**
+     * Last connection test timestamp.
+     */
+    last_tested_at: string | null;
+    /**
+     * Last send timestamp.
+     */
+    last_used_at: string | null;
+    /**
+     * Display name
+     */
+    name: string;
+    /**
+     * Connected account email for OAuth accounts.
+     */
+    oauth_email: string | null;
+    /**
+     * Routing weight percentage.
+     */
+    percentage: number | null;
+    quotas: ProviderQuotas;
+    /**
+     * Default Reply-To email address.
+     */
+    reply_to_email: string | null;
+    /**
+     * Default Reply-To display name.
+     */
+    reply_to_name: string | null;
+    /**
+     * SMTP host for custom SMTP accounts.
+     */
+    smtp_host: string | null;
+    /**
+     * SMTP port for custom SMTP accounts.
+     */
+    smtp_port: number | null;
+    /**
+     * SMTP security mode.
+     */
+    smtp_protocol: string | null;
+    /**
+     * SMTP username for custom SMTP accounts.
+     */
+    smtp_username: string | null;
+    /**
+     * Current sending account status.
+     */
+    status: 'active' | 'inactive' | 'error' | 'pending';
+    /**
+     * Public-safe reason for the current status.
+     */
+    status_reason: string | null;
+    /**
+     * Custom tracking hostname.
+     */
+    tracking_domain: string | null;
+    /**
+     * Sending account type. `amazon_ses` is the shared managed account.
+     */
+    type: 'smtp' | 'gmail_api' | 'outlook_api' | 'amazon_ses';
+    /**
+     * ISO 8601 last update timestamp
+     */
+    updated_at: string;
+};
+export type ProviderItemCursorListResponse = SuccessEnvelope & {
+    data: Array<ProviderItem>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type ProviderDeletedResponse = SuccessEnvelope & {
+    data: ProviderDeleted;
+    meta?: ResponseMeta;
+};
+export type ProviderDeleted = {
+    deleted: true;
+    id: string;
+};
+export type ProviderCreateBody = {
+    from_email?: string | null;
+    from_name?: string | null;
+    name: string;
+    percentage?: number;
+    quotas?: {
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_day?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_hour?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_minute?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+        /**
+         * Quota value. Use a number for a fixed cap, a min/max range, or null to clear on PATCH.
+         */
+        per_second?: number | (ProviderQuotaRange & {
+            [key: string]: unknown;
+        }) | null;
+    };
+    reply_to_email?: string | null;
+    reply_to_name?: string | null;
+    smtp_host: string;
+    smtp_password: string;
+    smtp_port: number;
+    smtp_protocol: 'tls' | 'ssl' | 'none' | 'starttls';
+    smtp_username: string;
+    tracking_domain?: string | null;
+};
+export type MailboxSendScope = {
+    /**
+     * Delivery group public IDs (only when type=group)
+     */
+    group_public_ids?: Array<string>;
+    /**
+     * Provider public IDs (only when type=providers)
+     */
+    provider_public_ids?: Array<string>;
+    /**
+     * Outbound routing strategy. `all` lets the mailbox use any team-configured provider; `providers` restricts to the listed provider IDs; `group` routes via a delivery group.
+     */
+    type: 'all' | 'providers' | 'group';
+} | null;
+export type Mailbox = {
+    /**
+     * ISO 8601 creation timestamp
+     */
+    created_at: string;
+    /**
+     * Optional display name shown in outbound From headers
+     */
+    display_name: string | null;
+    /**
+     * Mailbox email address (lowercase)
+     */
+    email: string;
+    /**
+     * Public ID
+     */
+    id: string;
+    /**
+     * Storage quota in bytes. Current writable tiers are 1 GB, 5 GB, and 50 GB.
+     */
+    quota_bytes: number | null;
+    send_scope: MailboxSendScope;
+    /**
+     * active | suspended | deleted
+     */
+    status: string;
+};
+export type MailboxKeyDeletedResponse = SuccessEnvelope & {
+    data: {
+        deleted: true;
+        id: string;
+    };
+    meta?: ResponseMeta;
+};
+export type MailboxItemResponse = SuccessEnvelope & {
+    data: Mailbox;
+    meta?: ResponseMeta;
+};
+export type MailboxItemCursorListResponse = SuccessEnvelope & {
+    data: Array<Mailbox>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type MailboxDomainVerifyResult = {
+    checks: MailboxDomainVerifyChecks;
+    /**
+     * Latest SES DKIM status from AWS
+     */
+    ses_dkim_status: string;
+    /**
+     * Post-check verification status
+     */
+    status: 'verified' | 'pending';
+};
+export type MailboxDomainVerifyChecks = {
+    /**
+     * DMARC TXT record matches expected value
+     */
+    dmarc: boolean;
+    /**
+     * MX record present with priority 10 pointing at mail.sendmux.ai
+     */
+    mx: boolean;
+    /**
+     * SPF TXT record matches expected value
+     */
+    spf: boolean;
+    /**
+     * Ownership TXT record present with correct value
+     */
+    verification_txt: boolean;
+};
+/**
+ * SPF TXT record covering both SES and Sendmux includes
+ */
+export type MailboxDomainNameValueRecord = {
+    name: string;
+    value: string;
+};
+export type MailboxDomainMxRecord = {
+    priority: number;
+    target: string;
+};
+export type MailboxDomainDnsRecords = {
+    /**
+     * Three SES DKIM CNAME records
+     */
+    dkim: Array<MailboxDomainNameValueRecord>;
+    dmarc: MailboxDomainNameValueRecord & unknown;
+    /**
+     * MX records the customer must place. All point at Sendmux's inbound mail servers.
+     */
+    mx: Array<MailboxDomainMxRecord>;
+    spf: MailboxDomainNameValueRecord;
+    verification: MailboxDomainNameValueRecord & unknown;
+};
+export type MailboxDomain = {
+    /**
+     * ISO 8601 creation timestamp
+     */
+    created_at: string;
+    dns_records: MailboxDomainDnsRecords;
+    /**
+     * Fully qualified domain name
+     */
+    domain: string;
+    /**
+     * Public ID
+     */
+    id: string;
+    /**
+     * Active mailboxes currently using this domain
+     */
+    mailbox_count: number;
+    /**
+     * SES DKIM status (pending/success/failed/temporary_failure/not_started)
+     */
+    ses_dkim_status: string | null;
+    /**
+     * Current verification state
+     */
+    verification_status: 'pending' | 'verified' | 'failed';
+    /**
+     * ISO 8601 timestamp of last successful verification
+     */
+    verified_at: string | null;
+};
+export type MailboxDeletedResponse = SuccessEnvelope & {
+    data: {
+        deleted: true;
+        id: string;
+    };
+    meta?: ResponseMeta;
+};
+/**
+ * Initial credential for the mailbox. `null` if credential generation failed — call POST /mailboxes/{id}/keys to retry.
+ */
+export type MailboxCredential = {
+    /**
+     * IMAP retrieval port
+     */
+    imap_port: number;
+    key_prefix: string;
+    key_suffix: string;
+    /**
+     * Credential public ID
+     */
+    public_id: string;
+    /**
+     * Mailbox credential — shown exactly once. Use as a Bearer token on the HTTP API and as the password for IMAP retrieval and SMTP submission.
+     */
+    secret: string;
+    /**
+     * Mailbox server name
+     */
+    server: string;
+    /**
+     * SMTP submission port
+     */
+    smtp_port: number;
+    /**
+     * Mailbox email address used as the login
+     */
+    username: string;
+} | null;
+export type MailboxCreateResultResponse = SuccessEnvelope & {
+    data: MailboxCreateResult;
+    meta?: ResponseMeta;
+};
+export type MailboxCreateResult = {
+    credential: MailboxCredential;
+    mailbox: Mailbox;
+    /**
+     * Optional warning string when the mailbox was created without an initial credential
+     */
+    warning: string | null;
+};
+export type MailboxAppPasswordResultResponse = SuccessEnvelope & {
+    data: MailboxAppPasswordResult;
+    meta?: ResponseMeta;
+};
+export type MailboxAppPasswordResult = {
+    credential: MailboxCredential & {
+        [key: string]: unknown;
+    };
+};
+export type IncomingLogItemResponse = SuccessEnvelope & {
+    data: IncomingLogItem;
+    meta?: ResponseMeta;
+};
+export type IncomingLogItem = {
+    /**
+     * Billable amount for this message in USD
+     */
+    amount: string;
+    /**
+     * ISO 8601 usage bucket start
+     */
+    billing_bucket_start: string;
+    event_type: 'message.received' | 'message.received.spam';
+    from_email: string | null;
+    /**
+     * Incoming log public ID
+     */
+    id: string;
+    is_spam: boolean;
+    /**
+     * Mailbox email address
+     */
+    mailbox_email: string | null;
+    /**
+     * Mailbox public ID
+     */
+    mailbox_id: string | null;
+    /**
+     * Message identifier when available
+     */
+    message_id: string | null;
+    /**
+     * Identifier source when available
+     */
+    message_id_kind: string | null;
+    /**
+     * ISO 8601 received timestamp
+     */
+    received_at: string;
+    size_bytes: number | null;
+    subject: string | null;
+    to_emails: Array<string>;
+    /**
+     * Per-message unit amount in USD
+     */
+    unit_amount: string;
+};
+export type IncomingLogItemCursorListResponse = SuccessEnvelope & {
+    data: Array<IncomingLogItem>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type FilterStateResponse = SuccessEnvelope & {
+    data: FilterState;
+    meta?: ResponseMeta;
+};
+export type FilterState = {
+    /**
+     * Active filtering mode. `off` disables filtering (all senders accepted). `allowlist` only accepts senders matching a rule. `denylist` blocks senders matching a rule.
+     */
+    mode: 'off' | 'allowlist' | 'denylist';
+    /**
+     * Current rules, sorted by pattern ascending
+     */
+    rules: Array<FilterRule>;
+};
+export type EmailMetricsResponse = SuccessEnvelope & {
+    data: EmailMetrics;
+    meta?: ResponseMeta;
+};
+export type EmailMetrics = {
+    comparison: {
+        change_pct: {
+            failed: number;
+            pending: number;
+            rejected: number;
+            sent: number;
+            total: number;
+        };
+        failed: number;
+        pending: number;
+        rejected: number;
+        sent: number;
+        total: number;
+    };
+    summary: {
+        failed: number;
+        pending: number;
+        rejected: number;
+        sent: number;
+        total: number;
+    };
+    timeseries: Array<{
+        failed: number;
+        pending: number;
+        rejected: number;
+        sent: number;
+        timestamp: string;
+        total: number;
+    }>;
+};
+export type DomainVerifyResponse = SuccessEnvelope & {
+    data: MailboxDomainVerifyResult;
+    meta?: ResponseMeta;
+};
+export type DomainItemResponse = SuccessEnvelope & {
+    data: MailboxDomain;
+    meta?: ResponseMeta;
+};
+export type DomainItemCursorListResponse = SuccessEnvelope & {
+    data: Array<MailboxDomain>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type DomainDeletedResponse = SuccessEnvelope & {
+    data: {
+        deleted: true;
+        id: string;
+    };
+    meta?: ResponseMeta;
+};
+export type DeliveryLogItemResponse = SuccessEnvelope & {
+    data: DeliveryLogItem;
+    meta?: ResponseMeta;
+};
+export type DeliveryLogItem = {
+    attempts: number;
+    /**
+     * ISO 8601 creation timestamp
+     */
+    created_at: string;
+    from_email: string | null;
+    /**
+     * Log public ID
+     */
+    id: string;
+    /**
+     * Email Message-ID header
+     */
+    message_id: string | null;
+    /**
+     * Provider public ID
+     */
+    provider_id: string | null;
+    /**
+     * Provider display name
+     */
+    provider_name: string | null;
+    /**
+     * ISO 8601 timestamp when email was sent
+     */
+    sent_at: string | null;
+    /**
+     * The actual from address used for delivery after transformation. NULL if no transformation occurred or for older log entries.
+     */
+    sent_from_email: string | null;
+    size_bytes: number | null;
+    status: 'pending' | 'sent' | 'failed' | 'rejected';
+    status_reason: string | null;
+    subject: string | null;
+    to_email: string | null;
+};
+export type DeliveryLogItemCursorListResponse = SuccessEnvelope & {
+    data: Array<DeliveryLogItem>;
+    meta?: ResponseMeta;
+    pagination: CursorPagination;
+};
+export type BalanceResponse = SuccessEnvelope & {
+    data: Balance;
+    meta?: ResponseMeta;
+};
+export type Balance = {
+    auto_topup: {
+        amount: string | null;
+        enabled: boolean;
+        monthly_limit: string | null;
+        monthly_used: string;
+        threshold: string | null;
+    };
+    /**
+     * Current balance (purchased - consumed)
+     */
+    balance: string;
+    balance_consumed: string;
+    balance_purchased: string;
+    currency: 'USD';
+};
+export type ApiErrorDetail = {
+    /**
+     * Machine-readable issue code from the validator (e.g. zod issue code).
+     */
+    code: string;
+    /**
+     * Dot-path of the offending request field.
+     */
+    field: string;
+    /**
+     * Human-readable issue description.
+     */
+    message: string;
+};
+export type ApiError = {
+    error: {
+        /**
+         * Machine-readable error code
+         */
+        code: 'invalid_parameter' | 'missing_parameter' | 'authentication_required' | 'insufficient_permissions' | 'not_found' | 'conflict' | 'limit_exceeded' | 'idempotency_conflict' | 'payload_too_large' | 'validation_error' | 'rate_limit_exceeded' | 'service_unavailable' | 'internal_error';
+        /**
+         * Link to relevant documentation
+         */
+        doc_url?: string;
+        /**
+         * Accumulated per-field issues for validation errors. Only present on 400/422 responses.
+         */
+        errors?: Array<ApiErrorDetail>;
+        /**
+         * Human-readable error description
+         */
+        message: string;
+        /**
+         * The parameter that caused the error
+         */
+        param?: string;
+        /**
+         * Whether the caller may safely retry this request. 4xx are typically false (except 429); 5xx are typically true.
+         */
+        retryable: boolean;
+    };
+    meta: {
+        request_id: string;
+    };
+    ok: false;
+};
+export type ManagementListBalanceData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/billing/balance';
+};
+export type ManagementListBalanceErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListBalanceError = ManagementListBalanceErrors[keyof ManagementListBalanceErrors];
+export type ManagementListBalanceResponses = {
+    /**
+     * Current balance
+     */
+    200: BalanceResponse;
+};
+export type ManagementListBalanceResponse = ManagementListBalanceResponses[keyof ManagementListBalanceResponses];
+export type ManagementGetSpendSummaryData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Lookback period in days (default: 30)
+         */
+        days?: '7' | '30' | '90';
+    };
+    url: '/billing/summary';
+};
+export type ManagementGetSpendSummaryErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementGetSpendSummaryError = ManagementGetSpendSummaryErrors[keyof ManagementGetSpendSummaryErrors];
+export type ManagementGetSpendSummaryResponses = {
+    /**
+     * Spend summary
+     */
+    200: SpendSummaryResponse;
+};
+export type ManagementGetSpendSummaryResponse = ManagementGetSpendSummaryResponses[keyof ManagementGetSpendSummaryResponses];
+export type ManagementListTransactionsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Pagination cursor — the `next_cursor` from the previous response.
+         */
+        cursor?: string;
+        /**
+         * Max results (default 25, max 100)
+         */
+        limit?: number;
+        type?: 'PURCHASE' | 'USAGE' | 'AUTO_TOPUP' | 'REFUND' | 'ADJUSTMENT';
+    };
+    url: '/billing/transactions';
+};
+export type ManagementListTransactionsErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListTransactionsError = ManagementListTransactionsErrors[keyof ManagementListTransactionsErrors];
+export type ManagementListTransactionsResponses = {
+    /**
+     * Transaction list
+     */
+    200: TransactionCursorListResponse;
+};
+export type ManagementListTransactionsResponse = ManagementListTransactionsResponses[keyof ManagementListTransactionsResponses];
+export type ManagementListDomainsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Pagination cursor — the `next_cursor` from the previous response.
+         */
+        cursor?: string;
+        /**
+         * Maximum results (default 50, max 100)
+         */
+        limit?: number;
+    };
+    url: '/domains';
+};
+export type ManagementListDomainsErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListDomainsError = ManagementListDomainsErrors[keyof ManagementListDomainsErrors];
+export type ManagementListDomainsResponses = {
+    /**
+     * Domain list
+     */
+    200: DomainItemCursorListResponse;
+};
+export type ManagementListDomainsResponse = ManagementListDomainsResponses[keyof ManagementListDomainsResponses];
+export type ManagementCreateDomainData = {
+    body?: {
+        /**
+         * Fully qualified domain name. Must be lowercased and domain-only (no scheme).
+         */
+        domain: string;
+    };
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/domains';
+};
+export type ManagementCreateDomainErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Domain already in use, or `Idempotency-Key` was replayed with a different body.
+     */
+    409: ApiError;
+    /**
+     * SES tenant not yet provisioned for this team
+     */
+    503: ApiError;
+};
+export type ManagementCreateDomainError = ManagementCreateDomainErrors[keyof ManagementCreateDomainErrors];
+export type ManagementCreateDomainResponses = {
+    /**
+     * Domain created. The response carries a `Location` header pointing at the canonical GET URL for the new domain.
+     */
+    201: DomainItemResponse;
+};
+export type ManagementCreateDomainResponse = ManagementCreateDomainResponses[keyof ManagementCreateDomainResponses];
+export type ManagementDeleteDomainData = {
+    body?: never;
+    path: {
+        /**
+         * Domain public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/domains/{public_id}';
+};
+export type ManagementDeleteDomainErrors = {
+    /**
+     * Domain not found
+     */
+    404: ApiError;
+    /**
+     * Domain still has active mailboxes (error code `conflict`).
+     */
+    409: ApiError;
+};
+export type ManagementDeleteDomainError = ManagementDeleteDomainErrors[keyof ManagementDeleteDomainErrors];
+export type ManagementDeleteDomainResponses = {
+    /**
+     * Deletion result
+     */
+    200: DomainDeletedResponse;
+};
+export type ManagementDeleteDomainResponse = ManagementDeleteDomainResponses[keyof ManagementDeleteDomainResponses];
+export type ManagementGetDomainData = {
+    body?: never;
+    headers?: {
+        /**
+         * Weak ETag from a previous response. Returns 304 when unchanged.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * Domain public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/domains/{public_id}';
+};
+export type ManagementGetDomainErrors = {
+    /**
+     * Domain not found
+     */
+    404: ApiError;
+};
+export type ManagementGetDomainError = ManagementGetDomainErrors[keyof ManagementGetDomainErrors];
+export type ManagementGetDomainResponses = {
+    /**
+     * Domain
+     */
+    200: DomainItemResponse;
+};
+export type ManagementGetDomainResponse = ManagementGetDomainResponses[keyof ManagementGetDomainResponses];
+export type ManagementGetDomainFiltersData = {
+    body?: never;
+    headers?: {
+        /**
+         * Weak ETag from a previous response. Returns 304 when unchanged.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * Domain public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/domains/{public_id}/filters';
+};
+export type ManagementGetDomainFiltersErrors = {
+    /**
+     * Domain not found
+     */
+    404: ApiError;
+    /**
+     * Filter service temporarily unavailable
+     */
+    503: ApiError;
+};
+export type ManagementGetDomainFiltersError = ManagementGetDomainFiltersErrors[keyof ManagementGetDomainFiltersErrors];
+export type ManagementGetDomainFiltersResponses = {
+    /**
+     * Filter state
+     */
+    200: FilterStateResponse;
+};
+export type ManagementGetDomainFiltersResponse = ManagementGetDomainFiltersResponses[keyof ManagementGetDomainFiltersResponses];
+export type ManagementSetDomainFiltersData = {
+    body?: SetFilterStateBody;
+    headers?: {
+        /**
+         * Weak ETag from a prior GET. Reject with 409 conflict when the server's current ETag differs.
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Domain public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/domains/{public_id}/filters';
+};
+export type ManagementSetDomainFiltersErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Domain not found
+     */
+    404: ApiError;
+    /**
+     * `If-Match` ETag does not match the server's current version.
+     */
+    409: ApiError;
+    /**
+     * Rule cap exceeded or invalid rule pattern
+     */
+    422: ApiError;
+    /**
+     * Filter service temporarily unavailable
+     */
+    503: ApiError;
+};
+export type ManagementSetDomainFiltersError = ManagementSetDomainFiltersErrors[keyof ManagementSetDomainFiltersErrors];
+export type ManagementSetDomainFiltersResponses = {
+    /**
+     * Updated filter state
+     */
+    200: FilterStateResponse;
+};
+export type ManagementSetDomainFiltersResponse = ManagementSetDomainFiltersResponses[keyof ManagementSetDomainFiltersResponses];
+export type ManagementVerifyDomainData = {
+    body?: never;
+    path: {
+        /**
+         * Domain public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/domains/{public_id}/verify';
+};
+export type ManagementVerifyDomainErrors = {
+    /**
+     * Domain not found
+     */
+    404: ApiError;
+};
+export type ManagementVerifyDomainError = ManagementVerifyDomainErrors[keyof ManagementVerifyDomainErrors];
+export type ManagementVerifyDomainResponses = {
+    /**
+     * Verification result
+     */
+    200: DomainVerifyResponse;
+};
+export type ManagementVerifyDomainResponse = ManagementVerifyDomainResponses[keyof ManagementVerifyDomainResponses];
+export type ManagementGetDomainZoneFileData = {
+    body?: never;
+    path: {
+        /**
+         * Domain public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/domains/{public_id}/zone-file';
+};
+export type ManagementGetDomainZoneFileErrors = {
+    /**
+     * Domain not found
+     */
+    404: ApiError;
+};
+export type ManagementGetDomainZoneFileError = ManagementGetDomainZoneFileErrors[keyof ManagementGetDomainZoneFileErrors];
+export type ManagementGetDomainZoneFileResponses = {
+    /**
+     * Zone file (text/plain)
+     */
+    200: string;
+};
+export type ManagementGetDomainZoneFileResponse = ManagementGetDomainZoneFileResponses[keyof ManagementGetDomainZoneFileResponses];
+export type ManagementListEmailLogsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Max results (default 25)
+         */
+        limit?: number;
+        /**
+         * Cursor from previous page
+         */
+        cursor?: string;
+        status?: 'pending' | 'sent' | 'failed' | 'rejected';
+        /**
+         * ISO 8601 start date
+         */
+        from_date?: string;
+        /**
+         * ISO 8601 end date
+         */
+        to_date?: string;
+        /**
+         * Filter by provider publicId
+         */
+        provider_id?: string;
+        /**
+         * Search to_email, from_email, sent_from_email, subject, message_id
+         */
+        search?: string;
+    };
+    url: '/emails/logs';
+};
+export type ManagementListEmailLogsErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListEmailLogsError = ManagementListEmailLogsErrors[keyof ManagementListEmailLogsErrors];
+export type ManagementListEmailLogsResponses = {
+    /**
+     * Delivery log list
+     */
+    200: DeliveryLogItemCursorListResponse;
+};
+export type ManagementListEmailLogsResponse = ManagementListEmailLogsResponses[keyof ManagementListEmailLogsResponses];
+export type ManagementGetEmailLogData = {
+    body?: never;
+    headers?: {
+        /**
+         * Weak ETag from a previous response. Returns 304 when unchanged.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * Delivery log public ID (dlog_...)
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/emails/logs/{public_id}';
+};
+export type ManagementGetEmailLogErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+    /**
+     * Not found
+     */
+    404: ApiError;
+};
+export type ManagementGetEmailLogError = ManagementGetEmailLogErrors[keyof ManagementGetEmailLogErrors];
+export type ManagementGetEmailLogResponses = {
+    /**
+     * Delivery log detail
+     */
+    200: DeliveryLogItemResponse;
+};
+export type ManagementGetEmailLogResponse = ManagementGetEmailLogResponses[keyof ManagementGetEmailLogResponses];
+export type ManagementGetEmailMetricsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Preset time window (default: 24h)
+         */
+        window?: '24h' | '7d' | '30d';
+        /**
+         * ISO 8601 start date (overrides window)
+         */
+        from_date?: string;
+        /**
+         * ISO 8601 end date
+         */
+        to_date?: string;
+        /**
+         * Timeseries granularity (default: daily)
+         */
+        granularity?: 'hourly' | 'daily';
+        /**
+         * Filter by provider publicId
+         */
+        provider_id?: string;
+    };
+    url: '/emails/metrics';
+};
+export type ManagementGetEmailMetricsErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementGetEmailMetricsError = ManagementGetEmailMetricsErrors[keyof ManagementGetEmailMetricsErrors];
+export type ManagementGetEmailMetricsResponses = {
+    /**
+     * Email metrics with comparison
+     */
+    200: EmailMetricsResponse;
+};
+export type ManagementGetEmailMetricsResponse = ManagementGetEmailMetricsResponses[keyof ManagementGetEmailMetricsResponses];
+export type ManagementListInboxLogsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Max results (default 25)
+         */
+        limit?: number;
+        /**
+         * Cursor from previous page
+         */
+        cursor?: string;
+        /**
+         * Filter by mailbox public ID
+         */
+        mailbox_id?: string;
+        event_type?: 'message.received' | 'message.received.spam';
+        /**
+         * ISO 8601 start date
+         */
+        from_date?: string;
+        /**
+         * ISO 8601 end date
+         */
+        to_date?: string;
+        /**
+         * Search mailbox, sender, recipient, subject, or message ID
+         */
+        search?: string;
+    };
+    url: '/inboxes/logs';
+};
+export type ManagementListInboxLogsErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListInboxLogsError = ManagementListInboxLogsErrors[keyof ManagementListInboxLogsErrors];
+export type ManagementListInboxLogsResponses = {
+    /**
+     * Incoming log list
+     */
+    200: IncomingLogItemCursorListResponse;
+};
+export type ManagementListInboxLogsResponse = ManagementListInboxLogsResponses[keyof ManagementListInboxLogsResponses];
+export type ManagementGetInboxLogData = {
+    body?: never;
+    path: {
+        /**
+         * Incoming log public ID (ilog_...)
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/inboxes/logs/{public_id}';
+};
+export type ManagementGetInboxLogErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+    /**
+     * Not found
+     */
+    404: ApiError;
+};
+export type ManagementGetInboxLogError = ManagementGetInboxLogErrors[keyof ManagementGetInboxLogErrors];
+export type ManagementGetInboxLogResponses = {
+    /**
+     * Incoming log detail
+     */
+    200: IncomingLogItemResponse;
+};
+export type ManagementGetInboxLogResponse = ManagementGetInboxLogResponses[keyof ManagementGetInboxLogResponses];
+export type ManagementListMailboxesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Pagination cursor — the `next_cursor` from the previous response.
+         */
+        cursor?: string;
+        /**
+         * Max results (default 50, max 100)
+         */
+        limit?: number;
+        /**
+         * Set to `true` to include soft-deleted mailboxes (status `deleted`) in the response. Default `false`. Soft-deleted mailboxes are retained for tenant-isolation references in delivery logs and API keys.
+         */
+        include_deleted?: 'true';
+    };
+    url: '/mailboxes';
+};
+export type ManagementListMailboxesErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListMailboxesError = ManagementListMailboxesErrors[keyof ManagementListMailboxesErrors];
+export type ManagementListMailboxesResponses = {
+    /**
+     * Mailbox list
+     */
+    200: MailboxItemCursorListResponse;
+};
+export type ManagementListMailboxesResponse = ManagementListMailboxesResponses[keyof ManagementListMailboxesResponses];
+export type ManagementCreateMailboxData = {
+    body?: {
+        display_name?: string;
+        email: string;
+        /**
+         * Storage quota in bytes. Allowed values: 1073741824 (1 GB), 5368709120 (5 GB), 53687091200 (50 GB).
+         */
+        quota_bytes?: number;
+        send_scope?: {
+            group_public_ids?: Array<string>;
+            provider_public_ids?: Array<string>;
+            type: 'all' | 'providers' | 'group';
+        };
+    };
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/mailboxes';
+};
+export type ManagementCreateMailboxErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Email already in use (error code `conflict`), or `Idempotency-Key` was replayed with a different body (`idempotency_conflict`).
+     */
+    409: ApiError;
+    /**
+     * Domain not yet verified or semantic validation failure
+     */
+    422: ApiError;
+    /**
+     * Team is not yet provisioned for sending
+     */
+    503: ApiError;
+};
+export type ManagementCreateMailboxError = ManagementCreateMailboxErrors[keyof ManagementCreateMailboxErrors];
+export type ManagementCreateMailboxResponses = {
+    /**
+     * Mailbox created. The response carries a `Location` header pointing at the canonical GET URL for the new mailbox.
+     */
+    201: MailboxCreateResultResponse;
+};
+export type ManagementCreateMailboxResponse = ManagementCreateMailboxResponses[keyof ManagementCreateMailboxResponses];
+export type ManagementDeleteMailboxData = {
+    body?: never;
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}';
+};
+export type ManagementDeleteMailboxErrors = {
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+};
+export type ManagementDeleteMailboxError = ManagementDeleteMailboxErrors[keyof ManagementDeleteMailboxErrors];
+export type ManagementDeleteMailboxResponses = {
+    /**
+     * Deletion result
+     */
+    200: MailboxDeletedResponse;
+};
+export type ManagementDeleteMailboxResponse = ManagementDeleteMailboxResponses[keyof ManagementDeleteMailboxResponses];
+export type ManagementGetMailboxData = {
+    body?: never;
+    headers?: {
+        /**
+         * Weak ETag from a previous response. Returns 304 when unchanged.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}';
+};
+export type ManagementGetMailboxErrors = {
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+};
+export type ManagementGetMailboxError = ManagementGetMailboxErrors[keyof ManagementGetMailboxErrors];
+export type ManagementGetMailboxResponses = {
+    /**
+     * Mailbox
+     */
+    200: MailboxItemResponse;
+};
+export type ManagementGetMailboxResponse = ManagementGetMailboxResponses[keyof ManagementGetMailboxResponses];
+export type ManagementUpdateMailboxData = {
+    body?: UpdateMailboxBody;
+    headers?: {
+        /**
+         * Weak ETag from a prior GET. Reject with 409 conflict when the server's current ETag differs.
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}';
+};
+export type ManagementUpdateMailboxErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+    /**
+     * `If-Match` ETag does not match the server's current version.
+     */
+    409: ApiError;
+    /**
+     * Validation error — unsupported quota tier, quota below current usage, or cross-tenant send_scope reference
+     */
+    422: ApiError;
+};
+export type ManagementUpdateMailboxError = ManagementUpdateMailboxErrors[keyof ManagementUpdateMailboxErrors];
+export type ManagementUpdateMailboxResponses = {
+    /**
+     * Updated mailbox
+     */
+    200: MailboxItemResponse;
+};
+export type ManagementUpdateMailboxResponse = ManagementUpdateMailboxResponses[keyof ManagementUpdateMailboxResponses];
+export type ManagementGetMailboxFiltersData = {
+    body?: never;
+    headers?: {
+        /**
+         * Weak ETag from a previous response. Returns 304 when unchanged.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}/filters';
+};
+export type ManagementGetMailboxFiltersErrors = {
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+    /**
+     * Filter service temporarily unavailable
+     */
+    503: ApiError;
+};
+export type ManagementGetMailboxFiltersError = ManagementGetMailboxFiltersErrors[keyof ManagementGetMailboxFiltersErrors];
+export type ManagementGetMailboxFiltersResponses = {
+    /**
+     * Filter state
+     */
+    200: FilterStateResponse;
+};
+export type ManagementGetMailboxFiltersResponse = ManagementGetMailboxFiltersResponses[keyof ManagementGetMailboxFiltersResponses];
+export type ManagementSetMailboxFiltersData = {
+    body?: SetFilterStateBody;
+    headers?: {
+        /**
+         * Weak ETag from a prior GET. Reject with 409 conflict when the server's current ETag differs.
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}/filters';
+};
+export type ManagementSetMailboxFiltersErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+    /**
+     * `If-Match` ETag does not match the server's current version.
+     */
+    409: ApiError;
+    /**
+     * Rule cap exceeded or invalid rule pattern
+     */
+    422: ApiError;
+    /**
+     * Filter service temporarily unavailable
+     */
+    503: ApiError;
+};
+export type ManagementSetMailboxFiltersError = ManagementSetMailboxFiltersErrors[keyof ManagementSetMailboxFiltersErrors];
+export type ManagementSetMailboxFiltersResponses = {
+    /**
+     * Updated filter state
+     */
+    200: FilterStateResponse;
+};
+export type ManagementSetMailboxFiltersResponse = ManagementSetMailboxFiltersResponses[keyof ManagementSetMailboxFiltersResponses];
+export type ManagementCreateMailboxKeyData = {
+    body?: {
+        app_name: string;
+    };
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}/keys';
+};
+export type ManagementCreateMailboxKeyErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+    /**
+     * API key limit reached (`limit_exceeded`) or idempotency key conflict (`idempotency_conflict`).
+     */
+    409: ApiError;
+    /**
+     * Mailbox is not active
+     */
+    422: ApiError;
+};
+export type ManagementCreateMailboxKeyError = ManagementCreateMailboxKeyErrors[keyof ManagementCreateMailboxKeyErrors];
+export type ManagementCreateMailboxKeyResponses = {
+    /**
+     * Mailbox API key created. The response carries a `Location` header pointing at the canonical URL for the new key.
+     */
+    201: MailboxAppPasswordResultResponse;
+};
+export type ManagementCreateMailboxKeyResponse = ManagementCreateMailboxKeyResponses[keyof ManagementCreateMailboxKeyResponses];
+export type ManagementDeleteMailboxKeyData = {
+    body?: never;
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+        /**
+         * API key public ID
+         */
+        key_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}/keys/{key_id}';
+};
+export type ManagementDeleteMailboxKeyErrors = {
+    /**
+     * Mailbox or key not found
+     */
+    404: ApiError;
+};
+export type ManagementDeleteMailboxKeyError = ManagementDeleteMailboxKeyErrors[keyof ManagementDeleteMailboxKeyErrors];
+export type ManagementDeleteMailboxKeyResponses = {
+    /**
+     * Deletion result
+     */
+    200: MailboxKeyDeletedResponse;
+};
+export type ManagementDeleteMailboxKeyResponse = ManagementDeleteMailboxKeyResponses[keyof ManagementDeleteMailboxKeyResponses];
+export type ManagementResumeMailboxData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key).
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}/resume';
+};
+export type ManagementResumeMailboxErrors = {
+    /**
+     * Root API key required
+     */
+    403: ApiError;
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+    /**
+     * Mailbox is deleted, or `Idempotency-Key` was replayed with a different request body.
+     */
+    409: ApiError;
+    /**
+     * Mailbox service temporarily unavailable
+     */
+    503: ApiError;
+};
+export type ManagementResumeMailboxError = ManagementResumeMailboxErrors[keyof ManagementResumeMailboxErrors];
+export type ManagementResumeMailboxResponses = {
+    /**
+     * Resumed mailbox
+     */
+    200: MailboxItemResponse;
+};
+export type ManagementResumeMailboxResponse = ManagementResumeMailboxResponses[keyof ManagementResumeMailboxResponses];
+export type ManagementSuspendMailboxData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key).
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Mailbox public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/mailboxes/{public_id}/suspend';
+};
+export type ManagementSuspendMailboxErrors = {
+    /**
+     * Root API key required
+     */
+    403: ApiError;
+    /**
+     * Mailbox not found
+     */
+    404: ApiError;
+    /**
+     * Mailbox is deleted, or `Idempotency-Key` was replayed with a different request body.
+     */
+    409: ApiError;
+    /**
+     * Mailbox service temporarily unavailable
+     */
+    503: ApiError;
+};
+export type ManagementSuspendMailboxError = ManagementSuspendMailboxErrors[keyof ManagementSuspendMailboxErrors];
+export type ManagementSuspendMailboxResponses = {
+    /**
+     * Suspended mailbox
+     */
+    200: MailboxItemResponse;
+};
+export type ManagementSuspendMailboxResponse = ManagementSuspendMailboxResponses[keyof ManagementSuspendMailboxResponses];
+export type ManagementListProvidersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Pagination cursor — the `next_cursor` from the previous response.
+         */
+        cursor?: string;
+        status?: 'active' | 'inactive' | 'error' | 'pending';
+        type?: 'smtp' | 'gmail_api' | 'outlook_api' | 'amazon_ses';
+        /**
+         * Maximum results (default 50, max 100)
+         */
+        limit?: number;
+    };
+    url: '/providers';
+};
+export type ManagementListProvidersErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListProvidersError = ManagementListProvidersErrors[keyof ManagementListProvidersErrors];
+export type ManagementListProvidersResponses = {
+    /**
+     * Sending account list
+     */
+    200: ProviderItemCursorListResponse;
+};
+export type ManagementListProvidersResponse = ManagementListProvidersResponses[keyof ManagementListProvidersResponses];
+export type ManagementCreateProviderData = {
+    body?: ProviderCreateBody;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/providers';
+};
+export type ManagementCreateProviderErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Limit reached or idempotency conflict
+     */
+    409: ApiError;
+};
+export type ManagementCreateProviderError = ManagementCreateProviderErrors[keyof ManagementCreateProviderErrors];
+export type ManagementCreateProviderResponses = {
+    /**
+     * Sending account created
+     */
+    201: ProviderItemResponse;
+};
+export type ManagementCreateProviderResponse = ManagementCreateProviderResponses[keyof ManagementCreateProviderResponses];
+export type ManagementDeleteProviderData = {
+    body?: never;
+    path: {
+        /**
+         * Sending account public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/providers/{public_id}';
+};
+export type ManagementDeleteProviderErrors = {
+    /**
+     * Sending account not found
+     */
+    404: ApiError;
+    /**
+     * Shared account cannot be deleted
+     */
+    422: ApiError;
+};
+export type ManagementDeleteProviderError = ManagementDeleteProviderErrors[keyof ManagementDeleteProviderErrors];
+export type ManagementDeleteProviderResponses = {
+    /**
+     * Deletion result
+     */
+    200: ProviderDeletedResponse;
+};
+export type ManagementDeleteProviderResponse = ManagementDeleteProviderResponses[keyof ManagementDeleteProviderResponses];
+export type ManagementGetProviderData = {
+    body?: never;
+    headers?: {
+        /**
+         * Weak ETag from a previous response. Returns 304 when unchanged.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * Sending account public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/providers/{public_id}';
+};
+export type ManagementGetProviderErrors = {
+    /**
+     * Sending account not found
+     */
+    404: ApiError;
+};
+export type ManagementGetProviderError = ManagementGetProviderErrors[keyof ManagementGetProviderErrors];
+export type ManagementGetProviderResponses = {
+    /**
+     * Sending account
+     */
+    200: ProviderItemResponse;
+};
+export type ManagementGetProviderResponse = ManagementGetProviderResponses[keyof ManagementGetProviderResponses];
+export type ManagementUpdateProviderData = {
+    body?: ProviderUpdateBody;
+    headers?: {
+        /**
+         * Weak ETag from a prior GET. Reject with 409 conflict when the server's current ETag differs.
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Sending account public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/providers/{public_id}';
+};
+export type ManagementUpdateProviderErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Sending account not found
+     */
+    404: ApiError;
+    /**
+     * ETag conflict
+     */
+    409: ApiError;
+    /**
+     * Shared-account lock or unsupported field
+     */
+    422: ApiError;
+};
+export type ManagementUpdateProviderError = ManagementUpdateProviderErrors[keyof ManagementUpdateProviderErrors];
+export type ManagementUpdateProviderResponses = {
+    /**
+     * Updated sending account
+     */
+    200: ProviderItemResponse;
+};
+export type ManagementUpdateProviderResponse = ManagementUpdateProviderResponses[keyof ManagementUpdateProviderResponses];
+export type ManagementActivateProviderData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Sending account public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/providers/{public_id}/activate';
+};
+export type ManagementActivateProviderErrors = {
+    /**
+     * Sending account not found
+     */
+    404: ApiError;
+    /**
+     * Idempotency conflict
+     */
+    409: ApiError;
+};
+export type ManagementActivateProviderError = ManagementActivateProviderErrors[keyof ManagementActivateProviderErrors];
+export type ManagementActivateProviderResponses = {
+    /**
+     * Updated sending account
+     */
+    200: ProviderItemResponse;
+};
+export type ManagementActivateProviderResponse = ManagementActivateProviderResponses[keyof ManagementActivateProviderResponses];
+export type ManagementDeactivateProviderData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Sending account public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/providers/{public_id}/deactivate';
+};
+export type ManagementDeactivateProviderErrors = {
+    /**
+     * Sending account not found
+     */
+    404: ApiError;
+    /**
+     * Idempotency conflict
+     */
+    409: ApiError;
+};
+export type ManagementDeactivateProviderError = ManagementDeactivateProviderErrors[keyof ManagementDeactivateProviderErrors];
+export type ManagementDeactivateProviderResponses = {
+    /**
+     * Updated sending account
+     */
+    200: ProviderItemResponse;
+};
+export type ManagementDeactivateProviderResponse = ManagementDeactivateProviderResponses[keyof ManagementDeactivateProviderResponses];
+export type ManagementTestProviderData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Sending account public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/providers/{public_id}/test';
+};
+export type ManagementTestProviderErrors = {
+    /**
+     * Sending account not found
+     */
+    404: ApiError;
+    /**
+     * Account cannot be tested
+     */
+    422: ApiError;
+    /**
+     * Connection testing unavailable
+     */
+    503: ApiError;
+};
+export type ManagementTestProviderError = ManagementTestProviderErrors[keyof ManagementTestProviderErrors];
+export type ManagementTestProviderResponses = {
+    /**
+     * Connection test result
+     */
+    200: ProviderTestResultResponse;
+};
+export type ManagementTestProviderResponse = ManagementTestProviderResponses[keyof ManagementTestProviderResponses];
+export type ManagementGetProviderLimitsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/providers/limits';
+};
+export type ManagementGetProviderLimitsResponses = {
+    /**
+     * Limit state
+     */
+    200: ProviderLimitsResponse;
+};
+export type ManagementGetProviderLimitsResponse = ManagementGetProviderLimitsResponses[keyof ManagementGetProviderLimitsResponses];
+export type ManagementRequestSendingAccountLimitIncreaseData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/providers/limits/sending-accounts/request-increase';
+};
+export type ManagementRequestSendingAccountLimitIncreaseErrors = {
+    /**
+     * A request is already pending
+     */
+    409: ApiError;
+    /**
+     * Increase request is not available yet
+     */
+    422: ApiError;
+};
+export type ManagementRequestSendingAccountLimitIncreaseError = ManagementRequestSendingAccountLimitIncreaseErrors[keyof ManagementRequestSendingAccountLimitIncreaseErrors];
+export type ManagementRequestSendingAccountLimitIncreaseResponses = {
+    /**
+     * Request submitted
+     */
+    200: SendingAccountLimitRequestResponse;
+};
+export type ManagementRequestSendingAccountLimitIncreaseResponse = ManagementRequestSendingAccountLimitIncreaseResponses[keyof ManagementRequestSendingAccountLimitIncreaseResponses];
+export type ManagementGetSharedAmazonSesLimitRequestData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/providers/shared-amazon-ses-limit-request';
+};
+export type ManagementGetSharedAmazonSesLimitRequestResponses = {
+    /**
+     * Shared Amazon SES limit request state
+     */
+    200: SharedAmazonSesLimitRequestPageResponse;
+};
+export type ManagementGetSharedAmazonSesLimitRequestResponse = ManagementGetSharedAmazonSesLimitRequestResponses[keyof ManagementGetSharedAmazonSesLimitRequestResponses];
+export type ManagementCreateSharedAmazonSesLimitRequestData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/providers/shared-amazon-ses-limit-request';
+};
+export type ManagementCreateSharedAmazonSesLimitRequestErrors = {
+    /**
+     * Shared Amazon SES account not found
+     */
+    404: ApiError;
+    /**
+     * A request is already pending
+     */
+    409: ApiError;
+    /**
+     * Increase request is not available yet
+     */
+    422: ApiError;
+};
+export type ManagementCreateSharedAmazonSesLimitRequestError = ManagementCreateSharedAmazonSesLimitRequestErrors[keyof ManagementCreateSharedAmazonSesLimitRequestErrors];
+export type ManagementCreateSharedAmazonSesLimitRequestResponses = {
+    /**
+     * Request submitted
+     */
+    200: SharedAmazonSesLimitRequestCreateResponse;
+};
+export type ManagementCreateSharedAmazonSesLimitRequestResponse = ManagementCreateSharedAmazonSesLimitRequestResponses[keyof ManagementCreateSharedAmazonSesLimitRequestResponses];
+export type ManagementGetProviderStatsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/providers/stats';
+};
+export type ManagementGetProviderStatsErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementGetProviderStatsError = ManagementGetProviderStatsErrors[keyof ManagementGetProviderStatsErrors];
+export type ManagementGetProviderStatsResponses = {
+    /**
+     * Sending account statistics
+     */
+    200: ProviderStatsResponse;
+};
+export type ManagementGetProviderStatsResponse = ManagementGetProviderStatsResponses[keyof ManagementGetProviderStatsResponses];
+export type ManagementGetProviderUsageData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/providers/usage';
+};
+export type ManagementGetProviderUsageResponses = {
+    /**
+     * Usage summary
+     */
+    200: ProviderUsageResponse;
+};
+export type ManagementGetProviderUsageResponse = ManagementGetProviderUsageResponses[keyof ManagementGetProviderUsageResponses];
+export type ManagementListWebhooksData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Pagination cursor — the `next_cursor` from the previous response.
+         */
+        cursor?: string;
+        /**
+         * Maximum results (default 50, max 100)
+         */
+        limit?: number;
+    };
+    url: '/webhooks';
+};
+export type ManagementListWebhooksErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+};
+export type ManagementListWebhooksError = ManagementListWebhooksErrors[keyof ManagementListWebhooksErrors];
+export type ManagementListWebhooksResponses = {
+    /**
+     * Subscription list
+     */
+    200: WebhookSubscriptionCursorListResponse;
+};
+export type ManagementListWebhooksResponse = ManagementListWebhooksResponses[keyof ManagementListWebhooksResponses];
+export type ManagementCreateWebhookData = {
+    body?: WebhookCreateBody;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different body with same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/webhooks';
+};
+export type ManagementCreateWebhookErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+    /**
+     * `Idempotency-Key` was replayed with a different body (`idempotency_conflict`).
+     */
+    409: ApiError;
+    /**
+     * Validation failed (e.g. non-https URL, unknown event type)
+     */
+    422: ApiError;
+};
+export type ManagementCreateWebhookError = ManagementCreateWebhookErrors[keyof ManagementCreateWebhookErrors];
+export type ManagementCreateWebhookResponses = {
+    /**
+     * Subscription created, including the signing secret. The response carries a `Location` header pointing at the canonical GET URL for the new subscription.
+     */
+    201: WebhookSubscriptionWithSecretResponse;
+};
+export type ManagementCreateWebhookResponse = ManagementCreateWebhookResponses[keyof ManagementCreateWebhookResponses];
+export type ManagementDeleteWebhookData = {
+    body?: never;
+    path: {
+        /**
+         * Webhook public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/webhooks/{public_id}';
+};
+export type ManagementDeleteWebhookErrors = {
+    /**
+     * Subscription not found
+     */
+    404: ApiError;
+};
+export type ManagementDeleteWebhookError = ManagementDeleteWebhookErrors[keyof ManagementDeleteWebhookErrors];
+export type ManagementDeleteWebhookResponses = {
+    /**
+     * Deletion result
+     */
+    200: WebhookDeletedResponse;
+};
+export type ManagementDeleteWebhookResponse = ManagementDeleteWebhookResponses[keyof ManagementDeleteWebhookResponses];
+export type ManagementGetWebhookData = {
+    body?: never;
+    headers?: {
+        /**
+         * Weak ETag from a previous response. Returns 304 when unchanged.
+         */
+        'If-None-Match'?: string;
+    };
+    path: {
+        /**
+         * Webhook public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/webhooks/{public_id}';
+};
+export type ManagementGetWebhookErrors = {
+    /**
+     * Subscription not found
+     */
+    404: ApiError;
+};
+export type ManagementGetWebhookError = ManagementGetWebhookErrors[keyof ManagementGetWebhookErrors];
+export type ManagementGetWebhookResponses = {
+    /**
+     * Subscription
+     */
+    200: WebhookSubscriptionResponse;
+};
+export type ManagementGetWebhookResponse = ManagementGetWebhookResponses[keyof ManagementGetWebhookResponses];
+export type ManagementUpdateWebhookData = {
+    body?: WebhookUpdateBody;
+    headers?: {
+        /**
+         * Weak ETag from a prior GET. Reject with 409 conflict when the server's current ETag differs.
+         */
+        'If-Match'?: string;
+    };
+    path: {
+        /**
+         * Webhook public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/webhooks/{public_id}';
+};
+export type ManagementUpdateWebhookErrors = {
+    /**
+     * Invalid request body
+     */
+    400: ApiError;
+    /**
+     * Subscription not found
+     */
+    404: ApiError;
+    /**
+     * `If-Match` ETag does not match the server's current version.
+     */
+    409: ApiError;
+    /**
+     * Validation failed (e.g. non-https URL, unknown event type, empty event list)
+     */
+    422: ApiError;
+};
+export type ManagementUpdateWebhookError = ManagementUpdateWebhookErrors[keyof ManagementUpdateWebhookErrors];
+export type ManagementUpdateWebhookResponses = {
+    /**
+     * Updated subscription
+     */
+    200: WebhookSubscriptionResponse;
+};
+export type ManagementUpdateWebhookResponse = ManagementUpdateWebhookResponses[keyof ManagementUpdateWebhookResponses];
+export type ManagementListDeliveryData = {
+    body?: never;
+    path: {
+        /**
+         * Webhook public ID
+         */
+        public_id: string;
+    };
+    query?: {
+        /**
+         * Pagination cursor — the `next_cursor` from the previous response.
+         */
+        cursor?: string;
+        /**
+         * Maximum results (default 25, max 100)
+         */
+        limit?: number;
+        /**
+         * Filter by event type.
+         */
+        event_type?: 'message.delivered' | 'message.bounced' | 'message.complained' | 'message.rejected' | 'message.delivery_delayed' | 'message.received' | 'message.received.spam' | 'sendmux.test';
+        /**
+         * Filter by delivery result.
+         */
+        result?: 'success' | 'retrying' | 'failed' | 'permanent_failure';
+    };
+    url: '/webhooks/{public_id}/deliveries';
+};
+export type ManagementListDeliveryErrors = {
+    /**
+     * Invalid query parameter
+     */
+    400: ApiError;
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+    /**
+     * Subscription not found
+     */
+    404: ApiError;
+};
+export type ManagementListDeliveryError = ManagementListDeliveryErrors[keyof ManagementListDeliveryErrors];
+export type ManagementListDeliveryResponses = {
+    /**
+     * Delivery-attempt list
+     */
+    200: WebhookDeliveryAttemptCursorListResponse;
+};
+export type ManagementListDeliveryResponse = ManagementListDeliveryResponses[keyof ManagementListDeliveryResponses];
+export type ManagementGetDeliveryPayloadData = {
+    body?: never;
+    path: {
+        /**
+         * Webhook public ID
+         */
+        public_id: string;
+        /**
+         * Delivery-attempt public ID
+         */
+        delivery_id: string;
+    };
+    query?: never;
+    url: '/webhooks/{public_id}/deliveries/{delivery_id}/payload';
+};
+export type ManagementGetDeliveryPayloadErrors = {
+    /**
+     * Authentication required
+     */
+    401: ApiError;
+    /**
+     * Insufficient permissions
+     */
+    403: ApiError;
+    /**
+     * Delivery not found or payload no longer available
+     */
+    404: ApiError;
+};
+export type ManagementGetDeliveryPayloadError = ManagementGetDeliveryPayloadErrors[keyof ManagementGetDeliveryPayloadErrors];
+export type ManagementGetDeliveryPayloadResponses = {
+    /**
+     * Delivery payload
+     */
+    200: WebhookDeliveryPayloadResponse;
+};
+export type ManagementGetDeliveryPayloadResponse = ManagementGetDeliveryPayloadResponses[keyof ManagementGetDeliveryPayloadResponses];
+export type ManagementRotateWebhookSecretData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different target `public_id` under the same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Webhook public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/webhooks/{public_id}/rotate-secret';
+};
+export type ManagementRotateWebhookSecretErrors = {
+    /**
+     * Subscription not found
+     */
+    404: ApiError;
+    /**
+     * `Idempotency-Key` was replayed against a different webhook (`idempotency_conflict`).
+     */
+    409: ApiError;
+};
+export type ManagementRotateWebhookSecretError = ManagementRotateWebhookSecretErrors[keyof ManagementRotateWebhookSecretErrors];
+export type ManagementRotateWebhookSecretResponses = {
+    /**
+     * Subscription with new signing secret
+     */
+    200: WebhookSubscriptionWithSecretResponse;
+};
+export type ManagementRotateWebhookSecretResponse = ManagementRotateWebhookSecretResponses[keyof ManagementRotateWebhookSecretResponses];
+export type ManagementTestWebhookData = {
+    body?: never;
+    headers?: {
+        /**
+         * Client-chosen unique key to safely retry the request. Cached for 24h per (team, endpoint, key). Different target `public_id` under the same key returns 409 idempotency_conflict.
+         */
+        'Idempotency-Key'?: string;
+    };
+    path: {
+        /**
+         * Webhook public ID
+         */
+        public_id: string;
+    };
+    query?: never;
+    url: '/webhooks/{public_id}/test';
+};
+export type ManagementTestWebhookErrors = {
+    /**
+     * Subscription not found
+     */
+    404: ApiError;
+    /**
+     * `Idempotency-Key` was replayed against a different webhook (`idempotency_conflict`) or the webhook is not subscribed to `sendmux.test` (`conflict`).
+     */
+    409: ApiError;
+    /**
+     * Event publish service is unavailable.
+     */
+    503: ApiError;
+};
+export type ManagementTestWebhookError = ManagementTestWebhookErrors[keyof ManagementTestWebhookErrors];
+export type ManagementTestWebhookResponses = {
+    /**
+     * Test event published
+     */
+    200: SuccessEnvelope & {
+        data: WebhookTestResponse;
+        meta?: ResponseMeta;
+    };
+};
+export type ManagementTestWebhookResponse = ManagementTestWebhookResponses[keyof ManagementTestWebhookResponses];
+//# sourceMappingURL=types.gen.d.ts.map