@sendora/sdk 1.1.0

package/dist/types.d.ts

@@ -0,0 +1,802 @@
+/** Options every call takes. */
+export interface RequestOptions {
+    /** Cancels the call, retries included. */
+    signal?: AbortSignal | undefined;
+}
+/** Options a send takes. */
+export interface SendOptions extends RequestOptions {
+    /**
+     * Any text of 1 to 255 printable characters that identifies this request.
+     * The SDK makes a random UUID when you give none, so a retry never sends
+     * twice; give your own to make retries across processes safe too. The
+     * API remembers a key for 24 hours and refuses it with a different body.
+     */
+    idempotencyKey?: string | undefined;
+}
+/** An address as a plain string, or an object with the address and a display name of up to 200 characters. */
+export type Address = string | {
+    email: string;
+    name?: string | null | undefined;
+};
+/** An attachment as you hand it to the SDK: the bytes, or base64 without line breaks as the API takes it. */
+export interface Attachment {
+    /** A file name without path separators, at most 255 characters. */
+    name: string;
+    /** The bytes, or base64 without line breaks. */
+    content: Uint8Array | string;
+    /** A media type such as application/pdf, without parameters; application/octet-stream when left out. */
+    contentType?: string | undefined;
+    /** Lets the HTML part refer to the attachment as cid:<contentId>. */
+    contentId?: string | null | undefined;
+}
+/** An attachment on the wire: the content base64-encoded. */
+export interface EncodedAttachment {
+    name: string;
+    content: string;
+    contentType?: string | undefined;
+    contentId?: string | null | undefined;
+}
+/** The fields of a message apart from its parts. */
+export interface SendEmailFields {
+    /** The sender. Its domain must be a verified sending domain of the account. */
+    from: Address;
+    /** The stream of this server the message goes on; the default transactional stream when absent. */
+    streamId?: string | undefined;
+    /** Recipients; at most 50 across to, cc and bcc. */
+    to: Address[];
+    /** Copied recipients, shown in the message. */
+    cc?: Address[] | undefined;
+    /** Blind-copied recipients. */
+    bcc?: Address[] | undefined;
+    /** The subject line, 1 to 998 characters. */
+    subject: string;
+    /** Custom headers by name. Headers Sendora sets itself, such as From and DKIM-Signature, are refused. */
+    headers?: Record<string, string> | undefined;
+    /** At most 20. The built message, attachments encoded, may not exceed 10 MB. */
+    attachments?: Attachment[] | undefined;
+    /** A label of up to 100 characters, returned with the message and its events. */
+    tag?: string | null | undefined;
+    /** Up to 20 key-value pairs of your own, returned with the message and its events. */
+    metadata?: Record<string, string> | undefined;
+}
+/** What `email.send` takes: the fields and at least one of `text` and `html`. */
+export type SendEmailRequest = SendEmailFields & ({
+    text: string;
+    html?: string | undefined;
+} | {
+    html: string;
+    text?: string | undefined;
+});
+/** The body POST /v1/email takes; equal to the API's own schema. */
+export interface SendEmailBody {
+    from: Address;
+    streamId?: string | undefined;
+    to: Address[];
+    cc?: Address[] | undefined;
+    bcc?: Address[] | undefined;
+    subject: string;
+    text?: string | undefined;
+    html?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    attachments?: EncodedAttachment[] | undefined;
+    tag?: string | null | undefined;
+    metadata?: Record<string, string> | undefined;
+}
+/** A message accepted for delivery. Delivery, deferral, bounce and complaint arrive later as events and webhooks. */
+export interface AcceptedEmail {
+    /** The id the message log, the events and the webhooks refer to. */
+    messageId: string;
+    status: 'accepted';
+    /** When the message was accepted. */
+    submittedAt: string;
+}
+/** One invalid field of a request. */
+export interface ValidationIssue {
+    /** The field, dotted, such as to.0.email; empty when the whole body is wrong. */
+    path: string;
+    message: string;
+}
+export type SuppressionReason = 'hard_bounce' | 'spam_complaint' | 'manual' | 'unsubscribe';
+/** A recipient the server refused because it is on the suppression list. */
+export interface SuppressedRecipient {
+    address: string;
+    reason: SuppressionReason;
+}
+/** Whose limit or cap it is. */
+export type LimitScope = 'tenant' | 'server';
+/** One result of a batch, in request order: accepted with its id, or refused with the error a single send would give. */
+export type BatchItemResult = {
+    messageId: string;
+    status: 'accepted';
+    submittedAt: string;
+    /** The position of the message in the request. */
+    index: number;
+    /** True when an earlier request under the same key already sent this item. */
+    replayed: boolean;
+} | {
+    index: number;
+    status: 'error';
+    error: 'invalid_request';
+    message: string;
+    issues: ValidationIssue[];
+} | {
+    error: 'from_domain_not_verified';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'stream_not_found';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'stream_archived';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'stream_paused';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'stream_not_sendable';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'broadcast_not_enabled';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'unsubscribe_placeholder_missing';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'list_unsubscribe_reserved';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'recipient_suppressed';
+    message: string;
+    streamId: string;
+    suppressed: SuppressedRecipient[];
+    index: number;
+    status: 'error';
+} | {
+    error: 'idempotency_key_mismatch';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'rate_limited';
+    message: string;
+    scope: LimitScope;
+    limit: number;
+    retryAfter: number;
+    index: number;
+    status: 'error';
+} | {
+    error: 'monthly_cap_reached';
+    message: string;
+    scope: LimitScope;
+    cap: number;
+    used: number;
+    resetsAt: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'sending_disabled';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'tenant_paused';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'tenant_not_active';
+    message: string;
+    index: number;
+    status: 'error';
+} | {
+    error: 'payment_required';
+    message: string;
+    index: number;
+    status: 'error';
+};
+/** Every message of a batch answered on its own; the batch as a whole never fails halfway. */
+export interface BatchResult {
+    results: BatchItemResult[];
+}
+/** accepted until handed to the mail server, injected after; failed if that never worked. */
+export type MessageStatus = 'accepted' | 'injected' | 'failed';
+/** queued until the receiver answers; deferred while it keeps saying try later. */
+export type RecipientStatus = 'queued' | 'delivered' | 'deferred' | 'bounced' | 'expired';
+export type RecipientKind = 'to' | 'cc' | 'bcc';
+export interface MessageRecipient {
+    address: string;
+    kind: RecipientKind;
+    status: RecipientStatus;
+}
+/** A message as the log lists it. */
+export interface Message {
+    messageId: string;
+    /** The stream the message went on. */
+    streamId: string;
+    /** The broadcast the message belongs to; null for a message sent on its own. */
+    broadcastId: string | null;
+    status: MessageStatus;
+    from: string;
+    subject: string;
+    tag: string | null;
+    metadata: Record<string, string>;
+    submittedAt: string;
+    recipients: MessageRecipient[];
+}
+/** Reception when the mail server took it, Delivery, TransientFailure, Bounce, OOB for a bounce report received by mail, Feedback for a spam complaint. */
+export type MessageEventType = 'Reception' | 'Delivery' | 'Bounce' | 'TransientFailure' | 'Expiration' | 'AdminBounce' | 'OOB' | 'Feedback' | 'AdminRebind' | 'DeferredInjectionRebind' | 'Rejection' | 'Delayed';
+/** One step of a message's timeline. */
+export interface MessageEvent {
+    /** The recipient the event is about; null when it concerns the message as a whole. */
+    recipient: string | null;
+    type: MessageEventType;
+    at: string;
+    /** The SMTP status code the receiver answered. */
+    code: number | null;
+    /** The receiver's response text. */
+    details: string | null;
+    /** How a bounce was classified, such as InvalidRecipient. */
+    classification: string | null;
+}
+/** An attachment as the log describes it; the content is never returned. */
+export interface MessageAttachment {
+    name: string;
+    contentType: string;
+    contentId: string | null;
+    /** Bytes before encoding. */
+    size: number;
+}
+/** The message with its attachments described and its timeline, oldest event first. */
+export interface MessageDetail extends Message {
+    attachments: MessageAttachment[];
+    events: MessageEvent[];
+}
+/** The body POST /v1/messages/search takes; equal to the API's own schema. Every filter is optional. */
+export interface MessageSearchBody {
+    /** Messages to this address, in to, cc or bcc. */
+    recipient?: string | undefined;
+    /** Messages on this stream of the server. */
+    streamId?: string | undefined;
+    /** Messages of this broadcast. */
+    broadcastId?: string | undefined;
+    tag?: string | undefined;
+    /** Messages with at least one recipient in this state. */
+    status?: RecipientStatus | undefined;
+    /** Submitted at or after this time, ISO 8601. */
+    from?: string | undefined;
+    /** Submitted before this time, ISO 8601. */
+    to?: string | undefined;
+    /** Page size, 1 to 100; 50 when left out. */
+    limit?: number | undefined;
+    /** The `next` value of the previous page. */
+    after?: string | undefined;
+}
+/** What `messages.search` takes: the same filters, with times as Date or ISO 8601 string. */
+export interface MessageSearch {
+    /** Messages to this address, in to, cc or bcc. */
+    recipient?: string | undefined;
+    /** Messages on this stream of the server. */
+    streamId?: string | undefined;
+    /** Messages of this broadcast. */
+    broadcastId?: string | undefined;
+    tag?: string | undefined;
+    /** Messages with at least one recipient in this state. */
+    status?: RecipientStatus | undefined;
+    /** Submitted at or after this time. */
+    from?: Date | string | undefined;
+    /** Submitted before this time. */
+    to?: Date | string | undefined;
+    /** Page size, 1 to 100; 50 when left out. */
+    limit?: number | undefined;
+    /** The `next` value of the previous page. */
+    after?: string | undefined;
+}
+/** One page of the message log, newest first. */
+export interface MessagePage {
+    messages: Message[];
+    /** Pass as `after` for the next page; null on the last. */
+    next: string | null;
+}
+/** Cursor paging for the lists that page. */
+export interface PageQuery {
+    /** Page size, 1 to 1000; 100 when left out. */
+    limit?: number | undefined;
+    /** The `next` value of the previous page. */
+    after?: string | undefined;
+}
+/** The paging of a suppression list, and which stream's list. */
+export interface SuppressionQuery extends PageQuery {
+    /** The stream whose list is meant; the default transactional stream when left out. */
+    streamId?: string | undefined;
+}
+/** An address a stream of the server no longer sends to. */
+export interface Suppression {
+    /** The stream whose list the address is on. */
+    streamId: string;
+    /** The recipient, lower-cased. */
+    address: string;
+    /** A hard bounce or a manual entry may be lifted; a spam complaint only by Sendora support. */
+    reason: SuppressionReason;
+    /** The message whose bounce or complaint put it here. */
+    messageId: string | null;
+    createdAt: string;
+}
+/** One page of the suppression list, oldest first. */
+export interface SuppressionPage {
+    suppressions: Suppression[];
+    next: string | null;
+}
+/** The body POST /v1/suppressions/delete takes. */
+export interface DeleteSuppressionRequest {
+    /** The address to send to again. */
+    address: string;
+    /** The stream whose list holds it; the default transactional stream when left out. */
+    streamId?: string | undefined;
+}
+/** transactional for mail the recipient expects; broadcast for mail to many, once enabled for the account; inbound for mail the server receives. */
+export type StreamKind = 'transactional' | 'broadcast' | 'inbound';
+/** A stream of the server: what a send names as `streamId`; a sending stream has a suppression list of its own, an inbound one an address. */
+export interface Stream {
+    streamId: string;
+    kind: StreamKind;
+    /** The name given at creation, unique within the server. */
+    name: string;
+    /** The stream a send without a `streamId` goes on; one per server, transactional. */
+    isDefault: boolean;
+    createdAt: string;
+    /** Set once archived; the stream then takes no new messages. */
+    archivedAt: string | null;
+    /** Set while Sendora has paused the stream after complaints; it takes no messages until support has resumed it. */
+    pausedAt: string | null;
+    /** The address of an inbound stream, its id on inbound.sendora.se; null on every other kind. */
+    inboundAddress: string | null;
+    /** How many days an inbound stream keeps received content, 1 to 30; null means the default of 30, and null on every other kind. */
+    contentRetentionDays: number | null;
+}
+/** The body POST /v1/streams takes. */
+export interface CreateStreamRequest {
+    /** broadcast needs broadcast enabled for the account by Sendora; a server has one live inbound stream. */
+    kind: StreamKind;
+    /** 1 to 100 characters. */
+    name: string;
+}
+/** The body PATCH /v1/streams/{id} takes: a name, a content window for an inbound stream, or both. */
+export interface UpdateStreamRequest {
+    /** 1 to 100 characters. */
+    name?: string | undefined;
+    /** Days an inbound stream keeps received content, 1 to 30; null for the default of 30. */
+    contentRetentionDays?: number | null | undefined;
+}
+export interface StreamList {
+    streams: Stream[];
+}
+/** accepted until the first message leaves, processing while messages are leaving, completed when every message has left or failed, cancelled once cancelled. */
+export type BroadcastStatus = 'accepted' | 'processing' | 'completed' | 'cancelled';
+/** One message of a broadcast: its recipients, and what is its own beside the shared content. */
+export interface BroadcastMessageEntry {
+    /** Recipients of this message; at most 50 across to, cc and bcc. */
+    to: Address[];
+    /** Copied recipients, shown in the message. */
+    cc?: Address[] | undefined;
+    /** Blind-copied recipients. */
+    bcc?: Address[] | undefined;
+    /** Up to 20 key-value pairs for this message, merged over the broadcast's. */
+    metadata?: Record<string, string> | undefined;
+    /** Custom headers for this message, merged over the broadcast's. */
+    headers?: Record<string, string> | undefined;
+    /** Up to 20 strings that replace `{{ key }}` in the subject, the text and the HTML of this message; a key the content names must be given. */
+    substitutions?: Record<string, string> | undefined;
+}
+/** The fields of a broadcast apart from its parts. */
+export interface SendBroadcastFields {
+    /** The broadcast stream of this server the messages go on. */
+    streamId: string;
+    /** The sender. Its domain must be a verified sending domain of the account. */
+    from: Address;
+    /** The subject line, 1 to 998 characters. */
+    subject: string;
+    /** Custom headers on every message. Headers Sendora sets itself, the List-Unsubscribe pair included, are refused. */
+    headers?: Record<string, string> | undefined;
+    /** At most 20, sent with every message; the whole broadcast may not exceed 50 MB once built. */
+    attachments?: Attachment[] | undefined;
+    /** A label of up to 100 characters, on the broadcast and on every message. */
+    tag?: string | null | undefined;
+    /** Up to 20 key-value pairs of your own, on the broadcast and on every message. */
+    metadata?: Record<string, string> | undefined;
+    /** One entry per message, at most 50,000; a larger list is several broadcasts under one tag. */
+    messages: BroadcastMessageEntry[];
+}
+/** What `broadcasts.send` takes: the fields and at least one of `text` and `html`, each with `{{ unsubscribe_url }}` where the link goes. */
+export type SendBroadcastRequest = SendBroadcastFields & ({
+    text: string;
+    html?: string | undefined;
+} | {
+    html: string;
+    text?: string | undefined;
+});
+/** The body POST /v1/broadcasts takes; equal to the API's own schema. */
+export interface SendBroadcastBody {
+    streamId: string;
+    from: Address;
+    subject: string;
+    text?: string | undefined;
+    html?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    attachments?: EncodedAttachment[] | undefined;
+    tag?: string | null | undefined;
+    metadata?: Record<string, string> | undefined;
+    messages: BroadcastMessageEntry[];
+}
+/** The broadcast was stored; the worker sends its messages from here. */
+export interface AcceptedBroadcast {
+    /** The id the messages, the progress and the cancel refer to. */
+    broadcastId: string;
+    status: 'accepted';
+    /** Messages stored; each is a message in the log. */
+    total: number;
+    /** Addresses dropped for standing on the stream's suppression list. */
+    suppressed: number;
+    submittedAt: string;
+}
+/** A broadcast and how far it has come. */
+export interface Broadcast {
+    broadcastId: string;
+    /** The broadcast stream the messages go on. */
+    streamId: string;
+    status: BroadcastStatus;
+    from: string;
+    subject: string;
+    tag: string | null;
+    metadata: Record<string, string>;
+    /** Messages stored, after suppressed addresses were dropped. */
+    total: number;
+    /** Messages handed to the mail server so far. */
+    released: number;
+    /** Messages that could not be handed over, cancelled ones included. */
+    failed: number;
+    /** Addresses dropped from the list for standing on the stream's suppression list. */
+    suppressed: number;
+    submittedAt: string;
+    /** Set once nothing is left to send, or on cancel. */
+    completedAt: string | null;
+}
+export interface BroadcastPage {
+    broadcasts: Broadcast[];
+    /** Pass as `after` for the next page; null on the last. */
+    next: string | null;
+}
+/** What `broadcasts.list` takes. */
+export type BroadcastList = PageQuery;
+/** The body POST /v1/tokens takes. */
+export interface CreateTokenRequest {
+    /** 1 to 100 characters, for people to tell tokens apart. */
+    name: string;
+}
+/** A token of the server; its value is shown only when it is created. */
+export interface Token {
+    tokenId: string;
+    name: string;
+    /** The first characters of the token, to match it with a value in hand. */
+    prefix: string;
+    createdAt: string;
+    revokedAt: string | null;
+}
+/** A token just created, with its value, shown this once. */
+export interface CreatedToken extends Token {
+    token: string;
+}
+export interface TokenList {
+    tokens: Token[];
+}
+/** The events a webhook can receive. */
+export type WebhookEventName = 'delivered' | 'bounced' | 'deferred' | 'spam_complaint' | 'unsubscribed' | 'cap_warning' | 'cap_reached' | 'inbound';
+/** The body POST /v1/webhooks takes. */
+export interface CreateWebhookRequest {
+    /** An https URL on a public host, without credentials or a fragment. */
+    url: string;
+    /** The events to deliver; every event when left out. */
+    events?: WebhookEventName[] | undefined;
+    /** Limits the message events to one stream of the server; every stream when left out. Cap events arrive either way. */
+    streamId?: string | undefined;
+    /** How the inbound event carries a received message: full sends the parsed message with the event; reference sends ids and sizes only. full when left out. */
+    inboundContent?: InboundContent | undefined;
+}
+/** How the inbound event carries a received message. */
+export type InboundContent = 'full' | 'reference';
+/** A webhook of the server. */
+export interface Webhook {
+    webhookId: string;
+    url: string;
+    events: WebhookEventName[];
+    /** The one stream whose message events it receives; null for every stream. */
+    streamId: string | null;
+    /** False while switched off in the dashboard; nothing is queued for it then. */
+    enabled: boolean;
+    /** How the inbound event carries a received message: the parsed message, or a reference. */
+    inboundContent: InboundContent;
+    createdAt: string;
+}
+/** A webhook just created, with its signing secret, shown this once. */
+export interface CreatedWebhook extends Webhook {
+    secret: string;
+}
+export interface WebhookList {
+    webhooks: Webhook[];
+}
+/** pending is waiting for its next attempt; dead gave up and can be replayed. */
+export type DeliveryStatus = 'pending' | 'delivered' | 'dead';
+export interface DeliveryQuery extends PageQuery {
+    status?: DeliveryStatus | undefined;
+}
+/** One event on its way to a webhook, retried with backoff until delivered or dead. */
+export interface Delivery {
+    deliveryId: string;
+    event: WebhookEventName;
+    /** Null for an event about usage rather than a message. */
+    messageId: string | null;
+    status: DeliveryStatus;
+    attempts: number;
+    /** When the next attempt is due, while pending. */
+    nextAttemptAt: string | null;
+    /** The HTTP status the endpoint last answered. */
+    lastStatusCode: number | null;
+    /** Why the last attempt failed, when it did. */
+    lastError: string | null;
+    deliveredAt: string | null;
+    createdAt: string;
+}
+/** One page of a webhook's deliveries, newest first. */
+export interface DeliveryPage {
+    deliveries: Delivery[];
+    next: string | null;
+}
+/** Options `webhooks.receive` takes. */
+export interface ReceiveOptions {
+    /** How old a signature may be, in seconds; five minutes by default. */
+    toleranceSeconds?: number | undefined;
+}
+/** The body POST /v1/domains takes. */
+export interface CreateDomainRequest {
+    /** The domain mail is sent from, such as example.se. */
+    domain: string;
+}
+/** A DNS record the domain needs and whether it has been seen. */
+export interface DnsRecord<Type extends 'CNAME' | 'TXT'> {
+    type: Type;
+    /** The name to create the record under. */
+    host: string;
+    /** The value the record must hold. */
+    value: string;
+    verified: boolean;
+    verifiedAt: string | null;
+}
+/** A sending domain and the two records it needs. */
+export interface SendingDomain {
+    domainId: string;
+    domain: string;
+    /** True once both records have been seen; only then may mail go out. */
+    verified: boolean;
+    createdAt: string;
+    /** When the records were last looked up. */
+    lastCheckedAt: string | null;
+    /** The return-path record, which also satisfies SPF. */
+    returnPath: DnsRecord<'CNAME'>;
+    /** The DKIM public key record. */
+    dkim: DnsRecord<'TXT'>;
+}
+/** dns_error is a resolver failure, such as a DNSSEC problem or a timeout, not an absent record. */
+export type RecordCheck = 'ok' | 'missing' | 'mismatch' | 'dns_error';
+/** The domain as it stands after a check, and what each lookup found. */
+export interface VerifiedDomain extends SendingDomain {
+    check: {
+        returnPath: RecordCheck;
+        dkim: RecordCheck;
+    };
+}
+export interface DomainList {
+    domains: SendingDomain[];
+}
+/** What every event about a message carries. */
+export interface MessageEventFields {
+    /** The delivery id. Deliveries arrive at least once, so key your handling on it. */
+    id: string;
+    /** The attempt number, from 1. */
+    attempt: number;
+    messageId: string;
+    /** The recipient the event is about. */
+    recipient: string;
+    occurredAt: string;
+    serverId: string;
+    /** The stream the message went on. */
+    streamId: string;
+    /** The broadcast the message belongs to; null for a message sent on its own. */
+    broadcastId: string | null;
+    /** The tag and metadata you sent with the message. */
+    tag: string | null;
+    metadata: Record<string, string>;
+}
+/** The receiver accepted the message for the recipient. */
+export interface DeliveredEvent extends MessageEventFields {
+    event: 'delivered';
+    details: {
+        /** The SMTP status code the receiver answered. */
+        code: number | null;
+        /** The receiver's response text. */
+        response: string | null;
+    };
+}
+/** The receiver refused the message for good, or Sendora gave up; the recipient is suppressed when `hard`. */
+export interface BouncedEvent extends MessageEventFields {
+    event: 'bounced';
+    details: {
+        code: number | null;
+        response: string | null;
+        /** How the bounce was classified, such as InvalidRecipient. */
+        classification: string | null;
+        /** True when the address is now on the suppression list. */
+        hard: boolean;
+        /** True when the message expired after repeated deferrals rather than being refused. */
+        expired: boolean;
+    };
+}
+/** The receiver asked Sendora to try later; several may follow. */
+export interface DeferredEvent extends MessageEventFields {
+    event: 'deferred';
+    details: {
+        code: number | null;
+        response: string | null;
+    };
+}
+/** The recipient reported the message as spam; only Sendora support lifts that suppression. */
+export interface SpamComplaintEvent extends MessageEventFields {
+    event: 'spam_complaint';
+    details: {
+        /** The feedback type the receiver reported, such as abuse. */
+        feedbackType: string | null;
+    };
+}
+/** The recipient unsubscribed through the link or their mail client's one-click button; only Sendora support lifts that suppression. */
+export interface UnsubscribedEvent extends MessageEventFields {
+    event: 'unsubscribed';
+    details: {
+        /** `link` for the page's button, `one_click` for a mail client's request. */
+        source: 'link' | 'one_click';
+    };
+}
+/** What both usage events carry. */
+export interface CapEventFields {
+    id: string;
+    attempt: number;
+    /** Whose cap it is. */
+    scope: LimitScope;
+    /** The server whose cap it is, or null when the account's cap is meant. */
+    serverId: string | null;
+    cap: number;
+    used: number;
+    periodStart: string;
+    periodEnd: string;
+    occurredAt: string;
+}
+/** 80 percent of the monthly cap is used. */
+export interface CapWarningEvent extends CapEventFields {
+    event: 'cap_warning';
+}
+/** A send was refused because the monthly cap is used up. */
+export interface CapReachedEvent extends CapEventFields {
+    event: 'cap_reached';
+}
+export type SpfVerdict = 'pass' | 'fail' | 'softfail' | 'neutral' | 'none' | 'temperror' | 'permerror' | 'unchecked';
+export type AuthVerdict = 'pass' | 'fail' | 'none' | 'temperror' | 'permerror' | 'unchecked';
+export type DmarcPolicy = 'none' | 'quarantine' | 'reject';
+export type ArcVerdict = 'none' | 'pass' | 'fail' | 'unchecked';
+/** What Sendora found when it checked a received message's authentication; `unchecked` until the checks have run. */
+export interface InboundAuthentication {
+    /** SPF for the address in MAIL FROM. */
+    spf: SpfVerdict;
+    /** SPF for the name the sending server gave in HELO. */
+    spfHelo: SpfVerdict;
+    dkim: AuthVerdict;
+    dmarc: AuthVerdict;
+    /** What the sender's domain asks for; told only when DMARC failed. */
+    dmarcPolicy: DmarcPolicy | null;
+    arc: ArcVerdict;
+    /** When the checks ran; null until they have. */
+    checkedAt: string | null;
+}
+export interface InboundAddress {
+    address: string;
+    name: string | null;
+}
+export interface InboundHeader {
+    name: string;
+    value: string;
+}
+/** An attachment of a received message, without its bytes. */
+export interface InboundAttachment {
+    /** Its place among the message's attachments, from 0. */
+    position: number;
+    name: string;
+    contentType: string;
+    /** The Content-ID an HTML body refers to with `cid:`, when it has one. */
+    contentId: string | null;
+    size: number;
+    /** True for a part shown in the body rather than offered as a file. */
+    inline: boolean;
+}
+/** What every inbound event carries: the reference to the received message. */
+export interface InboundEventFields {
+    id: string;
+    attempt: number;
+    event: 'inbound';
+    inboundMessageId: string;
+    serverId: string;
+    /** The inbound stream that received it. */
+    streamId: string;
+    /** When the message was accepted from the sending server. */
+    receivedAt: string;
+    /** The address of yours the message was sent to. */
+    envelopeRecipient: string;
+    /** The text after `+` in the local part of that address, when the sender used one. */
+    mailboxHash: string | null;
+    sizeBytes: number;
+    attachmentCount: number;
+    hasText: boolean;
+    hasHtml: boolean;
+    authentication: InboundAuthentication;
+    /** What the parser met, from a closed set; null when the message parsed clean. */
+    parseIssue: string | null;
+}
+/** The message itself, added for a webhook with `inboundContent: 'full'`. */
+export interface InboundEventContent {
+    /** The envelope sender; null for a bounce, or once the content window has passed. */
+    envelope: {
+        sender: string | null;
+    } | null;
+    from: InboundAddress | null;
+    replyTo: InboundAddress[];
+    /** Up to 100 entries; `toCount` is the whole number. */
+    to: InboundAddress[];
+    toCount: number;
+    cc: InboundAddress[];
+    ccCount: number;
+    subject: string | null;
+    /** The sender's Date header as ISO 8601, when it was a real moment. */
+    date: string | null;
+    messageIdHeader: string | null;
+    inReplyTo: string | null;
+    references: string[];
+    headers: InboundHeader[];
+    /** The plain-text body; null when there is none, or over 1 MiB. */
+    text: string | null;
+    /** The HTML body; null when there is none, or over 2 MiB. */
+    html: string | null;
+    attachments: InboundAttachment[];
+    /** `too_large` when text or HTML was left out for size; `expired` when the content window has passed and the reference is all that remains. */
+    contentOmitted: 'too_large' | 'expired' | null;
+}
+/**
+ * A message received on an inbound stream. The content fields are present
+ * for a webhook with `inboundContent: 'full'` and absent for
+ * `reference`; `'contentOmitted' in event` tells them apart.
+ */
+export type InboundEvent = InboundEventFields & (InboundEventContent | {
+    contentOmitted?: undefined;
+});
+/** What a webhook request carries, once verified; narrow on `event`. */
+export type WebhookEvent = DeliveredEvent | BouncedEvent | DeferredEvent | SpamComplaintEvent | UnsubscribedEvent | CapWarningEvent | CapReachedEvent | InboundEvent;
+//# sourceMappingURL=types.d.ts.map