@primitivedotdev/sdk 0.6.0 → 0.8.0

package/dist/index-D9lanVFt.d.ts

@@ -0,0 +1,2145 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import { ReceivedEmail } from "./received-email-C67Z7Dha.js";
+
+//#region src/api/generated/core/auth.gen.d.ts
+type AuthToken = string | undefined;
+interface Auth {
+  /**
+   * Which part of the request do we use to send the auth?
+   *
+   * @default 'header'
+   */
+  in?: 'header' | 'query' | 'cookie';
+  /**
+   * Header or query parameter name.
+   *
+   * @default 'Authorization'
+   */
+  name?: string;
+  scheme?: 'basic' | 'bearer';
+  type: 'apiKey' | 'http';
+} //#endregion
+//#region src/api/generated/core/pathSerializer.gen.d.ts
+interface SerializerOptions<T> {
+  /**
+   * @default true
+   */
+  explode: boolean;
+  style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject'; //#endregion
+//#region src/api/generated/core/bodySerializer.gen.d.ts
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+  allowReserved?: boolean;
+  array?: Partial<SerializerOptions<ArrayStyle>>;
+  object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+  /**
+   * Per-parameter serialization overrides. When provided, these settings
+   * override the global array/object settings for specific parameter names.
+   */
+  parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+//#endregion
+//#region src/api/generated/core/types.gen.d.ts
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+  /**
+   * Returns the final request URL.
+   */
+  buildUrl: BuildUrlFn;
+  getConfig: () => Config$1;
+  request: RequestFn;
+  setConfig: (config: Config$1) => Config$1;
+} & { [K in HttpMethod]: MethodFn } & ([SseFn] extends [never] ? {
+  sse?: never;
+} : {
+  sse: { [K in HttpMethod]: SseFn };
+});
+interface Config$1 {
+  /**
+   * Auth token or a function returning auth token. The resolved value will be
+   * added to the request payload as defined by its `security` array.
+   */
+  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+  /**
+   * A function for serializing request body parameter. By default,
+   * {@link JSON.stringify()} will be used.
+   */
+  bodySerializer?: BodySerializer | null;
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `Headers` object with.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+   */
+  headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+  /**
+   * The request method.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+   */
+  method?: Uppercase<HttpMethod>;
+  /**
+   * A function for serializing request query parameters. By default, arrays
+   * will be exploded in form style, objects will be exploded in deepObject
+   * style, and reserved characters are percent-encoded.
+   *
+   * This method will have no effect if the native `paramsSerializer()` Axios
+   * API function is used.
+   *
+   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+   */
+  querySerializer?: QuerySerializer | QuerySerializerOptions;
+  /**
+   * A function validating request data. This is useful if you want to ensure
+   * the request conforms to the desired shape, so it can be safely sent to
+   * the server.
+   */
+  requestValidator?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function transforming response data before it's returned. This is useful
+   * for post-processing data, e.g., converting ISO strings into Date objects.
+   */
+  responseTransformer?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function validating response data. This is useful if you want to ensure
+   * the response conforms to the desired shape, so it can be safely passed to
+   * the transformers and returned to the user.
+   */
+  responseValidator?: (data: unknown) => Promise<unknown>;
+} //#endregion
+//#region src/api/generated/core/serverSentEvents.gen.d.ts
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * Implementing clients can call request interceptors inside this hook.
+   */
+  onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+  /**
+   * Callback invoked when a network or parsing error occurs during streaming.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @param error The error that occurred.
+   */
+  onSseError?: (error: unknown) => void;
+  /**
+   * Callback invoked when an event is streamed from the server.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @param event Event streamed from the server.
+   * @returns Nothing (void).
+   */
+  onSseEvent?: (event: StreamEvent<TData>) => void;
+  serializedBody?: RequestInit['body'];
+  /**
+   * Default retry delay in milliseconds.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @default 3000
+   */
+  sseDefaultRetryDelay?: number;
+  /**
+   * Maximum number of retry attempts before giving up.
+   */
+  sseMaxRetryAttempts?: number;
+  /**
+   * Maximum retry delay in milliseconds.
+   *
+   * Applies only when exponential backoff is used.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @default 30000
+   */
+  sseMaxRetryDelay?: number;
+  /**
+   * Optional sleep function for retry backoff.
+   *
+   * Defaults to using `setTimeout`.
+   */
+  sseSleepFn?: (ms: number) => Promise<void>;
+  url: string;
+};
+interface StreamEvent<TData = unknown> {
+  data: TData;
+  event?: string;
+  id?: string;
+  retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+  stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+//#endregion
+//#region src/api/generated/client/utils.gen.d.ts
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+  fns: Array<Interceptor | null>;
+  clear(): void;
+  eject(id: number | Interceptor): void;
+  exists(id: number | Interceptor): boolean;
+  getInterceptorIndex(id: number | Interceptor): number;
+  update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+  use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+  error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+  request: Interceptors<ReqInterceptor<Req, Options>>;
+  response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+//#endregion
+//#region src/api/generated/client/types.gen.d.ts
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * Please don't use the Fetch client for Next.js applications. The `next`
+   * options won't have any effect.
+   *
+   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+   */
+  next?: never;
+  /**
+   * Return the response data parsed in a specified format. By default, `auto`
+   * will infer the appropriate method from the `Content-Type` response header.
+   * You can override this behavior with any of the {@link Body} methods.
+   * Select `stream` if you don't want to parse response data at all.
+   *
+   * @default 'auto'
+   */
+  parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+  /**
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
+   */
+  responseStyle?: ResponseStyle;
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+  responseStyle: TResponseStyle;
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+  /**
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+   */
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+  serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+  request: Request;
+  response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+  error: undefined;
+} | {
+  data: undefined;
+  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+  request: Request;
+  response: Response;
+}>;
+interface ClientOptions$1 {
+  baseUrl?: string;
+  responseStyle?: ResponseStyle;
+  throwOnError?: boolean;
+}
+type MethodFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn$1 = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn$1 = <TData extends {
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  url: string;
+}>(options: TData & Options$2<TData>) => string;
+type Client = Client$1<RequestFn$1, Config, MethodFn$1, BuildUrlFn$1, SseFn$1> & {
+  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+type CreateClientConfig<T extends ClientOptions$1 = ClientOptions$1> = (override?: Config<ClientOptions$1 & T>) => Config<Required<ClientOptions$1> & T>;
+interface TDataShape {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$2<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+//#endregion
+//#region src/api/generated/types.gen.d.ts
+type ClientOptions = {
+  baseUrl: 'https://www.primitive.dev/api/v1' | (string & {});
+};
+type SuccessEnvelope = {
+  success: boolean;
+};
+type ListEnvelope = {
+  success: boolean;
+  meta: PaginationMeta;
+};
+type PaginationMeta = {
+  /**
+   * Total number of matching records
+   */
+  total: number;
+  /**
+   * Page size used for this request
+   */
+  limit: number;
+  /**
+   * Cursor for the next page, or null if no more results
+   */
+  cursor: string | null;
+};
+type ErrorResponse = {
+  success: boolean;
+  error: {
+    code: 'unauthorized' | 'forbidden' | 'not_found' | 'validation_error' | 'rate_limit_exceeded' | 'internal_error' | 'conflict' | 'mx_conflict' | 'bad_gateway' | 'outbound_disabled' | 'cannot_send_from_domain' | 'recipient_not_allowed' | 'outbound_key_missing' | 'outbound_unreachable' | 'outbound_key_invalid' | 'outbound_capacity_exhausted' | 'outbound_response_malformed' | 'outbound_relay_failed';
+    message: string;
+    /**
+     * Optional structured data that callers can inspect to recover
+     * from the error. The fields present depend on `code`. Additional
+     * keys may be added over time without a major-version bump.
+     *
+     */
+    details?: {
+      /**
+       * Present when `code == mx_conflict`.
+       */
+      mx_conflict?: {
+        /**
+         * Human-readable name of the detected mailbox provider (e.g. "Google Workspace").
+         */
+        provider_name: string;
+        /**
+         * Subdomain to try instead (e.g. "mail" for `mail.example.com`).
+         */
+        suggested_subdomain: string;
+      };
+      /**
+       * Entitlements that would allow a denied send when no recipient-scope gate was granted.
+       */
+      required_entitlements?: Array<string>;
+      /**
+       * ID of the persisted sent-email attempt associated with the error.
+       */
+      sent_email_id?: string;
+      /**
+       * Content hash of the original request on idempotency cache-hit errors.
+       */
+      content_hash?: string;
+      /**
+       * Effective idempotency key associated with the original request.
+       */
+      client_idempotency_key?: string;
+      [key: string]: unknown;
+    };
+    /**
+     * Structured per-gate denial detail for recipient-scope send-mail failures.
+     */
+    gates?: Array<GateDenial>;
+    /**
+     * Server-issued request identifier for support and tracing.
+     */
+    request_id?: string;
+  };
+};
+type GateDenial = {
+  /**
+   * Public recipient-scope gate name that denied the send.
+   */
+  name: 'send_to_confirmed_domains' | 'send_to_known_addresses';
+  /**
+   * Stable machine-readable denial reason.
+   */
+  reason: 'domain_not_confirmed' | 'recipient_unauthenticated' | 'recipient_not_known';
+  /**
+   * Human-readable explanation of the gate denial.
+   */
+  message: string;
+  /**
+   * Domain or address the gate evaluated.
+   */
+  subject: string;
+  fix?: GateFix;
+  /**
+   * Public docs URL with more context.
+   */
+  docs_url?: string;
+};
+type GateFix = {
+  /**
+   * Suggested next action for the caller.
+   */
+  action: 'confirm_domain' | 'sender_must_fix_authentication' | 'wait_for_inbound';
+  /**
+   * Entity the action applies to.
+   */
+  subject: string;
+};
+type Account = {
+  id: string;
+  email: string;
+  plan: string;
+  created_at: string;
+  onboarding_completed?: boolean;
+  onboarding_step?: string | null;
+  stripe_subscription_status?: string | null;
+  subscription_current_period_end?: string | null;
+  subscription_cancel_at_period_end?: boolean | null;
+  spam_threshold?: number | null;
+  discard_content_on_webhook_confirmed: boolean;
+  webhook_secret_rotated_at?: string | null;
+};
+type AccountUpdated = {
+  id: string;
+  email: string;
+  plan: string;
+  spam_threshold?: number | null;
+  discard_content_on_webhook_confirmed: boolean;
+};
+type UpdateAccountInput = {
+  /**
+   * Global spam score threshold (0-15). Emails scoring above this are rejected. Set to null to disable.
+   */
+  spam_threshold?: number | null;
+  /**
+   * Whether to discard email content after the webhook endpoint confirms receipt.
+   */
+  discard_content_on_webhook_confirmed?: boolean;
+};
+type StorageStats = {
+  /**
+   * Total storage used in bytes
+   */
+  used_bytes: number;
+  /**
+   * Total storage used in kilobytes (1 decimal)
+   */
+  used_kb: number;
+  /**
+   * Total storage used in megabytes (2 decimals)
+   */
+  used_mb: number;
+  /**
+   * Storage quota in megabytes (based on plan)
+   */
+  quota_mb: number;
+  /**
+   * Percentage of quota used (1 decimal)
+   */
+  percentage: number;
+  /**
+   * Number of stored emails
+   */
+  emails_count: number;
+};
+type WebhookSecret = {
+  /**
+   * The webhook signing secret value
+   */
+  secret: string;
+};
+/**
+ * A domain can be either verified or unverified. Verified domains have
+ * `is_active` and `spam_threshold` fields. Unverified domains have a
+ * `verification_token` for DNS verification.
+ *
+ */
+type Domain = VerifiedDomain | UnverifiedDomain;
+type VerifiedDomain = {
+  id: string;
+  org_id: string;
+  domain: string;
+  verified: boolean;
+  is_active: boolean;
+  spam_threshold?: number | null;
+  verification_token?: string | null;
+  created_at: string;
+};
+type UnverifiedDomain = {
+  id: string;
+  org_id: string;
+  domain: string;
+  verified: boolean;
+  /**
+   * Add this value as a TXT record to verify ownership
+   */
+  verification_token: string;
+  created_at: string;
+};
+type AddDomainInput = {
+  /**
+   * The domain name to claim (e.g. "example.com")
+   */
+  domain: string;
+};
+type UpdateDomainInput = {
+  /**
+   * Whether the domain accepts incoming emails
+   */
+  is_active?: boolean;
+  /**
+   * Per-domain spam threshold override (Pro plan required)
+   */
+  spam_threshold?: number | null;
+};
+type DomainVerifyResult = {
+  verified: boolean;
+} | {
+  verified: boolean;
+  /**
+   * Whether MX records point to Primitive
+   */
+  mxFound: boolean;
+  /**
+   * Whether the TXT verification record was found
+   */
+  txtFound: boolean;
+  /**
+   * Human-readable verification failure reason
+   */
+  error: string;
+};
+type EmailSummary = {
+  id: string;
+  message_id?: string | null;
+  domain_id?: string | null;
+  org_id?: string | null;
+  status: 'pending' | 'accepted' | 'completed' | 'rejected';
+  sender: string;
+  recipient: string;
+  subject?: string | null;
+  domain: string;
+  spam_score?: number | null;
+  created_at: string;
+  received_at: string;
+  raw_size_bytes?: number | null;
+  webhook_status?: 'pending' | 'in_flight' | 'fired' | 'failed' | 'exhausted' | null;
+  webhook_attempt_count: number;
+};
+type EmailDetail = {
+  id: string;
+  message_id?: string | null;
+  domain_id?: string | null;
+  org_id?: string | null;
+  sender: string;
+  recipient: string;
+  subject?: string | null;
+  status: 'pending' | 'accepted' | 'completed' | 'rejected';
+  domain: string;
+  spam_score?: number | null;
+  raw_size_bytes?: number | null;
+  raw_sha256?: string | null;
+  created_at: string;
+  received_at: string;
+  rejection_reason?: string | null;
+  webhook_status?: 'pending' | 'in_flight' | 'fired' | 'failed' | 'exhausted' | null;
+  webhook_attempt_count: number;
+  webhook_last_attempt_at?: string | null;
+  webhook_last_status_code?: number | null;
+  webhook_last_error?: string | null;
+  webhook_fired_at?: string | null;
+  smtp_helo?: string | null;
+  smtp_mail_from?: string | null;
+  smtp_rcpt_to?: Array<string> | null;
+  from_header?: string | null;
+  content_discarded_at?: string | null;
+  content_discarded_by_delivery_id?: string | null;
+  /**
+   * Parsed from address (from_header or sender fallback)
+   */
+  from_email: string;
+  /**
+   * Parsed to address (same as recipient)
+   */
+  to_email: string;
+};
+type SendMailInput = {
+  /**
+   * RFC 5322 From header. The sender domain must be a verified outbound domain for your organization.
+   */
+  from: string;
+  /**
+   * Recipient address. Recipient eligibility depends on your account's outbound entitlements.
+   */
+  to: string;
+  /**
+   * Subject line for the outbound message
+   */
+  subject: string;
+  /**
+   * Plain-text message body. At least one of body_text or body_html is required. The combined UTF-8 byte length of body_text and body_html must be at most 262144 bytes.
+   */
+  body_text?: string;
+  /**
+   * HTML message body. At least one of body_text or body_html is required. The combined UTF-8 byte length of body_text and body_html must be at most 262144 bytes.
+   */
+  body_html?: string;
+  /**
+   * Message-ID of the direct parent email when sending a threaded reply.
+   */
+  in_reply_to?: string;
+  /**
+   * Full ordered message-id chain for the thread.
+   */
+  references?: Array<string>;
+  /**
+   * When true, wait for the first downstream SMTP delivery outcome before returning.
+   */
+  wait?: boolean;
+  /**
+   * Maximum time to wait for a delivery outcome when wait is true. Defaults to 30000.
+   */
+  wait_timeout_ms?: number;
+};
+type SentEmailStatus = 'queued' | 'submitted_to_agent' | 'agent_failed' | 'unknown' | 'delivered' | 'bounced' | 'deferred' | 'wait_timeout';
+type DeliveryStatus = 'delivered' | 'bounced' | 'deferred' | 'wait_timeout';
+type SendMailResult = {
+  /**
+   * Persisted sent-email attempt ID.
+   */
+  id: string;
+  status: SentEmailStatus;
+  /**
+   * Message identifier assigned by Primitive's outbound relay, when available.
+   */
+  queue_id: string | null;
+  /**
+   * Recipient addresses accepted by the relay.
+   */
+  accepted: Array<string>;
+  /**
+   * Recipient addresses rejected by the relay.
+   */
+  rejected: Array<string>;
+  /**
+   * Effective idempotency key used for this send.
+   */
+  client_idempotency_key: string;
+  /**
+   * Server-issued request identifier for support and tracing.
+   */
+  request_id: string;
+  /**
+   * Stable hash of the canonical send payload.
+   */
+  content_hash: string;
+  delivery_status?: DeliveryStatus;
+  /**
+   * SMTP response code from the first downstream delivery outcome when wait is true.
+   */
+  smtp_response_code?: number | null;
+  /**
+   * SMTP response text from the first downstream delivery outcome when wait is true.
+   */
+  smtp_response_text?: string;
+};
+type Endpoint = {
+  id: string;
+  org_id: string;
+  url?: string | null;
+  enabled: boolean;
+  /**
+   * Restrict this endpoint to emails from a specific domain
+   */
+  domain_id?: string | null;
+  /**
+   * Endpoint-specific filtering rules
+   */
+  rules: {
+    [key: string]: unknown;
+  };
+  created_at: string;
+  updated_at: string;
+  /**
+   * Total webhook deliveries attempted
+   */
+  delivery_count: number;
+  /**
+   * Successful deliveries
+   */
+  success_count: number;
+  /**
+   * Failed deliveries
+   */
+  failure_count: number;
+  /**
+   * Current streak of consecutive failures
+   */
+  consecutive_fails: number;
+  last_delivery_at?: string | null;
+  last_success_at?: string | null;
+  last_failure_at?: string | null;
+  deactivated_at?: string | null;
+};
+type CreateEndpointInput = {
+  /**
+   * The webhook URL to deliver events to
+   */
+  url: string;
+  /**
+   * Whether the endpoint is active
+   */
+  enabled?: boolean;
+  /**
+   * Restrict to emails from a specific domain
+   */
+  domain_id?: string | null;
+  /**
+   * Endpoint-specific filtering rules
+   */
+  rules?: {
+    [key: string]: unknown;
+  };
+};
+type UpdateEndpointInput = {
+  /**
+   * New webhook URL (triggers endpoint rotation)
+   */
+  url?: string;
+  enabled?: boolean;
+  domain_id?: string | null;
+  rules?: {
+    [key: string]: unknown;
+  };
+};
+type TestResult = {
+  /**
+   * HTTP status code returned by the endpoint
+   */
+  status: number;
+  /**
+   * Response body (truncated to 1000 characters)
+   */
+  body: string;
+  /**
+   * The signature header value sent (if webhook secret is configured)
+   */
+  signature?: string;
+};
+type Filter = {
+  id: string;
+  org_id: string;
+  /**
+   * If set, filter applies only to this domain
+   */
+  domain_id?: string | null;
+  type: 'whitelist' | 'blocklist';
+  /**
+   * Email address or pattern to match (stored lowercase)
+   */
+  pattern: string;
+  enabled: boolean;
+  created_at: string;
+};
+type CreateFilterInput = {
+  type: 'whitelist' | 'blocklist';
+  /**
+   * Email address or pattern to filter
+   */
+  pattern: string;
+  /**
+   * Restrict filter to a specific domain (Pro plan required)
+   */
+  domain_id?: string | null;
+};
+type UpdateFilterInput = {
+  enabled: boolean;
+};
+type DeliverySummary = {
+  /**
+   * Delivery ID (numeric string)
+   */
+  id: string;
+  email_id: string;
+  org_id: string;
+  endpoint_id: string;
+  endpoint_url: string;
+  status: 'pending' | 'delivered' | 'header_confirmed' | 'failed';
+  attempt_count: number;
+  duration_ms?: number | null;
+  last_error?: string | null;
+  created_at: string;
+  updated_at: string;
+  email?: {
+    sender: string;
+    recipient: string;
+    subject?: string | null;
+  } | null;
+};
+type ReplayResult = {
+  /**
+   * Number of successful deliveries
+   */
+  delivered: number;
+  /**
+   * Number of failed deliveries
+   */
+  failed: number;
+};
+/**
+ * Resource UUID
+ */
+type ResourceId = string;
+/**
+ * Pagination cursor from a previous response's `meta.cursor` field.
+ * Format: `{ISO-datetime}|{id}`
+ *
+ */
+type Cursor = string;
+/**
+ * Number of results per page
+ */
+type Limit = number;
+type GetAccountData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/account';
+};
+type GetAccountErrors = {
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type GetAccountError = GetAccountErrors[keyof GetAccountErrors];
+type GetAccountResponses = {
+  /**
+   * Account details
+   */
+  200: SuccessEnvelope & {
+    data?: Account;
+  };
+};
+type GetAccountResponse = GetAccountResponses[keyof GetAccountResponses];
+type UpdateAccountData = {
+  body: UpdateAccountInput;
+  path?: never;
+  query?: never;
+  url: '/account';
+};
+type UpdateAccountErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type UpdateAccountError = UpdateAccountErrors[keyof UpdateAccountErrors];
+type UpdateAccountResponses = {
+  /**
+   * Updated account
+   */
+  200: SuccessEnvelope & {
+    data?: AccountUpdated;
+  };
+};
+type UpdateAccountResponse = UpdateAccountResponses[keyof UpdateAccountResponses];
+type GetStorageStatsData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/account/storage';
+};
+type GetStorageStatsErrors = {
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type GetStorageStatsError = GetStorageStatsErrors[keyof GetStorageStatsErrors];
+type GetStorageStatsResponses = {
+  /**
+   * Storage statistics
+   */
+  200: SuccessEnvelope & {
+    data?: StorageStats;
+  };
+};
+type GetStorageStatsResponse = GetStorageStatsResponses[keyof GetStorageStatsResponses];
+type GetWebhookSecretData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/account/webhook-secret';
+};
+type GetWebhookSecretErrors = {
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type GetWebhookSecretError = GetWebhookSecretErrors[keyof GetWebhookSecretErrors];
+type GetWebhookSecretResponses = {
+  /**
+   * Webhook secret
+   */
+  200: SuccessEnvelope & {
+    data?: WebhookSecret;
+  };
+};
+type GetWebhookSecretResponse = GetWebhookSecretResponses[keyof GetWebhookSecretResponses];
+type RotateWebhookSecretData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/account/webhook-secret/rotate';
+};
+type RotateWebhookSecretErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+  /**
+   * Rate limit exceeded
+   */
+  429: ErrorResponse;
+};
+type RotateWebhookSecretError = RotateWebhookSecretErrors[keyof RotateWebhookSecretErrors];
+type RotateWebhookSecretResponses = {
+  /**
+   * New webhook secret
+   */
+  200: SuccessEnvelope & {
+    data?: WebhookSecret;
+  };
+};
+type RotateWebhookSecretResponse = RotateWebhookSecretResponses[keyof RotateWebhookSecretResponses];
+type ListDomainsData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/domains';
+};
+type ListDomainsErrors = {
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+};
+type ListDomainsError = ListDomainsErrors[keyof ListDomainsErrors];
+type ListDomainsResponses = {
+  /**
+   * List of domains
+   */
+  200: SuccessEnvelope & {
+    data?: Array<Domain>;
+  };
+};
+type ListDomainsResponse = ListDomainsResponses[keyof ListDomainsResponses];
+type AddDomainData = {
+  body: AddDomainInput;
+  path?: never;
+  query?: never;
+  url: '/domains';
+};
+type AddDomainErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Domain claim conflicts with existing state. Two error codes
+   * are possible:
+   * * `mx_conflict`: the domain's current MX records point at
+   * another mailbox provider. The response includes
+   * `error.details.mx_conflict` with the detected provider
+   * and a suggested subdomain.
+   * * `conflict`: the domain is already claimed by another
+   * org, or a pending claim exists for another user.
+   *
+   */
+  409: ErrorResponse;
+};
+type AddDomainError = AddDomainErrors[keyof AddDomainErrors];
+type AddDomainResponses = {
+  /**
+   * Domain claim created
+   */
+  201: SuccessEnvelope & {
+    data?: UnverifiedDomain;
+  };
+};
+type AddDomainResponse = AddDomainResponses[keyof AddDomainResponses];
+type DeleteDomainData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/domains/{id}';
+};
+type DeleteDomainErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type DeleteDomainError = DeleteDomainErrors[keyof DeleteDomainErrors];
+type DeleteDomainResponses = {
+  /**
+   * Resource deleted
+   */
+  200: SuccessEnvelope & {
+    data?: {
+      deleted: boolean;
+    };
+  };
+};
+type DeleteDomainResponse = DeleteDomainResponses[keyof DeleteDomainResponses];
+type UpdateDomainData = {
+  body: UpdateDomainInput;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/domains/{id}';
+};
+type UpdateDomainErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type UpdateDomainError = UpdateDomainErrors[keyof UpdateDomainErrors];
+type UpdateDomainResponses = {
+  /**
+   * Updated domain
+   */
+  200: SuccessEnvelope & {
+    data?: VerifiedDomain;
+  };
+};
+type UpdateDomainResponse = UpdateDomainResponses[keyof UpdateDomainResponses];
+type VerifyDomainData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/domains/{id}/verify';
+};
+type VerifyDomainErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type VerifyDomainError = VerifyDomainErrors[keyof VerifyDomainErrors];
+type VerifyDomainResponses = {
+  /**
+   * Verification result
+   */
+  200: SuccessEnvelope & {
+    data?: DomainVerifyResult;
+  };
+};
+type VerifyDomainResponse = VerifyDomainResponses[keyof VerifyDomainResponses];
+type ListEmailsData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Pagination cursor from a previous response's `meta.cursor` field.
+     * Format: `{ISO-datetime}|{id}`
+     *
+     */
+    cursor?: string;
+    /**
+     * Number of results per page
+     */
+    limit?: number;
+    /**
+     * Filter by domain ID
+     */
+    domain_id?: string;
+    /**
+     * Filter by email status
+     */
+    status?: 'pending' | 'accepted' | 'completed' | 'rejected';
+    /**
+     * Search subject, sender, and recipient (case-insensitive)
+     */
+    search?: string;
+    /**
+     * Filter emails created on or after this timestamp
+     */
+    date_from?: string;
+    /**
+     * Filter emails created on or before this timestamp
+     */
+    date_to?: string;
+  };
+  url: '/emails';
+};
+type ListEmailsErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+};
+type ListEmailsError = ListEmailsErrors[keyof ListEmailsErrors];
+type ListEmailsResponses = {
+  /**
+   * Paginated list of emails
+   */
+  200: ListEnvelope & {
+    data?: Array<EmailSummary>;
+  };
+};
+type ListEmailsResponse = ListEmailsResponses[keyof ListEmailsResponses];
+type DeleteEmailData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/emails/{id}';
+};
+type DeleteEmailErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type DeleteEmailError = DeleteEmailErrors[keyof DeleteEmailErrors];
+type DeleteEmailResponses = {
+  /**
+   * Resource deleted
+   */
+  200: SuccessEnvelope & {
+    data?: {
+      deleted: boolean;
+    };
+  };
+};
+type DeleteEmailResponse = DeleteEmailResponses[keyof DeleteEmailResponses];
+type GetEmailData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/emails/{id}';
+};
+type GetEmailErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type GetEmailError = GetEmailErrors[keyof GetEmailErrors];
+type GetEmailResponses = {
+  /**
+   * Email details
+   */
+  200: SuccessEnvelope & {
+    data?: EmailDetail;
+  };
+};
+type GetEmailResponse = GetEmailResponses[keyof GetEmailResponses];
+type DownloadRawEmailData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: {
+    /**
+     * Signed download token from webhook payload
+     */
+    token?: string;
+  };
+  url: '/emails/{id}/raw';
+};
+type DownloadRawEmailErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type DownloadRawEmailError = DownloadRawEmailErrors[keyof DownloadRawEmailErrors];
+type DownloadRawEmailResponses = {
+  /**
+   * Raw email file
+   */
+  200: Blob | File;
+};
+type DownloadRawEmailResponse = DownloadRawEmailResponses[keyof DownloadRawEmailResponses];
+type DownloadAttachmentsData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: {
+    /**
+     * Signed download token from webhook payload
+     */
+    token?: string;
+  };
+  url: '/emails/{id}/attachments.tar.gz';
+};
+type DownloadAttachmentsErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type DownloadAttachmentsError = DownloadAttachmentsErrors[keyof DownloadAttachmentsErrors];
+type DownloadAttachmentsResponses = {
+  /**
+   * Attachments archive
+   */
+  200: Blob | File;
+};
+type DownloadAttachmentsResponse = DownloadAttachmentsResponses[keyof DownloadAttachmentsResponses];
+type ReplayEmailWebhooksData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/emails/{id}/replay';
+};
+type ReplayEmailWebhooksErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+  /**
+   * Rate limit exceeded
+   */
+  429: ErrorResponse;
+};
+type ReplayEmailWebhooksError = ReplayEmailWebhooksErrors[keyof ReplayEmailWebhooksErrors];
+type ReplayEmailWebhooksResponses = {
+  /**
+   * Replay result
+   */
+  200: SuccessEnvelope & {
+    data?: ReplayResult;
+  };
+};
+type ReplayEmailWebhooksResponse = ReplayEmailWebhooksResponses[keyof ReplayEmailWebhooksResponses];
+type ListEndpointsData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/endpoints';
+};
+type ListEndpointsErrors = {
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+};
+type ListEndpointsError = ListEndpointsErrors[keyof ListEndpointsErrors];
+type ListEndpointsResponses = {
+  /**
+   * List of endpoints
+   */
+  200: SuccessEnvelope & {
+    data?: Array<Endpoint>;
+  };
+};
+type ListEndpointsResponse = ListEndpointsResponses[keyof ListEndpointsResponses];
+type CreateEndpointData = {
+  body: CreateEndpointInput;
+  path?: never;
+  query?: never;
+  url: '/endpoints';
+};
+type CreateEndpointErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+};
+type CreateEndpointError = CreateEndpointErrors[keyof CreateEndpointErrors];
+type CreateEndpointResponses = {
+  /**
+   * Endpoint created (or reactivated)
+   */
+  201: SuccessEnvelope & {
+    data?: Endpoint;
+  };
+};
+type CreateEndpointResponse = CreateEndpointResponses[keyof CreateEndpointResponses];
+type DeleteEndpointData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/endpoints/{id}';
+};
+type DeleteEndpointErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type DeleteEndpointError = DeleteEndpointErrors[keyof DeleteEndpointErrors];
+type DeleteEndpointResponses = {
+  /**
+   * Resource deleted
+   */
+  200: SuccessEnvelope & {
+    data?: {
+      deleted: boolean;
+    };
+  };
+};
+type DeleteEndpointResponse = DeleteEndpointResponses[keyof DeleteEndpointResponses];
+type UpdateEndpointData = {
+  body: UpdateEndpointInput;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/endpoints/{id}';
+};
+type UpdateEndpointErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type UpdateEndpointError = UpdateEndpointErrors[keyof UpdateEndpointErrors];
+type UpdateEndpointResponses = {
+  /**
+   * Updated endpoint
+   */
+  200: SuccessEnvelope & {
+    data?: Endpoint;
+  };
+};
+type UpdateEndpointResponse = UpdateEndpointResponses[keyof UpdateEndpointResponses];
+type TestEndpointData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/endpoints/{id}/test';
+};
+type TestEndpointErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+  /**
+   * Rate limit exceeded
+   */
+  429: ErrorResponse;
+};
+type TestEndpointError = TestEndpointErrors[keyof TestEndpointErrors];
+type TestEndpointResponses = {
+  /**
+   * Test result
+   */
+  200: SuccessEnvelope & {
+    data?: TestResult;
+  };
+};
+type TestEndpointResponse = TestEndpointResponses[keyof TestEndpointResponses];
+type ListFiltersData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/filters';
+};
+type ListFiltersErrors = {
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+};
+type ListFiltersError = ListFiltersErrors[keyof ListFiltersErrors];
+type ListFiltersResponses = {
+  /**
+   * List of filters
+   */
+  200: SuccessEnvelope & {
+    data?: Array<Filter>;
+  };
+};
+type ListFiltersResponse = ListFiltersResponses[keyof ListFiltersResponses];
+type CreateFilterData = {
+  body: CreateFilterInput;
+  path?: never;
+  query?: never;
+  url: '/filters';
+};
+type CreateFilterErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type CreateFilterError = CreateFilterErrors[keyof CreateFilterErrors];
+type CreateFilterResponses = {
+  /**
+   * Filter created
+   */
+  201: SuccessEnvelope & {
+    data?: Filter;
+  };
+};
+type CreateFilterResponse = CreateFilterResponses[keyof CreateFilterResponses];
+type DeleteFilterData = {
+  body?: never;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/filters/{id}';
+};
+type DeleteFilterErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type DeleteFilterError = DeleteFilterErrors[keyof DeleteFilterErrors];
+type DeleteFilterResponses = {
+  /**
+   * Resource deleted
+   */
+  200: SuccessEnvelope & {
+    data?: {
+      deleted: boolean;
+    };
+  };
+};
+type DeleteFilterResponse = DeleteFilterResponses[keyof DeleteFilterResponses];
+type UpdateFilterData = {
+  body: UpdateFilterInput;
+  path: {
+    /**
+     * Resource UUID
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/filters/{id}';
+};
+type UpdateFilterErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+};
+type UpdateFilterError = UpdateFilterErrors[keyof UpdateFilterErrors];
+type UpdateFilterResponses = {
+  /**
+   * Updated filter
+   */
+  200: SuccessEnvelope & {
+    data?: Filter;
+  };
+};
+type UpdateFilterResponse = UpdateFilterResponses[keyof UpdateFilterResponses];
+type ListDeliveriesData = {
+  body?: never;
+  path?: never;
+  query?: {
+    /**
+     * Pagination cursor from a previous response's `meta.cursor` field.
+     * Format: `{ISO-datetime}|{id}`
+     *
+     */
+    cursor?: string;
+    /**
+     * Number of results per page
+     */
+    limit?: number;
+    /**
+     * Filter by email ID
+     */
+    email_id?: string;
+    /**
+     * Filter by delivery status
+     */
+    status?: 'pending' | 'delivered' | 'header_confirmed' | 'failed';
+    /**
+     * Filter deliveries created on or after this timestamp
+     */
+    date_from?: string;
+    /**
+     * Filter deliveries created on or before this timestamp
+     */
+    date_to?: string;
+  };
+  url: '/webhooks/deliveries';
+};
+type ListDeliveriesErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+};
+type ListDeliveriesError = ListDeliveriesErrors[keyof ListDeliveriesErrors];
+type ListDeliveriesResponses = {
+  /**
+   * Paginated list of deliveries
+   */
+  200: ListEnvelope & {
+    data?: Array<DeliverySummary>;
+  };
+};
+type ListDeliveriesResponse = ListDeliveriesResponses[keyof ListDeliveriesResponses];
+type ReplayDeliveryData = {
+  body?: never;
+  path: {
+    /**
+     * Delivery ID (numeric)
+     */
+    id: string;
+  };
+  query?: never;
+  url: '/webhooks/deliveries/{id}/replay';
+};
+type ReplayDeliveryErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Resource not found
+   */
+  404: ErrorResponse;
+  /**
+   * Rate limit exceeded
+   */
+  429: ErrorResponse;
+};
+type ReplayDeliveryError = ReplayDeliveryErrors[keyof ReplayDeliveryErrors];
+type ReplayDeliveryResponses = {
+  /**
+   * Replay result
+   */
+  200: SuccessEnvelope & {
+    data?: ReplayResult;
+  };
+};
+type ReplayDeliveryResponse = ReplayDeliveryResponses[keyof ReplayDeliveryResponses];
+type SendEmailData = {
+  body: SendMailInput;
+  headers?: {
+    /**
+     * Optional customer-supplied idempotency key. If omitted, Primitive
+     * derives one from the canonical request payload and echoes the
+     * effective value in the `Idempotency-Key` response header.
+     *
+     */
+    'Idempotency-Key'?: string;
+  };
+  path?: never;
+  query?: never;
+  url: '/send-mail';
+};
+type SendEmailErrors = {
+  /**
+   * Invalid request parameters
+   */
+  400: ErrorResponse;
+  /**
+   * Invalid or missing API key
+   */
+  401: ErrorResponse;
+  /**
+   * Authenticated caller lacks permission for the operation
+   */
+  403: ErrorResponse;
+  /**
+   * Rate limit exceeded
+   */
+  429: ErrorResponse;
+  /**
+   * Primitive encountered an internal error
+   */
+  500: ErrorResponse;
+  /**
+   * Primitive could not complete the downstream SMTP request
+   */
+  502: ErrorResponse;
+  /**
+   * Primitive is temporarily unable to process the request
+   */
+  503: ErrorResponse;
+};
+type SendEmailError = SendEmailErrors[keyof SendEmailErrors];
+type SendEmailResponses = {
+  /**
+   * Outbound relay result
+   */
+  200: SuccessEnvelope & {
+    data?: SendMailResult;
+  };
+};
+type SendEmailResponse = SendEmailResponses[keyof SendEmailResponses]; //#endregion
+//#region src/api/generated/sdk.gen.d.ts
+declare namespace sdk_gen_d_exports {
+  export { Options$1 as Options, addDomain, createEndpoint, createFilter, deleteDomain, deleteEmail, deleteEndpoint, deleteFilter, downloadAttachments, downloadRawEmail, getAccount, getEmail, getStorageStats, getWebhookSecret, listDeliveries, listDomains, listEmails, listEndpoints, listFilters, replayDelivery, replayEmailWebhooks, rotateWebhookSecret, sendEmail, testEndpoint, updateAccount, updateDomain, updateEndpoint, updateFilter, verifyDomain };
+}
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$2<TData, ThrowOnError, TResponse> & {
+  /**
+   * You can provide a client instance returned by `createClient()` instead of
+   * individual options. This might be also useful if you want to implement a
+   * custom client.
+   */
+  client?: Client;
+  /**
+   * You can pass arbitrary values through the `meta` object. This can be
+   * used to access values that aren't defined as part of the SDK function.
+   */
+  meta?: Record<string, unknown>;
+};
+/**
+ * Get account info
+ */
+declare const getAccount: <ThrowOnError extends boolean = false>(options?: Options$1<GetAccountData, ThrowOnError>) => RequestResult<GetAccountResponses, GetAccountErrors, ThrowOnError, "fields">;
+/**
+ * Update account settings
+ */
+declare const updateAccount: <ThrowOnError extends boolean = false>(options: Options$1<UpdateAccountData, ThrowOnError>) => RequestResult<UpdateAccountResponses, UpdateAccountErrors, ThrowOnError, "fields">;
+/**
+ * Get storage usage
+ */
+declare const getStorageStats: <ThrowOnError extends boolean = false>(options?: Options$1<GetStorageStatsData, ThrowOnError>) => RequestResult<GetStorageStatsResponses, GetStorageStatsErrors, ThrowOnError, "fields">;
+/**
+ * Get webhook signing secret
+ *
+ * Returns the webhook signing secret for your account. If no secret
+ * exists yet, one is generated automatically on first access.
+ *
+ */
+declare const getWebhookSecret: <ThrowOnError extends boolean = false>(options?: Options$1<GetWebhookSecretData, ThrowOnError>) => RequestResult<GetWebhookSecretResponses, GetWebhookSecretErrors, ThrowOnError, "fields">;
+/**
+ * Rotate webhook signing secret
+ *
+ * Generates a new webhook signing secret, replacing the current one.
+ * Rate limited to once per 60 minutes.
+ *
+ */
+declare const rotateWebhookSecret: <ThrowOnError extends boolean = false>(options?: Options$1<RotateWebhookSecretData, ThrowOnError>) => RequestResult<RotateWebhookSecretResponses, RotateWebhookSecretErrors, ThrowOnError, "fields">;
+/**
+ * List all domains
+ *
+ * Returns all verified and unverified domains for your organization,
+ * sorted by creation date (newest first). Each domain includes a
+ * `verified` boolean to distinguish between the two states.
+ *
+ */
+declare const listDomains: <ThrowOnError extends boolean = false>(options?: Options$1<ListDomainsData, ThrowOnError>) => RequestResult<ListDomainsResponses, ListDomainsErrors, ThrowOnError, "fields">;
+/**
+ * Claim a new domain
+ *
+ * Creates an unverified domain claim. You will receive a
+ * `verification_token` to add as a DNS TXT record before
+ * calling the verify endpoint.
+ *
+ */
+declare const addDomain: <ThrowOnError extends boolean = false>(options: Options$1<AddDomainData, ThrowOnError>) => RequestResult<AddDomainResponses, AddDomainErrors, ThrowOnError, "fields">;
+/**
+ * Delete a domain
+ *
+ * Deletes a verified or unverified domain claim.
+ */
+declare const deleteDomain: <ThrowOnError extends boolean = false>(options: Options$1<DeleteDomainData, ThrowOnError>) => RequestResult<DeleteDomainResponses, DeleteDomainErrors, ThrowOnError, "fields">;
+/**
+ * Update domain settings
+ *
+ * Update a verified domain's settings. Only verified domains can be
+ * updated. Per-domain spam thresholds require a Pro plan.
+ *
+ */
+declare const updateDomain: <ThrowOnError extends boolean = false>(options: Options$1<UpdateDomainData, ThrowOnError>) => RequestResult<UpdateDomainResponses, UpdateDomainErrors, ThrowOnError, "fields">;
+/**
+ * Verify domain ownership
+ *
+ * Checks DNS records (MX and TXT) to verify domain ownership.
+ * On success, the domain is promoted from unverified to verified.
+ * On failure, returns which checks passed and which failed.
+ *
+ */
+declare const verifyDomain: <ThrowOnError extends boolean = false>(options: Options$1<VerifyDomainData, ThrowOnError>) => RequestResult<VerifyDomainResponses, VerifyDomainErrors, ThrowOnError, "fields">;
+/**
+ * List emails
+ *
+ * Returns a paginated list of received emails. Supports filtering by
+ * domain, status, date range, and free-text search across subject,
+ * sender, and recipient fields.
+ *
+ */
+declare const listEmails: <ThrowOnError extends boolean = false>(options?: Options$1<ListEmailsData, ThrowOnError>) => RequestResult<ListEmailsResponses, ListEmailsErrors, ThrowOnError, "fields">;
+/**
+ * Delete an email
+ */
+declare const deleteEmail: <ThrowOnError extends boolean = false>(options: Options$1<DeleteEmailData, ThrowOnError>) => RequestResult<DeleteEmailResponses, DeleteEmailErrors, ThrowOnError, "fields">;
+/**
+ * Get email details
+ */
+declare const getEmail: <ThrowOnError extends boolean = false>(options: Options$1<GetEmailData, ThrowOnError>) => RequestResult<GetEmailResponses, GetEmailErrors, ThrowOnError, "fields">;
+/**
+ * Download raw email
+ *
+ * Downloads the raw RFC 822 email file (.eml). Authenticates via
+ * a signed download token (provided in webhook payloads) or a
+ * valid session.
+ *
+ */
+declare const downloadRawEmail: <ThrowOnError extends boolean = false>(options: Options$1<DownloadRawEmailData, ThrowOnError>) => RequestResult<DownloadRawEmailResponses, DownloadRawEmailErrors, ThrowOnError, "fields">;
+/**
+ * Download email attachments
+ *
+ * Downloads all attachments as a gzip-compressed tar archive.
+ * Authenticates via a signed download token (provided in webhook
+ * payloads) or a valid session.
+ *
+ */
+declare const downloadAttachments: <ThrowOnError extends boolean = false>(options: Options$1<DownloadAttachmentsData, ThrowOnError>) => RequestResult<DownloadAttachmentsResponses, DownloadAttachmentsErrors, ThrowOnError, "fields">;
+/**
+ * Replay email webhooks
+ *
+ * Re-delivers the webhook payload for this email to all active
+ * endpoints matching the email's domain. Rate limited per-email
+ * (short cooldown between successive replays of the same email)
+ * and per-org (burst + sustained windows), sharing an org-wide
+ * budget with delivery replays.
+ *
+ */
+declare const replayEmailWebhooks: <ThrowOnError extends boolean = false>(options: Options$1<ReplayEmailWebhooksData, ThrowOnError>) => RequestResult<ReplayEmailWebhooksResponses, ReplayEmailWebhooksErrors, ThrowOnError, "fields">;
+/**
+ * List webhook endpoints
+ *
+ * Returns all active (non-deleted) webhook endpoints.
+ */
+declare const listEndpoints: <ThrowOnError extends boolean = false>(options?: Options$1<ListEndpointsData, ThrowOnError>) => RequestResult<ListEndpointsResponses, ListEndpointsErrors, ThrowOnError, "fields">;
+/**
+ * Create a webhook endpoint
+ *
+ * Creates a new webhook endpoint. If a deactivated endpoint with the
+ * same URL and domain exists, it is reactivated instead.
+ * Subject to plan limits on the number of active endpoints.
+ *
+ */
+declare const createEndpoint: <ThrowOnError extends boolean = false>(options: Options$1<CreateEndpointData, ThrowOnError>) => RequestResult<CreateEndpointResponses, CreateEndpointErrors, ThrowOnError, "fields">;
+/**
+ * Delete a webhook endpoint
+ *
+ * Soft-deletes a webhook endpoint. The endpoint will no longer
+ * receive webhook deliveries.
+ *
+ */
+declare const deleteEndpoint: <ThrowOnError extends boolean = false>(options: Options$1<DeleteEndpointData, ThrowOnError>) => RequestResult<DeleteEndpointResponses, DeleteEndpointErrors, ThrowOnError, "fields">;
+/**
+ * Update a webhook endpoint
+ *
+ * Updates an active webhook endpoint. If the URL is changed, the old
+ * endpoint is deactivated and a new one is created (or an existing
+ * deactivated endpoint with the new URL is reactivated).
+ *
+ */
+declare const updateEndpoint: <ThrowOnError extends boolean = false>(options: Options$1<UpdateEndpointData, ThrowOnError>) => RequestResult<UpdateEndpointResponses, UpdateEndpointErrors, ThrowOnError, "fields">;
+/**
+ * Send a test webhook
+ *
+ * Sends a sample `email.received` event to the endpoint. The request
+ * includes SSRF protection (private IP rejection and DNS pinning).
+ * Rate limited to 4 per minute and 30 per hour (non-exempt).
+ * Successful deliveries and verified-domain endpoints are exempt
+ * from the rate limit.
+ *
+ */
+declare const testEndpoint: <ThrowOnError extends boolean = false>(options: Options$1<TestEndpointData, ThrowOnError>) => RequestResult<TestEndpointResponses, TestEndpointErrors, ThrowOnError, "fields">;
+/**
+ * List filter rules
+ *
+ * Returns all whitelist and blocklist filter rules.
+ */
+declare const listFilters: <ThrowOnError extends boolean = false>(options?: Options$1<ListFiltersData, ThrowOnError>) => RequestResult<ListFiltersResponses, ListFiltersErrors, ThrowOnError, "fields">;
+/**
+ * Create a filter rule
+ *
+ * Creates a new whitelist or blocklist filter. Per-domain filters
+ * require a Pro plan. Patterns are stored as lowercase.
+ *
+ */
+declare const createFilter: <ThrowOnError extends boolean = false>(options: Options$1<CreateFilterData, ThrowOnError>) => RequestResult<CreateFilterResponses, CreateFilterErrors, ThrowOnError, "fields">;
+/**
+ * Delete a filter rule
+ */
+declare const deleteFilter: <ThrowOnError extends boolean = false>(options: Options$1<DeleteFilterData, ThrowOnError>) => RequestResult<DeleteFilterResponses, DeleteFilterErrors, ThrowOnError, "fields">;
+/**
+ * Update a filter rule
+ *
+ * Toggle a filter's enabled state.
+ */
+declare const updateFilter: <ThrowOnError extends boolean = false>(options: Options$1<UpdateFilterData, ThrowOnError>) => RequestResult<UpdateFilterResponses, UpdateFilterErrors, ThrowOnError, "fields">;
+/**
+ * List webhook deliveries
+ *
+ * Returns a paginated list of webhook delivery attempts. Each delivery
+ * includes a nested `email` object with sender, recipient, and subject.
+ *
+ */
+declare const listDeliveries: <ThrowOnError extends boolean = false>(options?: Options$1<ListDeliveriesData, ThrowOnError>) => RequestResult<ListDeliveriesResponses, ListDeliveriesErrors, ThrowOnError, "fields">;
+/**
+ * Replay a webhook delivery
+ *
+ * Re-sends the stored webhook payload from a previous delivery attempt.
+ * If the original endpoint is still active, it is targeted. If the
+ * original endpoint was deleted, the oldest active endpoint is used.
+ * Deactivated endpoints cannot be replayed to. Rate limited per-org,
+ * sharing an org-wide budget with email replays.
+ *
+ */
+declare const replayDelivery: <ThrowOnError extends boolean = false>(options: Options$1<ReplayDeliveryData, ThrowOnError>) => RequestResult<ReplayDeliveryResponses, ReplayDeliveryErrors, ThrowOnError, "fields">;
+/**
+ * Send outbound email
+ *
+ * Sends an outbound email through Primitive's outbound relay. By default
+ * the request returns once the relay accepts the message for delivery.
+ * Set `wait: true` to wait for the first downstream SMTP delivery outcome.
+ *
+ */
+declare const sendEmail: <ThrowOnError extends boolean = false>(options: Options$1<SendEmailData, ThrowOnError>) => RequestResult<SendEmailResponses, SendEmailErrors, ThrowOnError, "fields">;
+
+//#endregion
+//#region src/api/index.d.ts
+declare const DEFAULT_BASE_URL = "https://www.primitive.dev/api/v1";
+interface PrimitiveApiClientOptions extends Omit<Config, "auth" | "baseUrl"> {
+  apiKey?: string;
+  auth?: Config["auth"];
+  baseUrl?: string;
+}
+interface SendThreadInput {
+  inReplyTo?: string;
+  references?: string[];
+}
+interface SendInput {
+  from: string;
+  to: string;
+  subject: string;
+  bodyText?: string;
+  bodyHtml?: string;
+  thread?: SendThreadInput;
+  wait?: boolean;
+  waitTimeoutMs?: number;
+  idempotencyKey?: string;
+}
+type ReplyInput = string | {
+  text: string;
+  subject?: string;
+  from?: string;
+};
+interface ForwardInput {
+  to: string;
+  bodyText?: string;
+  subject?: string;
+  from?: string;
+}
+interface SendResult {
+  id: string;
+  status: SendMailResult["status"];
+  queueId: string | null;
+  accepted: string[];
+  rejected: string[];
+  clientIdempotencyKey: string;
+  requestId: string;
+  contentHash: string;
+  deliveryStatus?: SendMailResult["delivery_status"];
+  smtpResponseCode?: number | null;
+  smtpResponseText?: string;
+}
+type PrimitiveApiErrorDetails = NonNullable<ErrorResponse["error"]["details"]>;
+declare class PrimitiveApiError extends Error {
+  readonly status: number | undefined;
+  readonly code: string | undefined;
+  readonly gates: GateDenial[] | undefined;
+  readonly requestId: string | undefined;
+  readonly retryAfter: number | undefined;
+  readonly details: PrimitiveApiErrorDetails | undefined;
+  readonly payload: unknown;
+  constructor(message: string, options: {
+    payload: unknown;
+    status?: number;
+    code?: string;
+    gates?: GateDenial[];
+    requestId?: string;
+    retryAfter?: number;
+    details?: PrimitiveApiErrorDetails;
+  });
+}
+declare class PrimitiveApiClient {
+  readonly client: Client;
+  constructor(options?: PrimitiveApiClientOptions);
+  getConfig(): Config<ClientOptions$1>;
+  setConfig(config: Config): Config<ClientOptions$1>;
+}
+type PrimitiveClientOptions = PrimitiveApiClientOptions;
+declare class PrimitiveClient extends PrimitiveApiClient {
+  send(input: SendInput): Promise<SendResult>;
+  reply(email: ReceivedEmail, input: ReplyInput): Promise<SendResult>;
+  forward(email: ReceivedEmail, input: ForwardInput): Promise<SendResult>;
+}
+declare function createPrimitiveApiClient(options?: PrimitiveApiClientOptions): PrimitiveApiClient;
+declare function createPrimitiveClient(options?: PrimitiveClientOptions): PrimitiveClient;
+declare function client(options?: PrimitiveClientOptions): PrimitiveClient;
+declare const operations: typeof sdk_gen_d_exports;
+
+//#endregion
+export { Account, AccountUpdated, AddDomainData, AddDomainError, AddDomainErrors, AddDomainInput, AddDomainResponse, AddDomainResponses, Auth, Client, ClientOptions, ClientOptions$1, Config, CreateClientConfig, CreateEndpointData, CreateEndpointError, CreateEndpointErrors, CreateEndpointInput, CreateEndpointResponse, CreateEndpointResponses, CreateFilterData, CreateFilterError, CreateFilterErrors, CreateFilterInput, CreateFilterResponse, CreateFilterResponses, Cursor, DEFAULT_BASE_URL as DEFAULT_BASE_URL$1, DeleteDomainData, DeleteDomainError, DeleteDomainErrors, DeleteDomainResponse, DeleteDomainResponses, DeleteEmailData, DeleteEmailError, DeleteEmailErrors, DeleteEmailResponse, DeleteEmailResponses, DeleteEndpointData, DeleteEndpointError, DeleteEndpointErrors, DeleteEndpointResponse, DeleteEndpointResponses, DeleteFilterData, DeleteFilterError, DeleteFilterErrors, DeleteFilterResponse, DeleteFilterResponses, DeliveryStatus, DeliverySummary, Domain, DomainVerifyResult, DownloadAttachmentsData, DownloadAttachmentsError, DownloadAttachmentsErrors, DownloadAttachmentsResponse, DownloadAttachmentsResponses, DownloadRawEmailData, DownloadRawEmailError, DownloadRawEmailErrors, DownloadRawEmailResponse, DownloadRawEmailResponses, EmailDetail, EmailSummary, Endpoint, ErrorResponse, Filter, ForwardInput, GateDenial, GateFix, GetAccountData, GetAccountError, GetAccountErrors, GetAccountResponse, GetAccountResponses, GetEmailData, GetEmailError, GetEmailErrors, GetEmailResponse, GetEmailResponses, GetStorageStatsData, GetStorageStatsError, GetStorageStatsErrors, GetStorageStatsResponse, GetStorageStatsResponses, GetWebhookSecretData, GetWebhookSecretError, GetWebhookSecretErrors, GetWebhookSecretResponse, GetWebhookSecretResponses, Limit, ListDeliveriesData, ListDeliveriesError, ListDeliveriesErrors, ListDeliveriesResponse, ListDeliveriesResponses, ListDomainsData, ListDomainsError, ListDomainsErrors, ListDomainsResponse, ListDomainsResponses, ListEmailsData, ListEmailsError, ListEmailsErrors, ListEmailsResponse, ListEmailsResponses, ListEndpointsData, ListEndpointsError, ListEndpointsErrors, ListEndpointsResponse, ListEndpointsResponses, ListEnvelope, ListFiltersData, ListFiltersError, ListFiltersErrors, ListFiltersResponse, ListFiltersResponses, Options$1 as Options, Options$2 as Options$1, PaginationMeta, PrimitiveApiClient as PrimitiveApiClient$1, PrimitiveApiClientOptions, PrimitiveApiError as PrimitiveApiError$1, PrimitiveApiErrorDetails, PrimitiveClient as PrimitiveClient$1, PrimitiveClientOptions, ReplayDeliveryData, ReplayDeliveryError, ReplayDeliveryErrors, ReplayDeliveryResponse, ReplayDeliveryResponses, ReplayEmailWebhooksData, ReplayEmailWebhooksError, ReplayEmailWebhooksErrors, ReplayEmailWebhooksResponse, ReplayEmailWebhooksResponses, ReplayResult, ReplyInput, RequestOptions, RequestResult, ResourceId, ResponseStyle, RotateWebhookSecretData, RotateWebhookSecretError, RotateWebhookSecretErrors, RotateWebhookSecretResponse, RotateWebhookSecretResponses, SendEmailData, SendEmailError, SendEmailErrors, SendEmailResponse, SendEmailResponses, SendInput, SendMailInput, SendMailResult, SendResult, SendThreadInput, SentEmailStatus, StorageStats, SuccessEnvelope, TestEndpointData, TestEndpointError, TestEndpointErrors, TestEndpointResponse, TestEndpointResponses, TestResult, UnverifiedDomain, UpdateAccountData, UpdateAccountError, UpdateAccountErrors, UpdateAccountInput, UpdateAccountResponse, UpdateAccountResponses, UpdateDomainData, UpdateDomainError, UpdateDomainErrors, UpdateDomainInput, UpdateDomainResponse, UpdateDomainResponses, UpdateEndpointData, UpdateEndpointError, UpdateEndpointErrors, UpdateEndpointInput, UpdateEndpointResponse, UpdateEndpointResponses, UpdateFilterData, UpdateFilterError, UpdateFilterErrors, UpdateFilterInput, UpdateFilterResponse, UpdateFilterResponses, VerifiedDomain, VerifyDomainData, VerifyDomainError, VerifyDomainErrors, VerifyDomainResponse, VerifyDomainResponses, WebhookSecret, addDomain as addDomain$1, client as client$1, createEndpoint as createEndpoint$1, createFilter as createFilter$1, createPrimitiveApiClient as createPrimitiveApiClient$1, createPrimitiveClient as createPrimitiveClient$1, deleteDomain as deleteDomain$1, deleteEmail as deleteEmail$1, deleteEndpoint as deleteEndpoint$1, deleteFilter as deleteFilter$1, downloadAttachments as downloadAttachments$1, downloadRawEmail as downloadRawEmail$1, getAccount as getAccount$1, getEmail as getEmail$1, getStorageStats as getStorageStats$1, getWebhookSecret as getWebhookSecret$1, listDeliveries as listDeliveries$1, listDomains as listDomains$1, listEmails as listEmails$1, listEndpoints as listEndpoints$1, listFilters as listFilters$1, operations as operations$1, replayDelivery as replayDelivery$1, replayEmailWebhooks as replayEmailWebhooks$1, rotateWebhookSecret as rotateWebhookSecret$1, sendEmail as sendEmail$1, testEndpoint as testEndpoint$1, updateAccount as updateAccount$1, updateDomain as updateDomain$1, updateEndpoint as updateEndpoint$1, updateFilter as updateFilter$1, verifyDomain as verifyDomain$1 };