/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/api/v1/agents": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List your registered agents
         * @description Returns all agents owned by the authenticated user.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ListAgentsResponse"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        /**
         * Register a new agent
         * @description Register a new agent with a custom domain or, on deployments where slug registration is enabled, a slug on the shared domain. Use `slug` for instant onboarding (no DNS needed), or `email` for a custom domain (requires domain to be registered and verified first).
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            /** @description Agent registration details */
            requestBody: {
                content: {
                    "application/json": components["schemas"]["RegisterAgentRequest"];
                };
            };
            responses: {
                /** @description Created */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["RegisterAgentResponse"];
                    };
                };
                /** @description Invalid request */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent already exists */
                409: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Rate limit exceeded */
                429: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/agents/{email}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get agent details
         * @description Fetch details for a specific agent owned by the authenticated user.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Agent email address
                     * @example my-bot@example.com
                     */
                    email: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Agent"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent not owned by this user */
                403: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        /**
         * Update an agent
         * @description Updates an agent you own. Fields are optional; only the ones you send are applied, so callers can PATCH a single setting (for example, toggle HITL on) without re-supplying the others. When changing to cloud mode, webhook_url becomes required. HITL TTL is server-capped at 604800 seconds (7 days). Returns the post-update agent state so callers can confirm what landed.
         */
        put: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Agent email address
                     * @example my-bot@example.com
                     */
                    email: string;
                };
                cookie?: never;
            };
            /** @description Fields to update */
            requestBody: {
                content: {
                    "application/json": components["schemas"]["UpdateAgentRequest"];
                };
            };
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Agent"];
                    };
                };
                /** @description Validation error (e.g. bad agent_mode, TTL out of range) */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent not owned by this user */
                403: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent not found */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        post?: never;
        /**
         * Delete an agent
         * @description Delete an agent owned by the authenticated user. The agent email is cleared from any local config.
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Agent email address
                     * @example my-bot@example.com
                     */
                    email: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description status: deleted */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": {
                            [key: string]: string;
                        };
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent not owned by this user */
                403: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Internal server error */
                500: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/agents/{email}/messages": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List messages for an agent
         * @description Fetch messages for an agent. Returns lightweight summaries (no raw message content). Supports opaque token-based pagination via `page_size` and `token`.
         */
        get: {
            parameters: {
                query?: {
                    /** @description Filter by message status */
                    status?: "unread" | "read" | "all";
                    /** @description Number of messages per page (1-100) */
                    page_size?: number;
                    /** @description Opaque pagination token from a previous response's next_token */
                    token?: string;
                };
                header?: never;
                path: {
                    /**
                     * @description Agent email address
                     * @example my-bot@example.com
                     */
                    email: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ListMessagesResponse"];
                    };
                };
                /** @description Invalid status, pagination token, or filter mismatch */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent not found or not owned by this user */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/agents/{email}/messages/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get a single message
         * @description Fetch full message content including raw RFC 2822 email and auth headers. If the message is unread, this request marks it as read.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Agent email address
                     * @example my-bot@example.com
                     */
                    email: string;
                    /**
                     * @description Message ID
                     * @example msg_abc123
                     */
                    id: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["MessageDetail"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Message not found */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/agents/{email}/messages/{id}/reply": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reply to an inbound email
         * @description Reply to a previously received email using its message ID. The reply is sent as a real email back to the original sender, with proper threading headers (In-Reply-To, References). Pass conversation_id to tag the reply with your thread ID — the recipient will see it on their inbound payload. Rate limited to 60 sends per agent per minute. When the owning agent has HITL enabled, the server returns 202 Accepted and status="pending_approval" instead of sending immediately.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Agent email address
                     * @example my-bot@example.com
                     */
                    email: string;
                    /**
                     * @description Message ID from the inbound payload
                     * @example msg_abc123
                     */
                    id: string;
                };
                cookie?: never;
            };
            /** @description Reply content */
            requestBody: {
                content: {
                    "application/json": components["schemas"]["ReplyToMessageRequest"];
                };
            };
            responses: {
                /** @description Reply sent immediately */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SendEmailResponse"];
                    };
                };
                /** @description Reply held for human approval */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SendEmailResponse"];
                    };
                };
                /** @description Missing body */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent domain not verified */
                403: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Message not found or does not belong to this agent */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Rate limit exceeded */
                429: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/agents/{email}/test": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send a test email
         * @description Send a test email from the platform to the agent's own address. Useful for verifying inbound delivery is wired up correctly. Requires the agent's domain to be verified. If the agent has HITL enabled the message is held for approval and the response is 202.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Agent email address
                     * @example my-bot@example.com
                     */
                    email: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description status and message_id */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": {
                            [key: string]: string;
                        };
                    };
                };
                /** @description message_id (held for HITL approval) */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": {
                            [key: string]: string;
                        };
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent domain not verified */
                403: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent not found */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Failed to send test email */
                500: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/domains": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List your domains
         * @description Returns all domains owned by the authenticated user.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ListDomainsResponse"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        /**
         * Register a domain
         * @description Register a custom domain for use with agents. Returns DNS records to configure and a verification token.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            /** @description Domain to register */
            requestBody: {
                content: {
                    "application/json": components["schemas"]["RegisterDomainRequest"];
                };
            };
            responses: {
                /** @description Created */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["Domain"];
                    };
                };
                /** @description Invalid request */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/domains/{domain}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Delete a domain
         * @description Delete a domain. Fails if agents still exist on this domain.
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /** @description Domain name */
                    domain: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description Domain deleted */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content?: never;
                };
                /** @description Agents still exist on this domain */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Domain not found */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/domains/{domain}/verify": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Verify domain ownership
         * @description Verify domain ownership by checking for the expected TXT record in DNS.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /** @description Domain name */
                    domain: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["VerifyDomainResponse"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Domain not found */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description TXT record not found */
                412: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/info": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Deployment info
         * @description Returns deployment-specific configuration (shared domain, etc.) so CLI/SDK clients can self-configure. Unauthenticated.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["DeploymentInfo"];
                    };
                };
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/messages": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List messages waiting for HITL approval
         * @description Returns all pending_approval messages across every agent owned by the authenticated user, sorted by expiring-soonest first. Body and attachments are omitted — use the detail endpoint for full content. This is the only status value supported on this endpoint today.
         */
        get: {
            parameters: {
                query: {
                    /** @description Filter by status (only pending_approval is supported) */
                    status: "pending_approval";
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ListPendingMessagesResponse"];
                    };
                };
                /** @description Unsupported status */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/messages/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Fetch a held outbound message
         * @description Returns the full pending-approval detail — recipients, subject, body, attachments, and HITL metadata — for one of the authenticated user's outbound messages. After terminal transitions (sent, rejected, expired_*) the server scrubs body columns, so this endpoint returns the headers without content for non-pending rows.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Message ID
                     * @example msg_abc123
                     */
                    id: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["PendingMessageDetail"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Message not found or not owned by this user */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/messages/{id}/approve": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Approve a held outbound message
         * @description Sends a pending-approval message via the upstream SMTP relay and transitions it to `sent`. The request body is optional — passing any subset of subject / body_text / body_html / to / cc / bcc / attachments overrides the stored draft before send. An empty body approves the draft as-is. On successful send, the server scrubs body columns and records the provider-assigned Message-ID.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Message ID
                     * @example msg_abc123
                     */
                    id: string;
                };
                cookie?: never;
            };
            /** @description Optional field overrides */
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["ApprovePendingMessageRequest"];
                };
            };
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ApprovePendingMessageResponse"];
                    };
                };
                /** @description Invalid request or SMTP validation error */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent domain not verified */
                403: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Message not found or not owned by this user */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Message is no longer pending approval */
                409: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/messages/{id}/reject": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reject a held outbound message
         * @description Transitions a pending-approval message to `rejected`; the message is never sent. Body columns are scrubbed. An optional reason is stored for audit purposes. Returns 409 if the message has already been sent, rejected, or expired.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /**
                     * @description Message ID
                     * @example msg_abc123
                     */
                    id: string;
                };
                cookie?: never;
            };
            /** @description Optional rejection reason */
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["RejectPendingMessageRequest"];
                };
            };
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["RejectPendingMessageResponse"];
                    };
                };
                /** @description Invalid request body */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Message not found or not owned by this user */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Message is no longer pending approval */
                409: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/send": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send a new email
         * @description Send an email from your agent to any recipient. Your agent must be domain-verified. Messages are delivered via SMTP. Rate limited to 60 sends per agent per minute. Pass conversation_id to tag the message as part of a thread. When the owning agent has HITL (human-in-the-loop) enabled, the server responds with 202 Accepted and status="pending_approval" instead — the message is held until a reviewer approves it via the dashboard, CLI, or magic link, or until the approval TTL expires and the configured expiration action fires.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            /** @description Email to send */
            requestBody: {
                content: {
                    "application/json": components["schemas"]["SendEmailRequest"];
                };
            };
            responses: {
                /** @description Message sent immediately */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SendEmailResponse"];
                    };
                };
                /** @description Message held for human approval */
                202: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["SendEmailResponse"];
                    };
                };
                /** @description Missing required fields */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Agent domain not verified */
                403: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Rate limit exceeded */
                429: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/users/me": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Delete your account and all associated data
         * @description Permanently deletes the authenticated user along with their agents, domains, messages, API keys, sessions, and usage data. **Irreversible.** Requires `confirm=DELETE` query parameter as a guardrail. Returns per-table counts of removed rows so the caller can audit the cascade.
         */
        delete: {
            parameters: {
                query: {
                    /** @description Must equal 'DELETE' to proceed */
                    confirm: string;
                };
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["DeleteUserDataResult"];
                    };
                };
                /** @description Missing or invalid confirm parameter */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/users/me/export": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Export your data
         * @description Returns a JSON dump of every record the authenticated user owns: profile, agents, domains, API key metadata, messages (with bodies), and usage events. API key plaintexts are not included — they were never stored. Internal identifiers (google_subject, session tokens, key hashes) are excluded.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["UserExport"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/users/me/signing-secrets": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List your webhook signing secrets
         * @description Returns the authenticated user's webhook signing secrets (metadata, 12-char prefix, and full plaintext secret). Sorted most-recent-first; the most-recent secret is what the e2a relay uses for new signatures.
         */
        get: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description OK */
                200: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["ListSigningSecretsResponse"];
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        put?: never;
        /**
         * Create a new webhook signing secret
         * @description Mints a new HMAC signing secret for the authenticated user. The full plaintext `secret` is returned only in this response — save it now, you cannot retrieve it later. Hard cap is 5 active secrets per user; delete one before creating another.
         */
        post: {
            parameters: {
                query?: never;
                header?: never;
                path?: never;
                cookie?: never;
            };
            /** @description Optional name/label */
            requestBody?: {
                content: {
                    "application/json": components["schemas"]["internal_agent.CreateSigningSecretRequest"];
                };
            };
            responses: {
                /** @description Created */
                201: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": components["schemas"]["CreateSigningSecretResponse"];
                    };
                };
                /** @description Bad request (e.g. cap reached) */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/v1/users/me/signing-secrets/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Delete a webhook signing secret
         * @description Deletes the named secret. Refuses if it would leave the user with zero secrets — create a replacement first. After delete, any in-flight HITL approval magic-link tokens signed under the deleted secret stop verifying.
         */
        delete: {
            parameters: {
                query?: never;
                header?: never;
                path: {
                    /** @description Signing secret ID (e.g. wsec_abc123...) */
                    id: string;
                };
                cookie?: never;
            };
            requestBody?: never;
            responses: {
                /** @description No Content */
                204: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Cannot delete last secret */
                400: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Missing or invalid API key */
                401: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
                /** @description Secret not found */
                404: {
                    headers: {
                        [name: string]: unknown;
                    };
                    content: {
                        "application/json": string;
                    };
                };
            };
        };
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        APIKeyExportEntry: {
            created_at?: string;
            id?: string;
            key_prefix?: string;
            last_used_at?: string;
            name?: string;
            revoked_at?: string;
        };
        Agent: {
            /**
             * @example cloud
             * @enum {string}
             */
            agent_mode?: "cloud" | "local";
            created_at?: string;
            /** @example agents.example.com */
            domain?: string;
            domain_verified?: boolean;
            /** @example my-bot@example.com */
            email?: string;
            hitl_enabled?: boolean;
            /**
             * @example reject
             * @enum {string}
             */
            hitl_expiration_action?: "approve" | "reject";
            /** @example 604800 */
            hitl_ttl_seconds?: number;
            /** @example ag_abc123 */
            id?: string;
            /** @example My Bot */
            name?: string;
            webhook_url?: string;
        };
        ApprovePendingMessageRequest: {
            attachments?: components["schemas"]["internal_agent.Attachment"][];
            bcc?: string[];
            body_html?: string;
            body_text?: string;
            cc?: string[];
            subject?: string;
            to?: string[];
        };
        ApprovePendingMessageResponse: {
            edited?: boolean;
            message_id?: string;
            /** @example smtp */
            method?: string;
            provider_message_id?: string;
            /** @example sent */
            status?: string;
        };
        CreateSigningSecretResponse: {
            created_at?: string;
            id?: string;
            name?: string;
            secret?: string;
            secret_prefix?: string;
        };
        DNSRecord: {
            /** @example @ */
            host?: string;
            /** @example 10 */
            priority?: number;
            /** @example mx.example.com */
            value?: string;
        };
        DNSRecords: {
            mx?: components["schemas"]["DNSRecord"];
            txt?: components["schemas"]["DNSRecord"];
        };
        DeleteUserDataResult: {
            agents_deleted?: number;
            api_keys_deleted?: number;
            domains_deleted?: number;
            messages_deleted?: number;
            oauth_access_tokens_deleted?: number;
            oauth_auth_codes_deleted?: number;
            oauth_refresh_tokens_deleted?: number;
            sessions_deleted?: number;
            usage_events_deleted?: number;
            usage_summaries_deleted?: number;
            user_deleted?: boolean;
        };
        DeploymentInfo: {
            /**
             * @description PublicURL is the externally visible base URL of the API itself —
             *     the same value the operator sets in `http.public_url`. Empty when
             *     not configured.
             * @example https://e2a.example.com
             */
            public_url?: string;
            /**
             * @description SharedDomain is the mail domain backing slug-based agent registration
             *     on this deployment (e.g. "agents.example.com"). Empty when the
             *     operator hasn't configured one — in that case slug registration is
             *     disabled and every agent must use a custom domain.
             * @example agents.example.com
             */
            shared_domain?: string;
            /**
             * @description SlugRegistrationEnabled mirrors `shared_domain != ""` for clients
             *     that prefer a boolean. Equivalent to checking SharedDomain directly.
             * @example true
             */
            slug_registration_enabled?: boolean;
        };
        Domain: {
            created_at?: string;
            dns_records?: components["schemas"]["DNSRecords"];
            /** @example yourdomain.com */
            domain?: string;
            /** @example e2a-verify=abc123 */
            verification_token?: string;
            verified?: boolean;
            verified_at?: string;
        };
        ListAgentsResponse: {
            agents?: components["schemas"]["Agent"][];
        };
        ListDomainsResponse: {
            domains?: components["schemas"]["Domain"][];
        };
        ListMessagesResponse: {
            messages?: components["schemas"]["MessageSummary"][];
            next_token?: string;
        };
        ListPendingMessagesResponse: {
            messages?: components["schemas"]["PendingMessageSummary"][];
        };
        ListSigningSecretsResponse: {
            secrets?: components["schemas"]["SigningSecretSummary"][];
        };
        MessageDetail: {
            auth_headers?: {
                [key: string]: string;
            };
            cc?: string[];
            conversation_id?: string;
            created_at?: string;
            /** @example alice@example.com */
            from?: string;
            /** @example msg_abc123 */
            message_id?: string;
            raw_message?: string;
            /** @example my-bot@example.com */
            recipient?: string;
            reply_to?: string[];
            /** @example read */
            status?: string;
            /** @example Hello */
            subject?: string;
            /**
             * @example [
             *       "my-bot@example.com"
             *     ]
             */
            to?: string[];
        };
        MessageSummary: {
            cc?: string[];
            conversation_id?: string;
            /** @example 2025-01-15T10:30:00Z */
            created_at?: string;
            /** @example alice@example.com */
            from?: string;
            /** @example msg_abc123 */
            message_id?: string;
            /** @example my-bot@example.com */
            recipient?: string;
            reply_to?: string[];
            /**
             * @example unread
             * @enum {string}
             */
            status?: "unread" | "read";
            /** @example Hello */
            subject?: string;
            /**
             * @example [
             *       "my-bot@example.com"
             *     ]
             */
            to?: string[];
        };
        OAuthConnectionEntry: {
            agent_email?: string;
            client_id?: string;
            client_name?: string;
            expires_at?: string;
            issued_at?: string;
            revoked_at?: string;
            scope?: string;
        };
        PendingMessageDetail: {
            /** @example my-bot@example.com */
            agent_id?: string;
            /** @example 2025-01-15T10:30:00Z */
            approval_expires_at?: string;
            attachments?: components["schemas"]["internal_agent.Attachment"][];
            bcc?: string[];
            body_html?: string;
            body_text?: string;
            cc?: string[];
            conversation_id?: string;
            created_at?: string;
            /** @example outbound */
            direction?: string;
            edited?: boolean;
            /** @example <orig@gmail.com> */
            email_message_id?: string;
            /** @example msg_abc123 */
            id?: string;
            /** @example smtp */
            method?: string;
            provider_message_id?: string;
            rejection_reason?: string;
            /** @example 2025-01-15T10:35:00Z */
            reviewed_at?: string;
            /**
             * @example pending_approval
             * @enum {string}
             */
            status?: "sent" | "pending_approval" | "rejected" | "expired_approved" | "expired_rejected";
            /** @example Re: contract details */
            subject?: string;
            /**
             * @example [
             *       "alice@example.com"
             *     ]
             */
            to?: string[];
            /**
             * @example send
             * @enum {string}
             */
            type?: "send" | "reply" | "test";
        };
        PendingMessageSummary: {
            /** @example my-bot@example.com */
            agent_id?: string;
            /** @example 2025-01-15T10:30:00Z */
            approval_expires_at?: string;
            bcc?: string[];
            cc?: string[];
            conversation_id?: string;
            created_at?: string;
            /** @example outbound */
            direction?: string;
            /** @example msg_abc123 */
            id?: string;
            /**
             * @example pending_approval
             * @enum {string}
             */
            status?: "sent" | "pending_approval" | "rejected" | "expired_approved" | "expired_rejected";
            /** @example Re: contract details */
            subject?: string;
            /**
             * @example [
             *       "alice@example.com"
             *     ]
             */
            to?: string[];
            /**
             * @example send
             * @enum {string}
             */
            type?: "send" | "reply" | "test";
        };
        RegisterAgentRequest: {
            agent_mode?: string;
            email?: string;
            name?: string;
            slug?: string;
            webhook_url?: string;
        };
        RegisterAgentResponse: {
            domain?: string;
            email?: string;
            id?: string;
        };
        RegisterDomainRequest: {
            /** @example yourdomain.com */
            domain?: string;
        };
        RejectPendingMessageRequest: {
            /** @example wrong recipient */
            reason?: string;
        };
        RejectPendingMessageResponse: {
            message_id?: string;
            rejection_reason?: string;
            /** @example rejected */
            status?: string;
        };
        ReplyToMessageRequest: {
            attachments?: components["schemas"]["internal_agent.Attachment"][];
            /**
             * @example [
             *       "carol@example.com"
             *     ]
             */
            bcc?: string[];
            /** @example Thanks for your email! */
            body?: string;
            /**
             * @example [
             *       "bob@example.com"
             *     ]
             */
            cc?: string[];
            conversation_id?: string;
            /** @example <p>Thanks for your email!</p> */
            html_body?: string;
            /** @example false */
            reply_all?: boolean;
        };
        SendEmailRequest: {
            attachments?: components["schemas"]["internal_agent.Attachment"][];
            /**
             * @example [
             *       "carol@example.com"
             *     ]
             */
            bcc?: string[];
            /** @example Hi Alice, this is my agent reaching out. */
            body?: string;
            /**
             * @example [
             *       "bob@example.com"
             *     ]
             */
            cc?: string[];
            /** @example conv_abc123 */
            conversation_id?: string;
            /** @example my-bot@example.com */
            from?: string;
            /** @example <p>Hi Alice</p> */
            html_body?: string;
            /** @example Hello from my agent */
            subject?: string;
            /**
             * @example [
             *       "alice@example.com"
             *     ]
             */
            to?: string[];
        };
        SendEmailResponse: {
            /** @example 2025-01-15T10:30:00Z */
            approval_expires_at?: string;
            /** @example msg_abc123 */
            message_id?: string;
            /** @example smtp */
            method?: string;
            /**
             * @example sent
             * @enum {string}
             */
            status?: "sent" | "pending_approval";
        };
        SigningSecretSummary: {
            created_at?: string;
            id?: string;
            last_signed_at?: string;
            name?: string;
            secret?: string;
            secret_prefix?: string;
        };
        UpdateAgentRequest: {
            /** @enum {string} */
            agent_mode?: "cloud" | "local";
            hitl_enabled?: boolean;
            /** @enum {string} */
            hitl_expiration_action?: "approve" | "reject";
            /** @example 604800 */
            hitl_ttl_seconds?: number;
            webhook_url?: string;
        };
        UsageEventEntry: {
            agent_id?: string;
            created_at?: string;
            direction?: string;
            domain?: string;
            event_type?: string;
            id?: string;
        };
        UserExport: {
            agents?: components["schemas"]["github_com_Mnexa-AI_e2a_internal_identity.AgentIdentity"][];
            api_keys?: components["schemas"]["APIKeyExportEntry"][];
            domains?: components["schemas"]["github_com_Mnexa-AI_e2a_internal_identity.Domain"][];
            generated_at?: string;
            messages?: components["schemas"]["github_com_Mnexa-AI_e2a_internal_identity.Message"][];
            oauth_connections?: components["schemas"]["OAuthConnectionEntry"][];
            schema_version?: string;
            usage_events?: components["schemas"]["UsageEventEntry"][];
            user?: components["schemas"]["UserExportUser"];
        };
        UserExportUser: {
            created_at?: string;
            email?: string;
            id?: string;
            name?: string;
        };
        VerifyDomainResponse: {
            /** @example yourdomain.com */
            domain?: string;
            verified?: boolean;
            verified_at?: string;
        };
        "github_com_Mnexa-AI_e2a_internal_identity.AgentIdentity": {
            agent_mode?: string;
            created_at?: string;
            domain?: string;
            domain_verified?: boolean;
            email?: string;
            hitl_enabled?: boolean;
            hitl_expiration_action?: string;
            hitl_ttl_seconds?: number;
            id?: string;
            name?: string;
            public?: boolean;
            user_id?: string;
            webhook_url?: string;
        };
        "github_com_Mnexa-AI_e2a_internal_identity.Domain": {
            created_at?: string;
            domain?: string;
            user_id?: string;
            verification_token?: string;
            verified?: boolean;
            verified_at?: string;
        };
        "github_com_Mnexa-AI_e2a_internal_identity.Message": {
            agent_id?: string;
            approval_expires_at?: string;
            attachments?: number[];
            auth_headers?: {
                [key: string]: string;
            };
            bcc?: string[];
            body_html?: string;
            body_text?: string;
            cc?: string[];
            conversation_id?: string;
            created_at?: string;
            delivery_status?: string;
            direction?: string;
            edited?: boolean;
            email_message_id?: string;
            expires_at?: string;
            id?: string;
            method?: string;
            provider_message_id?: string;
            raw_message?: number[];
            recipient?: string;
            rejection_reason?: string;
            /**
             * @description ReplyTo is the parsed Reply-To: header on inbound messages — empty
             *     when the header was absent. Distinct from Sender so consumers can
             *     recover the original From: of forwarded / notification mail whose
             *     Reply-To points at a different mailbox. Outbound-irrelevant.
             */
            reply_to?: string[];
            reviewed_at?: string;
            sender?: string;
            /**
             * @description HITL approval fields. Status defaults to 'sent'; body and attachments
             *     are populated only while a message is in 'pending_approval', and are
             *     scrubbed on any terminal transition.
             */
            status?: string;
            subject?: string;
            /**
             * @description Multi-recipient fields. For outbound, these are the addressed
             *     To/Cc/Bcc recipients of the send. For inbound, ToRecipients and CC
             *     are the parsed To: and Cc: headers of the original message (the
             *     per-delivery target for this row is in Recipient). BCC is
             *     outbound-only.
             */
            to_recipients?: string[];
            type?: string;
            webhook_attempts?: number;
            webhook_error?: string;
            webhook_status?: string;
        };
        "internal_agent.Attachment": {
            /** @example application/pdf */
            content_type?: string;
            /**
             * @description base64-encoded
             * @example base64-encoded-content
             */
            data?: string;
            /** @example report.pdf */
            filename?: string;
        };
        "internal_agent.CreateSigningSecretRequest": {
            /**
             * @description Optional human-readable label so users can tell secrets apart in
             *     the dashboard (e.g. "prod", "staging", "rollover-2026-04").
             */
            name?: string;
        };
    };
    responses: never;
    parameters: never;
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export type operations = Record<string, never>;
