@primitivedotdev/sdk 0.7.0 → 0.9.0

package/dist/index-DVow4Fjd.d.ts

@@ -0,0 +1,2140 @@
+import { t as ReceivedEmail } from "./received-email-DNjpq_Wt.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;
+  request: RequestFn;
+  setConfig: (config: Config) => Config;
+} & { [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 = <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 = <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 = <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 = <TData extends {
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+  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$1<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' | '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];
+declare namespace sdk_gen_d_exports {
+  export { 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<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<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<GetAccountData, ThrowOnError>) => RequestResult<GetAccountResponses, GetAccountErrors, ThrowOnError, "fields">;
+/**
+ * Update account settings
+ */
+declare const updateAccount: <ThrowOnError extends boolean = false>(options: Options<UpdateAccountData, ThrowOnError>) => RequestResult<UpdateAccountResponses, UpdateAccountErrors, ThrowOnError, "fields">;
+/**
+ * Get storage usage
+ */
+declare const getStorageStats: <ThrowOnError extends boolean = false>(options?: Options<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<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<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<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<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<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<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<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<ListEmailsData, ThrowOnError>) => RequestResult<ListEmailsResponses, ListEmailsErrors, ThrowOnError, "fields">;
+/**
+ * Delete an email
+ */
+declare const deleteEmail: <ThrowOnError extends boolean = false>(options: Options<DeleteEmailData, ThrowOnError>) => RequestResult<DeleteEmailResponses, DeleteEmailErrors, ThrowOnError, "fields">;
+/**
+ * Get email details
+ */
+declare const getEmail: <ThrowOnError extends boolean = false>(options: Options<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<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<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<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<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<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<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<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<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<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<CreateFilterData, ThrowOnError>) => RequestResult<CreateFilterResponses, CreateFilterErrors, ThrowOnError, "fields">;
+/**
+ * Delete a filter rule
+ */
+declare const deleteFilter: <ThrowOnError extends boolean = false>(options: Options<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<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<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<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<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 { AddDomainResponses as $, ReplayDeliveryResponses as $n, VerifiedDomain as $r, GateDenial as $t, getWebhookSecret as A, ListDomainsResponse as An, UpdateAccountError as Ar, DeleteFilterError as At, testEndpoint as B, ListEndpointsResponse as Bn, UpdateDomainResponses as Br, DownloadAttachmentsErrors as Bt, deleteEndpoint as C, ListDeliveriesError as Cn, TestEndpointError as Cr, DeleteEmailResponses as Ct, getAccount as D, ListDomainsData as Dn, TestResult as Dr, DeleteEndpointResponse as Dt, downloadRawEmail as E, ListDeliveriesResponses as En, TestEndpointResponses as Er, DeleteEndpointErrors as Et, listFilters as F, ListEmailsResponse as Fn, UpdateDomainData as Fr, DeliverySummary as Ft, verifyDomain as G, ListFiltersErrors as Gn, UpdateEndpointResponse as Gr, DownloadRawEmailErrors as Gt, updateDomain as H, ListEnvelope as Hn, UpdateEndpointError as Hr, DownloadAttachmentsResponses as Ht, replayDelivery as I, ListEmailsResponses as In, UpdateDomainError as Ir, Domain as It, AddDomainData as J, PaginationMeta as Jn, UpdateFilterError as Jr, EmailDetail as Jt, Account as K, ListFiltersResponse as Kn, UpdateEndpointResponses as Kr, DownloadRawEmailResponse as Kt, replayEmailWebhooks as L, ListEndpointsData as Ln, UpdateDomainErrors as Lr, DomainVerifyResult as Lt, listDomains as M, ListEmailsData as Mn, UpdateAccountInput as Mr, DeleteFilterResponse as Mt, listEmails as N, ListEmailsError as Nn, UpdateAccountResponse as Nr, DeleteFilterResponses as Nt, getEmail as O, ListDomainsError as On, UnverifiedDomain as Or, DeleteEndpointResponses as Ot, listEndpoints as P, ListEmailsErrors as Pn, UpdateAccountResponses as Pr, DeliveryStatus as Pt, AddDomainResponse as Q, ReplayDeliveryResponse as Qn, UpdateFilterResponses as Qr, Filter as Qt, rotateWebhookSecret as R, ListEndpointsError as Rn, UpdateDomainInput as Rr, DownloadAttachmentsData as Rt, deleteEmail as S, ListDeliveriesData as Sn, TestEndpointData as Sr, DeleteEmailResponse as St, downloadAttachments as T, ListDeliveriesResponse as Tn, TestEndpointResponse as Tr, DeleteEndpointError as Tt, updateEndpoint as U, ListFiltersData as Un, UpdateEndpointErrors as Ur, DownloadRawEmailData as Ut, updateAccount as V, ListEndpointsResponses as Vn, UpdateEndpointData as Vr, DownloadAttachmentsResponse as Vt, updateFilter as W, ListFiltersError as Wn, UpdateEndpointInput as Wr, DownloadRawEmailError as Wt, AddDomainErrors as X, ReplayDeliveryError as Xn, UpdateFilterInput as Xr, Endpoint as Xt, AddDomainError as Y, ReplayDeliveryData as Yn, UpdateFilterErrors as Yr, EmailSummary as Yt, AddDomainInput as Z, ReplayDeliveryErrors as Zn, UpdateFilterResponse as Zr, ErrorResponse as Zt, Options as _, GetWebhookSecretError as _n, SendMailInput as _r, DeleteDomainResponse as _t, PrimitiveApiError as a, WebhookSecret as ai, GetAccountResponses as an, ReplayResult as ar, CreateEndpointResponse as at, createFilter as b, GetWebhookSecretResponses as bn, StorageStats as br, DeleteEmailError as bt, PrimitiveClientOptions as c, Config as ci, GetEmailErrors as cn, RotateWebhookSecretError as cr, CreateFilterError as ct, SendResult as d, RequestOptions as di, GetStorageStatsData as dn, RotateWebhookSecretResponses as dr, CreateFilterResponse as dt, VerifyDomainData as ei, GateFix as en, ReplayEmailWebhooksData as er, ClientOptions as et, SendThreadInput as f, RequestResult as fi, GetStorageStatsError as fn, SendEmailData as fr, CreateFilterResponses as ft, operations as g, GetWebhookSecretData as gn, SendEmailResponses as gr, DeleteDomainErrors as gt, createPrimitiveClient as h, GetStorageStatsResponses as hn, SendEmailResponse as hr, DeleteDomainError as ht, PrimitiveApiClientOptions as i, VerifyDomainResponses as ii, GetAccountResponse as in, ReplayEmailWebhooksResponses as ir, CreateEndpointInput as it, listDeliveries as j, ListDomainsResponses as jn, UpdateAccountErrors as jr, DeleteFilterErrors as jt, getStorageStats as k, ListDomainsErrors as kn, UpdateAccountData as kr, DeleteFilterData as kt, ReplyInput as l, CreateClientConfig as li, GetEmailResponse as ln, RotateWebhookSecretErrors as lr, CreateFilterErrors as lt, createPrimitiveApiClient as m, Auth as mi, GetStorageStatsResponse as mn, SendEmailErrors as mr, DeleteDomainData as mt, ForwardInput as n, VerifyDomainErrors as ni, GetAccountError as nn, ReplayEmailWebhooksErrors as nr, CreateEndpointError as nt, PrimitiveApiErrorDetails as o, Client as oi, GetEmailData as on, ResourceId as or, CreateEndpointResponses as ot, client as p, ResponseStyle as pi, GetStorageStatsErrors as pn, SendEmailError as pr, Cursor as pt, AccountUpdated as q, ListFiltersResponses as qn, UpdateFilterData as qr, DownloadRawEmailResponses as qt, PrimitiveApiClient as r, VerifyDomainResponse as ri, GetAccountErrors as rn, ReplayEmailWebhooksResponse as rr, CreateEndpointErrors as rt, PrimitiveClient as s, ClientOptions$1 as si, GetEmailError as sn, RotateWebhookSecretData as sr, CreateFilterData as st, DEFAULT_BASE_URL as t, VerifyDomainError as ti, GetAccountData as tn, ReplayEmailWebhooksError as tr, CreateEndpointData as tt, SendInput as u, Options$1 as ui, GetEmailResponses as un, RotateWebhookSecretResponse as ur, CreateFilterInput as ut, addDomain as v, GetWebhookSecretErrors as vn, SendMailResult as vr, DeleteDomainResponses as vt, deleteFilter as w, ListDeliveriesErrors as wn, TestEndpointErrors as wr, DeleteEndpointData as wt, deleteDomain as x, Limit as xn, SuccessEnvelope as xr, DeleteEmailErrors as xt, createEndpoint as y, GetWebhookSecretResponse as yn, SentEmailStatus as yr, DeleteEmailData as yt, sendEmail as z, ListEndpointsErrors as zn, UpdateDomainResponse as zr, DownloadAttachmentsError as zt };