@openemail/sdk 0.0.1 → 0.0.3

package/index.d.ts

@@ -19,6 +19,376 @@ type AddressBookResource = {
     domains: Array<SendableDomainResource>;
 };
 
+type AddressBookPage = AddressBookResource & {
+    hasMore: boolean;
+    nextCursor: string | null;
+};
+
+type AudienceBatchAddResource = {
+    object: 'audience_batch';
+    audienceId: string;
+    added: number;
+    unchanged: number;
+    missing: Array<string>;
+};
+
+type AudienceBatchRemoveResource = {
+    object: 'audience_batch';
+    audienceId: string;
+    removed: number;
+    notInAudience: Array<string>;
+    missing: Array<string>;
+};
+
+declare const AUDIENCE_BUILTINS: {
+    readonly DEFAULT: "default";
+};
+declare const AUDIENCE_MEMBER_SORTS: {
+    readonly LAST_HEARD_NEWEST: "last-heard-newest";
+    readonly LAST_HEARD_OLDEST: "last-heard-oldest";
+    readonly ADDED_NEWEST: "added-newest";
+    readonly ADDED_OLDEST: "added-oldest";
+    readonly NAME: "name";
+};
+
+type AudienceBuiltin = (typeof AUDIENCE_BUILTINS)[keyof typeof AUDIENCE_BUILTINS];
+
+type AudienceContactAdd = {
+    email: string;
+};
+
+type AudienceMemberSort = (typeof AUDIENCE_MEMBER_SORTS)[keyof typeof AUDIENCE_MEMBER_SORTS];
+
+declare const CONTACT_SOURCES: {
+    readonly MANUAL: "manual";
+    readonly AUTO: "auto";
+};
+declare const PEOPLE_SORTS: {
+    readonly RECENT: "recent";
+    readonly NAME: "name";
+    readonly THREADS: "threads";
+};
+declare const CONTACT_THREAD_SORTS: {
+    readonly NEWEST: "newest";
+    readonly OLDEST: "oldest";
+    readonly SENDER: "sender";
+    readonly SUBJECT: "subject";
+};
+declare const CONTACT_BLOCK_LISTS: {
+    readonly BLOCKED_SENDERS: "blockedSenders";
+    readonly BLOCKED_DOMAINS: "blockedDomains";
+};
+declare const CONTACT_PHOTO_TYPES: {
+    readonly PNG: "image/png";
+    readonly JPEG: "image/jpeg";
+    readonly WEBP: "image/webp";
+    readonly GIF: "image/gif";
+};
+
+type ContactSource = (typeof CONTACT_SOURCES)[keyof typeof CONTACT_SOURCES];
+
+type RequestScope = {
+    signal?: AbortSignal;
+    apiKey?: string;
+};
+
+type ListOptions = RequestScope & {
+    limit?: number;
+    cursor?: string;
+};
+
+type AudienceContactListOptions = ListOptions & {
+    q?: string;
+    source?: ContactSource;
+    sort?: AudienceMemberSort;
+};
+
+type ContactResource = {
+    object: 'contact';
+    email: string;
+    name: string | null;
+    source: ContactSource | (string & {});
+    notes: string | null;
+    photoUrl: string | null;
+    lastSeenAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type AudienceContactResource = ContactResource & {
+    addedAt: string;
+    unsubscribedAt: string | null;
+};
+
+type AudienceContactsBatch = {
+    emails: Array<string>;
+};
+
+type AudienceCreate = {
+    name: string;
+    description?: string | null;
+};
+
+type AudienceGrowthBucket = {
+    bucket: string;
+    added: number;
+    unsubscribed: number;
+};
+
+declare const HIT_KINDS: {
+    readonly HUMAN: "human";
+    readonly PROXY: "proxy";
+    readonly MACHINE: "machine";
+};
+declare const TRACKING_GRAINS: {
+    readonly MINUTE: "minute";
+    readonly HOUR: "hour";
+    readonly DAY: "day";
+};
+
+type TrackingGrain = (typeof TRACKING_GRAINS)[keyof typeof TRACKING_GRAINS];
+
+type AudienceGrowthOptions = RequestScope & {
+    audienceIds?: Array<string>;
+    days?: number;
+    minutes?: number;
+    grain?: TrackingGrain;
+    offsetMinutes?: number;
+};
+
+type AudienceGrowthSeries = {
+    id: string;
+    name: string;
+    builtin: boolean;
+    total: number;
+    subscribed: number;
+    before: number;
+    added: number;
+    unsubscribed: number;
+    buckets: Array<AudienceGrowthBucket>;
+};
+
+type AudienceGrowthTotals = {
+    contacts: number;
+    subscribed: number;
+    memberships: number;
+    added: number;
+    unsubscribed: number;
+    lists: number;
+    busiest: string | null;
+};
+
+type AudienceGrowthResource = {
+    object: 'audience_growth';
+    since: string;
+    until: string;
+    grain: TrackingGrain;
+    offsetMinutes: number;
+    totals: AudienceGrowthTotals;
+    series: Array<AudienceGrowthSeries>;
+};
+
+type AudienceImportRow = {
+    email: string;
+    name?: string | null;
+};
+
+type AudienceImport = {
+    contacts: Array<AudienceImportRow>;
+};
+
+type AudienceImportResource = {
+    object: 'audience_import';
+    audienceId: string;
+    created: number;
+    added: number;
+    skipped: number;
+    invalid: Array<string>;
+};
+
+type AudienceListOptions = ListOptions;
+
+type AudienceMemberResource = {
+    object: 'audience_member';
+    audienceId: string;
+    addedAt: string;
+    contact: ContactResource;
+};
+
+type AudiencePatch = {
+    name?: string;
+    description?: string | null;
+};
+
+type AudienceResource = {
+    object: 'audience';
+    id: string;
+    name: string;
+    description: string | null;
+    builtin: AudienceBuiltin | (string & {}) | null;
+    contactCount: number;
+    lastContactAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type DeletedAudienceResource = {
+    object: 'audience';
+    id: string;
+    deleted: true;
+};
+
+type EmptiedAudienceResource = AudienceResource & {
+    removed: number;
+};
+
+type RemovedAudienceContactResource = {
+    object: 'audience_member';
+    audienceId: string;
+    email: string;
+    deleted: true;
+};
+
+type BroadcastCounts = {
+    recipients: number;
+    created: number;
+    skipped: number;
+    failedToQueue: number;
+    queued: number;
+    sending: number;
+    sent: number;
+    failed: number;
+    cancelled: number;
+};
+
+type RecipientInput = string | {
+    email: string;
+    name?: string;
+};
+
+type TrackingRequest = {
+    opens?: boolean;
+    clicks?: boolean;
+};
+
+type BroadcastCreate = {
+    audienceIds: Array<string>;
+    from: RecipientInput;
+    replyTo?: RecipientInput;
+    subject?: string;
+    html?: string;
+    text?: string;
+    template?: {
+        id: string;
+        version?: number;
+        props?: Record<string, unknown>;
+        slots?: Record<string, unknown>;
+    };
+    tracking?: TrackingRequest;
+    tags?: Record<string, string>;
+    scheduledAt?: Date | string;
+};
+
+type BroadcastListOptions = ListOptions & {
+    audienceId?: string;
+};
+
+type BroadcastPreviewInput = {
+    audienceIds: Array<string>;
+};
+
+type BroadcastPreviewResource = {
+    object: 'broadcast_preview';
+    audienceIds: Array<string>;
+    recipients: number;
+    unsubscribed: number;
+    suppressed: number;
+};
+
+declare const API_KEY_MODES: {
+    readonly LIVE: "live";
+    readonly TEST: "test";
+};
+
+type ApiKeyMode = (typeof API_KEY_MODES)[keyof typeof API_KEY_MODES];
+
+declare const BROADCAST_STATUSES: {
+    readonly SCHEDULED: "scheduled";
+    readonly QUEUED: "queued";
+    readonly SENDING: "sending";
+    readonly SENT: "sent";
+    readonly CANCELLED: "cancelled";
+    readonly FAILED: "failed";
+};
+
+type BroadcastStatus = (typeof BROADCAST_STATUSES)[keyof typeof BROADCAST_STATUSES];
+
+declare const EMAIL_SOURCES: {
+    readonly COMPOSER: "composer";
+    readonly API: "api";
+    readonly MCP: "mcp";
+    readonly AI: "ai";
+};
+declare const EMAIL_STATUSES: {
+    readonly QUEUED: "queued";
+    readonly SCHEDULED: "scheduled";
+    readonly SENDING: "sending";
+    readonly SENT: "sent";
+    readonly PARTIAL: "partial";
+    readonly CANCELLED: "cancelled";
+    readonly FAILED: "failed";
+};
+declare const EMAIL_TRANSPORTS: {
+    readonly SES: "ses";
+    readonly RESEND: "resend";
+    readonly DEV: "dev";
+    readonly TEST: "test";
+};
+declare const RECIPIENT_STATUSES: {
+    readonly PENDING: "pending";
+    readonly SUPPRESSED: "suppressed";
+    readonly DELIVERED: "delivered";
+    readonly FAILED: "failed";
+    readonly BOUNCED: "bounced";
+    readonly COMPLAINED: "complained";
+    readonly UNCERTAIN: "uncertain";
+};
+declare const RECIPIENT_KINDS: {
+    readonly TO: "to";
+    readonly CC: "cc";
+    readonly BCC: "bcc";
+};
+declare const ATTACHMENT_DELIVERY_MODES: {
+    readonly MIME: "mime";
+    readonly LINK: "link";
+    readonly AUTO: "auto";
+};
+
+type EmailSource = (typeof EMAIL_SOURCES)[keyof typeof EMAIL_SOURCES];
+
+type BroadcastResource = {
+    object: 'broadcast';
+    id: string;
+    status: BroadcastStatus;
+    mode: ApiKeyMode;
+    source: EmailSource | (string & {});
+    audienceIds: Array<string>;
+    from: string;
+    subject: string;
+    counts: BroadcastCounts;
+    lastError: string | null;
+    scheduledAt: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    cancelledAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type SentBroadcastResource = BroadcastResource & {
+    replayed: boolean;
+};
+
 type CalendarAttendeeResource = {
     object: 'calendar_attendee';
     email: string;
@@ -83,28 +453,65 @@ type CalendarOccurrenceResource = {
     attendeeCount: number;
 };
 
-type RequestScope = {
-    signal?: AbortSignal;
-    apiKey?: string;
-};
-
-type CalendarRangeOptions = RequestScope & {
+type CalendarRangeOptions = ListOptions & {
     from: Date | string;
     to: Date | string;
     timezone?: string;
 };
 
-type ApiKeyMode = 'live' | 'test';
-
-declare const API_SCOPES: readonly ["emails:send", "emails:read", "drafts:read", "drafts:write", "threads:read", "threads:write", "labels:read", "labels:write", "contacts:read", "calendar:read", "calendar:write", "templates:read", "templates:write", "domains:read", "domains:write", "webhooks:read", "webhooks:write", "rules:read", "rules:write", "connections:read", "members:read", "members:write", "roles:read", "roles:write", "settings:read", "settings:write"];
-
-type ApiScope = (typeof API_SCOPES)[number];
-
-type AttachmentInput = {
+declare const API_SCOPES: {
+    readonly EMAILS_SEND: "emails:send";
+    readonly EMAILS_READ: "emails:read";
+    readonly DRAFTS_READ: "drafts:read";
+    readonly DRAFTS_WRITE: "drafts:write";
+    readonly THREADS_READ: "threads:read";
+    readonly THREADS_WRITE: "threads:write";
+    readonly LABELS_READ: "labels:read";
+    readonly LABELS_WRITE: "labels:write";
+    readonly CONTACTS_READ: "contacts:read";
+    readonly CONTACTS_WRITE: "contacts:write";
+    readonly AUDIENCES_READ: "audiences:read";
+    readonly AUDIENCES_WRITE: "audiences:write";
+    readonly CALENDAR_READ: "calendar:read";
+    readonly CALENDAR_WRITE: "calendar:write";
+    readonly TEMPLATES_READ: "templates:read";
+    readonly TEMPLATES_WRITE: "templates:write";
+    readonly DOMAINS_READ: "domains:read";
+    readonly DOMAINS_WRITE: "domains:write";
+    readonly WEBHOOKS_READ: "webhooks:read";
+    readonly WEBHOOKS_WRITE: "webhooks:write";
+    readonly RULES_READ: "rules:read";
+    readonly RULES_WRITE: "rules:write";
+    readonly CONNECTIONS_READ: "connections:read";
+    readonly MEMBERS_READ: "members:read";
+    readonly MEMBERS_WRITE: "members:write";
+    readonly ROLES_READ: "roles:read";
+    readonly ROLES_WRITE: "roles:write";
+    readonly SETTINGS_READ: "settings:read";
+    readonly SETTINGS_WRITE: "settings:write";
+    readonly KEYS_WRITE: "keys:write";
+    readonly KEYS_READ: "keys:read";
+    readonly KEYS_MANAGE: "keys:manage";
+};
+declare const CONSOLE_PERMISSIONS: {
+    readonly API_KEYS_READ: "api-keys:read";
+    readonly API_KEYS_WRITE: "api-keys:write";
+    readonly BILLING_READ: "billing:read";
+    readonly BILLING_WRITE: "billing:write";
+    readonly WORKSPACE_MANAGE: "workspace:manage";
+};
+
+type ApiScope = (typeof API_SCOPES)[keyof typeof API_SCOPES];
+
+type InlineAttachmentInput = {
     filename: string;
     content: string | Uint8Array | ArrayBuffer;
     contentType?: string;
 };
+type StoredAttachmentInput = {
+    fileId: string;
+};
+type AttachmentInput = InlineAttachmentInput | StoredAttachmentInput;
 
 type AttachmentResource = {
     object: 'attachment';
@@ -115,13 +522,73 @@ type AttachmentResource = {
     content: string | null;
 };
 
-type BuiltinRole = 'owner' | 'admin' | 'member' | 'viewer' | 'developer' | 'billing';
+declare const API_KEY_STATUSES: {
+    readonly ACTIVE: "active";
+    readonly INACTIVE: "inactive";
+    readonly EXPIRED: "expired";
+    readonly REVOKED: "revoked";
+};
+declare const API_KEY_EVENT_TYPES: {
+    readonly CREATED: "created";
+    readonly UPDATED: "updated";
+    readonly ROTATED: "rotated";
+    readonly REVOKED: "revoked";
+    readonly DEACTIVATED: "deactivated";
+    readonly REACTIVATED: "reactivated";
+    readonly AUTH_FAILED: "auth_failed";
+    readonly DELETED: "deleted";
+};
+declare const AUDIT_ACTOR_KINDS: {
+    readonly USER: "user";
+    readonly API_KEY: "apiKey";
+};
+
+type AuditActorKind = (typeof AUDIT_ACTOR_KINDS)[keyof typeof AUDIT_ACTOR_KINDS];
+
+type AuditActorResource = {
+    kind: AuditActorKind;
+    id: string;
+    name: string;
+    username: string | null;
+    label: string;
+};
+
+declare const BUILTIN_ROLES: {
+    readonly OWNER: "owner";
+    readonly ADMIN: "admin";
+    readonly MEMBER: "member";
+    readonly VIEWER: "viewer";
+    readonly DEVELOPER: "developer";
+    readonly BILLING: "billing";
+};
+
+type BuiltinRole = (typeof BUILTIN_ROLES)[keyof typeof BUILTIN_ROLES];
+
+type ConsolePermission = (typeof CONSOLE_PERMISSIONS)[keyof typeof CONSOLE_PERMISSIONS];
+
+type HitKind = (typeof HIT_KINDS)[keyof typeof HIT_KINDS];
+
+type LogWindow = {
+    since?: Date | string;
+    until?: Date | string;
+};
 
-type HitKind = 'human' | 'proxy' | 'machine';
+declare const MESSAGE_ENCRYPTION_FORMATS: {
+    readonly PGP_MIME: "pgp-mime";
+    readonly PGP_SIGNED: "pgp-signed";
+    readonly PGP_INLINE: "pgp-inline";
+    readonly SMIME_ENCRYPTED: "smime-encrypted";
+    readonly SMIME_SIGNED: "smime-signed";
+};
+declare const MESSAGE_ENCRYPTION_PART_ROLES: {
+    readonly VERSION: "version";
+    readonly CIPHERTEXT: "ciphertext";
+    readonly SIGNATURE: "signature";
+};
 
-declare const MESSAGE_ENCRYPTION_FORMATS: readonly ["pgp-mime", "pgp-signed", "pgp-inline", "smime-encrypted", "smime-signed"];
+type MessageEncryptionFormat = (typeof MESSAGE_ENCRYPTION_FORMATS)[keyof typeof MESSAGE_ENCRYPTION_FORMATS];
 
-type MessageEncryptionFormat = (typeof MESSAGE_ENCRYPTION_FORMATS)[number];
+type MessageEncryptionPartRole = (typeof MESSAGE_ENCRYPTION_PART_ROLES)[keyof typeof MESSAGE_ENCRYPTION_PART_ROLES];
 
 type MessageEncryption = {
     format: MessageEncryptionFormat;
@@ -130,7 +597,7 @@ type MessageEncryption = {
     parts?: Array<{
         index: number;
         attachmentId: string;
-        role: 'version' | 'ciphertext' | 'signature';
+        role: MessageEncryptionPartRole;
     }>;
 };
 
@@ -138,12 +605,7 @@ type MessageResource = Record<string, unknown> & {
     encryption?: MessageEncryption;
 };
 
-type Permission = ApiScope | 'api-keys:read' | 'api-keys:write' | 'billing:read' | 'billing:write' | 'workspace:manage' | (string & {});
-
-type RecipientInput = string | {
-    email: string;
-    name?: string;
-};
+type Permission = ApiScope | ConsolePermission | (string & {});
 
 type TranslateOptions = {
     to: string;
@@ -155,22 +617,172 @@ type SendTranslateOptions = TranslateOptions & {
     subject?: boolean;
 };
 
-type TrackingRequest = {
-    opens?: boolean;
-    clicks?: boolean;
+type ContactActivityBucket = {
+    bucket: string;
+    received: number;
+    sent: number;
 };
 
-type ContactListOptions = RequestScope & {
-    limit?: number;
+type ContactActivityOptions = RequestScope & {
+    minutes?: number;
+    grain?: TrackingGrain;
+    offsetMinutes?: number;
 };
 
-type ContactResource = {
+type ContactActivityTotals = {
+    received: number;
+    sent: number;
+    threads: number;
+    waiting: number;
+    lastReceivedAt: string | null;
+    lastSentAt: string | null;
+};
+
+type ContactReplyTime = {
+    yours: number | null;
+    theirs: number | null;
+};
+
+type ContactActivityResource = {
+    object: 'contact_activity';
+    email: string;
+    since: string;
+    until: string;
+    grain: TrackingGrain | (string & {});
+    buckets: Array<ContactActivityBucket>;
+    totals: ContactActivityTotals;
+    replyTime: ContactReplyTime;
+};
+
+type ContactAudienceResource = {
+    id: string;
+    name: string;
+    builtin: AudienceBuiltin | null;
+};
+
+type ContactAudiencesSet = {
+    audienceIds: Array<string>;
+};
+
+type ContactBatchDeleteResource = {
+    object: 'contact_batch_delete';
+    deleted: number;
+    saved: number;
+    invalid: Array<string>;
+};
+
+type ContactBlockList = (typeof CONTACT_BLOCK_LISTS)[keyof typeof CONTACT_BLOCK_LISTS];
+
+type ContactBlockRule = {
+    rule: string;
+    list: ContactBlockList | (string & {});
+};
+
+type ContactBlockResource = {
+    object: 'contact_block';
+    email: string;
+    blocked: boolean;
+    blockedBy?: ContactBlockRule;
+    created?: boolean;
+    removed?: Array<ContactBlockRule>;
+};
+
+type ContactCreate = {
+    email: string;
+    name?: string | null;
+    notes?: string | null;
+    audienceIds?: Array<string>;
+};
+
+type ContactDetailResource = ContactResource & {
+    audiences: Array<ContactAudienceResource>;
+};
+
+type ContactListOptions = ListOptions & {
+    source?: ContactSource;
+    q?: string;
+};
+
+type ContactPatch = {
+    name?: string | null;
+    notes?: string | null;
+};
+
+type ContactPhotoType = (typeof CONTACT_PHOTO_TYPES)[keyof typeof CONTACT_PHOTO_TYPES];
+
+type ContactPhotoOptions = RequestScope & {
+    contentType?: ContactPhotoType;
+};
+
+type ContactSave = {
+    name?: string;
+    notes?: string | null;
+};
+
+type ContactThreadSort = (typeof CONTACT_THREAD_SORTS)[keyof typeof CONTACT_THREAD_SORTS];
+
+type ContactThreadListOptions = ListOptions & {
+    q?: string;
+    sort?: ContactThreadSort;
+};
+
+type ContactThreadResource = {
+    object: 'thread';
+    id: string;
+    subject: string | null;
+    from: {
+        name: string | null;
+        email: string;
+    } | null;
+    receivedAt: string | null;
+    messageCount: number;
+    hasUnread: boolean;
+    labels: Array<{
+        id: string;
+        name: string;
+    }>;
+};
+
+type DeletedContactResource = {
     object: 'contact';
     email: string;
+    deleted: true;
+    wasSaved: boolean;
+};
+
+type Page<T> = {
+    items: Array<T>;
+    hasMore: boolean;
+    nextCursor: string | null;
+};
+
+type PersonResource = {
+    object: 'person';
+    email: string;
+    displayEmail: string;
     name: string | null;
-    source: 'manual' | 'auto' | (string & {});
+    saved: boolean;
+    source: ContactSource | (string & {}) | null;
     notes: string | null;
-    lastSeenAt: string | null;
+    photoUrl: string | null;
+    threads: number | null;
+    lastAt: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    blockedBy: ContactBlockRule | null;
+};
+
+type PeoplePage = Page<PersonResource> & {
+    seen: boolean;
+};
+
+type PeopleSort = (typeof PEOPLE_SORTS)[keyof typeof PEOPLE_SORTS];
+
+type PersonListOptions = ListOptions & {
+    q?: string;
+    email?: string;
+    sort?: PeopleSort;
+    blocked?: boolean;
 };
 
 type ApiErrorPayload = {
@@ -182,9 +794,18 @@ type ApiErrorPayload = {
     requestId?: string;
 };
 
-declare const ERROR_TYPES: readonly ["invalid_request_error", "authentication_error", "permission_error", "not_found_error", "conflict_error", "validation_error", "rate_limit_error", "api_error"];
+declare const ERROR_TYPES: {
+    readonly INVALID_REQUEST_ERROR: "invalid_request_error";
+    readonly AUTHENTICATION_ERROR: "authentication_error";
+    readonly PERMISSION_ERROR: "permission_error";
+    readonly NOT_FOUND_ERROR: "not_found_error";
+    readonly CONFLICT_ERROR: "conflict_error";
+    readonly VALIDATION_ERROR: "validation_error";
+    readonly RATE_LIMIT_ERROR: "rate_limit_error";
+    readonly API_ERROR: "api_error";
+};
 
-type ErrorType = (typeof ERROR_TYPES)[number];
+type ErrorType = (typeof ERROR_TYPES)[keyof typeof ERROR_TYPES];
 
 type ApiErrorProps = {
     message: string;
@@ -215,23 +836,79 @@ type ClientOptions = TransportOptions & {
 };
 
 declare const Addresses: (transport: Transport) => {
-    list: (options?: RequestScope) => Promise<AddressBookResource>;
+    list: (options?: ListOptions) => Promise<AddressBookPage>;
+    listAll: (options?: ListOptions) => Promise<AddressBookResource>;
+    iterate: (options?: ListOptions) => AsyncGenerator<AddressResource, void, undefined>;
+};
+
+declare const Audiences: (transport: Transport) => {
+    list: (options?: AudienceListOptions) => Promise<Page<AudienceResource>>;
+    listAll: (options?: AudienceListOptions) => Promise<Array<AudienceResource>>;
+    iterate: (options?: AudienceListOptions) => AsyncGenerator<AudienceResource, void, undefined>;
+    growth: (options?: AudienceGrowthOptions) => Promise<AudienceGrowthResource>;
+    get: (id: string, options?: RequestScope) => Promise<AudienceResource>;
+    create: (body: AudienceCreate, options?: RequestScope) => Promise<AudienceResource>;
+    update: (id: string, patch: AudiencePatch, options?: RequestScope) => Promise<AudienceResource>;
+    delete: (id: string, options?: RequestScope) => Promise<DeletedAudienceResource>;
+    empty: (id: string, options?: RequestScope) => Promise<EmptiedAudienceResource>;
+    listContacts: (id: string, options?: AudienceContactListOptions) => Promise<Page<AudienceContactResource>>;
+    listAllContacts: (id: string, options?: AudienceContactListOptions) => Promise<Array<AudienceContactResource>>;
+    iterateContacts: (id: string, options?: AudienceContactListOptions) => AsyncGenerator<AudienceContactResource, void, undefined>;
+    addContact: (id: string, body: AudienceContactAdd, options?: RequestScope) => Promise<AudienceMemberResource>;
+    removeContact: (id: string, email: string, options?: RequestScope) => Promise<RemovedAudienceContactResource>;
+    addContacts: (id: string, body: AudienceContactsBatch, options?: RequestScope) => Promise<AudienceBatchAddResource>;
+    removeContacts: (id: string, body: AudienceContactsBatch, options?: RequestScope) => Promise<AudienceBatchRemoveResource>;
+    importContacts: (id: string, body: AudienceImport, options?: RequestScope) => Promise<AudienceImportResource>;
+};
+
+declare const Broadcasts: (transport: Transport) => {
+    preview: (body: BroadcastPreviewInput, options?: RequestScope) => Promise<BroadcastPreviewResource>;
+    send: (body: BroadcastCreate, options?: SendScope) => Promise<SentBroadcastResource>;
+    list: (options?: BroadcastListOptions) => Promise<Page<BroadcastResource>>;
+    listAll: (options?: BroadcastListOptions) => Promise<Array<BroadcastResource>>;
+    iterate: (options?: BroadcastListOptions) => AsyncGenerator<BroadcastResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<BroadcastResource>;
+    cancel: (id: string, options?: RequestScope) => Promise<BroadcastResource>;
 };
 
 declare const Calendar: (transport: Transport) => {
-    listEvents: (options: CalendarRangeOptions) => Promise<Array<CalendarOccurrenceResource>>;
+    listEvents: (options: CalendarRangeOptions) => Promise<Page<CalendarOccurrenceResource>>;
+    listAllEvents: (options: CalendarRangeOptions) => Promise<Array<CalendarOccurrenceResource>>;
+    iterateEvents: (options: CalendarRangeOptions) => AsyncGenerator<CalendarOccurrenceResource, void, undefined>;
     getEvent: (id: string, options?: RequestScope) => Promise<CalendarEventResource>;
     getEventIcs: (id: string, options?: RequestScope) => Promise<string>;
 };
 
 declare const Contacts: (transport: Transport) => {
-    list: (options?: ContactListOptions) => Promise<Array<ContactResource>>;
-    get: (email: string, options?: RequestScope) => Promise<ContactResource>;
+    list: (options?: ContactListOptions) => Promise<Page<ContactResource>>;
+    listAll: (options?: ContactListOptions) => Promise<Array<ContactResource>>;
+    iterate: (options?: ContactListOptions) => AsyncGenerator<ContactResource, void, undefined>;
+    get: (email: string, options?: RequestScope) => Promise<ContactDetailResource>;
+    create: (body: ContactCreate, options?: RequestScope) => Promise<ContactDetailResource>;
+    update: (email: string, patch: ContactPatch, options?: RequestScope) => Promise<ContactDetailResource>;
+    delete: (email: string, options?: RequestScope) => Promise<DeletedContactResource>;
+    setAudiences: (email: string, body: ContactAudiencesSet, options?: RequestScope) => Promise<ContactDetailResource>;
+    listPeople: (options?: PersonListOptions) => Promise<PeoplePage>;
+    listAllPeople: (options?: PersonListOptions) => Promise<Array<PersonResource>>;
+    iteratePeople: (options?: PersonListOptions) => AsyncGenerator<PersonResource, void, undefined>;
+    save: (email: string, body?: ContactSave, options?: RequestScope) => Promise<ContactDetailResource>;
+    deleteMany: (emails: Array<string>, options?: RequestScope) => Promise<ContactBatchDeleteResource>;
+    setPhoto: (email: string, data: RawBody, options?: ContactPhotoOptions) => Promise<ContactDetailResource>;
+    removePhoto: (email: string, options?: RequestScope) => Promise<ContactDetailResource>;
+    block: (email: string, options?: RequestScope) => Promise<ContactBlockResource>;
+    unblock: (email: string, options?: RequestScope) => Promise<ContactBlockResource>;
+    listThreads: (email: string, options?: ContactThreadListOptions) => Promise<Page<ContactThreadResource>>;
+    listAllThreads: (email: string, options?: ContactThreadListOptions) => Promise<Array<ContactThreadResource>>;
+    iterateThreads: (email: string, options?: ContactThreadListOptions) => AsyncGenerator<ContactThreadResource, void, undefined>;
+    activity: (email: string, options?: ContactActivityOptions) => Promise<ContactActivityResource>;
 };
 
 declare const Domains: (transport: Transport) => {
-    list: (options?: RequestScope) => Promise<Array<DomainResource>>;
+    list: (options?: ListOptions) => Promise<Page<DomainResource>>;
+    listAll: (options?: ListOptions) => Promise<Array<DomainResource>>;
+    iterate: (options?: ListOptions) => AsyncGenerator<DomainResource, void, undefined>;
     get: (id: string, options?: RequestScope) => Promise<DomainDetailResource>;
+    update: (id: string, patch: DomainPatch, options?: RequestScope) => Promise<DomainDetailResource>;
 };
 
 declare const Drafts: (transport: Transport) => {
@@ -252,17 +929,86 @@ declare const Emails: (transport: Transport) => {
     listAll: (options?: EmailListOptions) => Promise<Array<EmailResource>>;
     iterate: (options?: EmailListOptions) => AsyncGenerator<EmailResource, void, undefined>;
     get: (id: string, options?: RequestScope) => Promise<EmailResource>;
-    listEvents: (id: string, options?: RequestScope) => Promise<Array<EmailEventResource>>;
+    listEvents: (id: string, options?: ListOptions) => Promise<Page<EmailEventResource>>;
+    listAllEvents: (id: string, options?: ListOptions) => Promise<Array<EmailEventResource>>;
+    iterateEvents: (id: string, options?: ListOptions) => AsyncGenerator<EmailEventResource, void, undefined>;
     getTracking: (id: string, options?: RequestScope) => Promise<TrackingResource>;
     cancel: (id: string, options?: RequestScope) => Promise<EmailResource>;
     reschedule: (id: string, scheduledAt: Date | string, options?: RequestScope) => Promise<EmailResource>;
 };
 
+declare const Files: (transport: Transport) => {
+    list: (options?: FileListOptions) => Promise<Page<FileResource>>;
+    listAll: (options?: FileListOptions) => Promise<Array<FileResource>>;
+    iterate: (options?: FileListOptions) => AsyncGenerator<FileResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<FileResource>;
+    stats: (options?: RequestScope) => Promise<FileStatsResource>;
+    download: (id: string, options?: RequestScope) => Promise<Uint8Array>;
+    listLinks: (id: string, options?: ListOptions) => Promise<Page<FileLinkResource>>;
+    listAllLinks: (id: string, options?: ListOptions) => Promise<Array<FileLinkResource>>;
+    iterateLinks: (id: string, options?: ListOptions) => AsyncGenerator<FileLinkResource, void, undefined>;
+    upload: (data: RawBody, options: FileUploadOptions) => Promise<FileResource>;
+    delete: (id: string, options?: RequestScope) => Promise<DeletedFileResource>;
+    deleteMany: (ids: Array<string>, options?: RequestScope) => Promise<FileBatchDeleteResource>;
+};
+
+declare const Imports: (transport: Transport) => {
+    list: (options?: ImportListOptions) => Promise<Page<ImportResource>>;
+    listAll: (options?: ImportListOptions) => Promise<Array<ImportResource>>;
+    iterate: (options?: ImportListOptions) => AsyncGenerator<ImportResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<ImportResource>;
+    create: (body: ImportCreate, options?: RequestScope) => Promise<ImportResource>;
+    uploadState: (id: string, options?: RequestScope) => Promise<ImportUploadResource>;
+    uploadChunk: (id: string, file: number, chunk: number, data: RawBody, options?: RequestScope) => Promise<ImportChunkResource>;
+    start: (id: string, options?: RequestScope) => Promise<ImportResource>;
+    cancel: (id: string, options?: RequestScope) => Promise<ImportResource>;
+    listFailures: (id: string, options?: ImportFailuresOptions) => Promise<ImportFailurePage>;
+    deleteUpload: (id: string, options?: RequestScope) => Promise<ImportResource>;
+    importFiles: (input: ImportFilesInput, options?: RequestScope) => Promise<ImportResource>;
+};
+
+declare const Keys: (transport: Transport) => {
+    list: (options?: ListOptions) => Promise<Page<ApiKeyResource>>;
+    listAll: (options?: ListOptions) => Promise<Array<ApiKeyResource>>;
+    iterate: (options?: ListOptions) => AsyncGenerator<ApiKeyResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<ApiKeyResource>;
+    create: (body: ApiKeyCreate, options?: RequestScope) => Promise<CreatedApiKeyResource>;
+    update: (id: string, patch: ApiKeyPatch, options?: RequestScope) => Promise<ApiKeyResource>;
+    delete: (id: string, options?: RequestScope) => Promise<DeletedApiKeyResource>;
+    rotate: (id: string, options?: RequestScope) => Promise<RotatedApiKeyResource>;
+    revoke: (id: string, body?: ApiKeyRevoke, options?: RequestScope) => Promise<ApiKeyResource>;
+    listRequests: (id: string, options?: ApiKeyRequestListOptions) => Promise<Page<ApiKeyRequestResource>>;
+    listAllRequests: (id: string, options?: ApiKeyRequestListOptions) => Promise<Array<ApiKeyRequestResource>>;
+    iterateRequests: (id: string, options?: ApiKeyRequestListOptions) => AsyncGenerator<ApiKeyRequestResource, void, undefined>;
+    listActivity: (id: string, options?: ApiKeyActivityListOptions) => Promise<Page<ApiKeyActivityResource>>;
+    listAllActivity: (id: string, options?: ApiKeyActivityListOptions) => Promise<Array<ApiKeyActivityResource>>;
+    iterateActivity: (id: string, options?: ApiKeyActivityListOptions) => AsyncGenerator<ApiKeyActivityResource, void, undefined>;
+    listWorkspaceRequests: (options?: ApiKeyWorkspaceRequestListOptions) => Promise<Page<ApiKeyRequestResource>>;
+    listAllWorkspaceRequests: (options?: ApiKeyWorkspaceRequestListOptions) => Promise<Array<ApiKeyRequestResource>>;
+    iterateWorkspaceRequests: (options?: ApiKeyWorkspaceRequestListOptions) => AsyncGenerator<ApiKeyRequestResource, void, undefined>;
+    listWorkspaceActivity: (options?: ApiKeyWorkspaceActivityListOptions) => Promise<Page<ApiKeyActivityResource>>;
+    listAllWorkspaceActivity: (options?: ApiKeyWorkspaceActivityListOptions) => Promise<Array<ApiKeyActivityResource>>;
+    iterateWorkspaceActivity: (options?: ApiKeyWorkspaceActivityListOptions) => AsyncGenerator<ApiKeyActivityResource, void, undefined>;
+};
+
+declare const ProviderImports: (transport: Transport) => {
+    inspect: (apiKey: string, options?: RequestScope) => Promise<ProviderInventoryResource>;
+    create: (body: ProviderImportCreate, options?: RequestScope) => Promise<ProviderImportResource>;
+    list: (options?: ProviderImportListOptions) => Promise<Page<ProviderImportResource>>;
+    listAll: (options?: ProviderImportListOptions) => Promise<Array<ProviderImportResource>>;
+    iterate: (options?: ProviderImportListOptions) => AsyncGenerator<ProviderImportResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<ProviderImportResource>;
+    cancel: (id: string, options?: RequestScope) => Promise<ProviderImportResource>;
+};
+
 declare const Labels: (transport: Transport) => {
-    list: (options?: RequestScope) => Promise<Array<LabelResource>>;
+    list: (options?: ListOptions) => Promise<Page<LabelResource>>;
+    listAll: (options?: ListOptions) => Promise<Array<LabelResource>>;
+    iterate: (options?: ListOptions) => AsyncGenerator<LabelResource, void, undefined>;
+    listColors: (options?: RequestScope) => Promise<Array<LabelColorResource>>;
     get: (id: string, options?: RequestScope) => Promise<LabelResource>;
-    create: (body: LabelInput, options?: RequestScope) => Promise<SavedLabelResource>;
-    update: (id: string, body: LabelInput, options?: RequestScope) => Promise<SavedLabelResource>;
+    create: (body: LabelInput, options?: RequestScope) => Promise<LabelResource>;
+    update: (id: string, patch: LabelPatch, options?: RequestScope) => Promise<LabelResource>;
     delete: (id: string, options?: RequestScope) => Promise<DeletedLabelResource>;
 };
 
@@ -273,20 +1019,30 @@ declare const Languages: (transport: Transport) => {
 declare const Me: (transport: Transport) => {
     get: (options?: RequestScope) => Promise<KeyResource>;
     ping: (options?: RequestScope) => Promise<PingResource>;
+    rotate: (options?: RequestScope) => Promise<RotatedKeyResource>;
 };
 
 declare const Members: (transport: Transport) => {
-    list: (options?: RequestScope) => Promise<Array<MemberResource>>;
+    list: (options?: ListOptions) => Promise<Page<MemberResource>>;
+    listAll: (options?: ListOptions) => Promise<Array<MemberResource>>;
+    iterate: (options?: ListOptions) => AsyncGenerator<MemberResource, void, undefined>;
     get: (userId: string, options?: RequestScope) => Promise<MemberResource>;
-    add: (body: MemberAdd, options?: RequestScope) => Promise<MemberResource>;
+    add: (body: MemberAdd, options?: RequestScope) => Promise<InvitationResource>;
     update: (userId: string, patch: MemberPatch, options?: RequestScope) => Promise<MemberResource>;
     remove: (userId: string, options?: RequestScope) => Promise<RemovedMemberResource>;
     grantAddress: (userId: string, body: MemberAddressGrant, options?: RequestScope) => Promise<MemberResource>;
     revokeAddress: (userId: string, addressId: string, options?: RequestScope) => Promise<MemberResource>;
+    listInvitations: (options?: ListOptions) => Promise<Page<InvitationResource>>;
+    listAllInvitations: (options?: ListOptions) => Promise<Array<InvitationResource>>;
+    iterateInvitations: (options?: ListOptions) => AsyncGenerator<InvitationResource, void, undefined>;
+    revokeInvitation: (invitationId: string, options?: RequestScope) => Promise<RevokedInvitationResource>;
+    resendInvitation: (invitationId: string, options?: RequestScope) => Promise<InvitationResource>;
 };
 
 declare const Roles: (transport: Transport) => {
-    list: (options?: RequestScope) => Promise<Array<RoleResource>>;
+    list: (options?: ListOptions) => Promise<Page<RoleResource>>;
+    listAll: (options?: ListOptions) => Promise<Array<RoleResource>>;
+    iterate: (options?: ListOptions) => AsyncGenerator<RoleResource, void, undefined>;
     get: (id: string, options?: RequestScope) => Promise<RoleResource>;
     create: (body: RoleCreate, options?: RequestScope) => Promise<RoleResource>;
     update: (id: string, patch: RolePatch, options?: RequestScope) => Promise<RoleResource>;
@@ -310,8 +1066,17 @@ declare const Rules: (transport: Transport) => {
 };
 
 declare const Settings: (transport: Transport) => {
-    get: (options?: RequestScope) => Promise<SettingsResource>;
-    update: (patch: SettingsPatch, options?: RequestScope) => Promise<SettingsResource>;
+    get: (options?: SettingsOptions) => Promise<SettingsResource>;
+    update: (patch: SettingsPatch, options?: SettingsOptions) => Promise<SettingsResource>;
+};
+
+declare const Suppressions: (transport: Transport) => {
+    list: (options?: SuppressionListOptions) => Promise<Page<SuppressionResource>>;
+    listAll: (options?: SuppressionListOptions) => Promise<Array<SuppressionResource>>;
+    iterate: (options?: SuppressionListOptions) => AsyncGenerator<SuppressionResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<SuppressionResource>;
+    add: (body: SuppressionAdd, options?: RequestScope) => Promise<SuppressionResource>;
+    remove: (id: string, options?: RequestScope) => Promise<RemovedSuppressionResource>;
 };
 
 declare const TempMail: (transport: Transport) => {
@@ -321,6 +1086,8 @@ declare const TempMail: (transport: Transport) => {
     extend: (inboxId: string, options?: InboxScope) => Promise<TempInboxResource>;
     delete: (inboxId: string, options?: InboxScope) => Promise<DeletedTempInboxResource>;
     listMessages: (inboxId: string, options?: TempMessageListOptions) => Promise<TempMessagesResource>;
+    listAllMessages: (inboxId: string, options?: TempMessageListOptions) => Promise<Array<TempMessageResource>>;
+    iterateMessages: (inboxId: string, options?: TempMessageListOptions) => AsyncGenerator<TempMessageResource, void, undefined>;
     getMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<TempMessageDetailResource>;
     deleteMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<DeletedTempMessageResource>;
     listAttachments: (inboxId: string, messageId: string, options?: InboxScope) => Promise<Array<AttachmentResource>>;
@@ -330,13 +1097,26 @@ declare const Templates: (transport: Transport) => {
     list: (options?: TemplateListOptions) => Promise<Page<TemplateResource>>;
     listAll: (options?: TemplateListOptions) => Promise<Array<TemplateResource>>;
     iterate: (options?: TemplateListOptions) => AsyncGenerator<TemplateResource, void, undefined>;
+    listStarters: (options?: RequestScope) => Promise<Array<TemplateStarterResource>>;
+    listFonts: (options?: RequestScope) => Promise<Array<TemplateFontResource>>;
+    getStarter: (slug: string, options?: RequestScope) => Promise<TemplateStarterDetailResource>;
+    render: (body: TemplateRenderInput, options?: RequestScope) => Promise<TemplateRenderResource>;
     get: (idOrSlug: string, options?: RequestScope) => Promise<TemplateDetailResource>;
     create: (body: TemplateCreate, options?: RequestScope) => Promise<TemplateResource>;
     update: (idOrSlug: string, patch: TemplatePatch, options?: RequestScope) => Promise<TemplateDetailResource>;
     delete: (idOrSlug: string, options?: RequestScope) => Promise<DeletedTemplateResource>;
-    listVersions: (idOrSlug: string, options?: RequestScope) => Promise<Array<TemplateVersionResource>>;
+    duplicate: (idOrSlug: string, body?: TemplateDuplicate, options?: RequestScope) => Promise<TemplateDetailResource>;
+    replaceContent: (idOrSlug: string, body: TemplateContentSource, options?: RequestScope) => Promise<TemplateDetailResource>;
+    listVersions: (idOrSlug: string, options?: ListOptions) => Promise<Page<TemplateVersionResource>>;
+    listAllVersions: (idOrSlug: string, options?: ListOptions) => Promise<Array<TemplateVersionResource>>;
+    iterateVersions: (idOrSlug: string, options?: ListOptions) => AsyncGenerator<TemplateVersionResource, void, undefined>;
+    getVersion: (idOrSlug: string, version: number, options?: RequestScope) => Promise<TemplateVersionResource>;
+    deleteVersion: (idOrSlug: string, version: number, options?: RequestScope) => Promise<DeletedTemplateVersionResource>;
+    restoreVersion: (idOrSlug: string, version: number, body?: TemplateRestoreInput, options?: RequestScope) => Promise<TemplateRestoredResource>;
     publish: (idOrSlug: string, options?: RequestScope) => Promise<TemplateVersionResource>;
     preview: (idOrSlug: string, body?: TemplatePreviewInput, options?: RequestScope) => Promise<TemplatePreviewResource>;
+    getAnalytics: (idOrSlug: string, options?: TemplateAnalyticsOptions) => Promise<TemplateAnalyticsResource>;
+    listSends: (idOrSlug: string, options?: TemplateSendListOptions) => Promise<TemplateSendsResource>;
     send: (idOrSlug: string, body: TemplateSend, options?: SendScope) => Promise<SentTemplateEmailResource>;
 };
 
@@ -353,28 +1133,50 @@ declare const Threads: (transport: Transport) => {
 };
 
 declare const Tracking: (transport: Transport) => {
-    list: (options?: TrackingListOptions) => Promise<Array<TrackingResource>>;
+    list: (options?: TrackingListOptions) => Promise<Page<TrackingResource>>;
+    listAll: (options?: TrackingListOptions) => Promise<Array<TrackingResource>>;
+    iterate: (options?: TrackingListOptions) => AsyncGenerator<TrackingResource, void, undefined>;
     getStats: (options?: TrackingStatsOptions) => Promise<TrackingStatsResource>;
     get: (id: string, options?: RequestScope) => Promise<TrackingResource>;
-    listOpens: (id: string, options?: TrackingHitOptions) => Promise<Array<TrackingOpenResource>>;
-    listClicks: (id: string, options?: TrackingHitOptions) => Promise<Array<TrackingClickResource>>;
+    listOpens: (id: string, options?: TrackingHitOptions) => Promise<Page<TrackingOpenResource>>;
+    listAllOpens: (id: string, options?: TrackingHitOptions) => Promise<Array<TrackingOpenResource>>;
+    iterateOpens: (id: string, options?: TrackingHitOptions) => AsyncGenerator<TrackingOpenResource, void, undefined>;
+    listClicks: (id: string, options?: TrackingHitOptions) => Promise<Page<TrackingClickResource>>;
+    listAllClicks: (id: string, options?: TrackingHitOptions) => Promise<Array<TrackingClickResource>>;
+    iterateClicks: (id: string, options?: TrackingHitOptions) => AsyncGenerator<TrackingClickResource, void, undefined>;
 };
 
 declare const Webhooks: (transport: Transport) => {
-    list: (options?: RequestScope) => Promise<Array<WebhookResource>>;
+    list: (options?: ListOptions) => Promise<Page<WebhookResource>>;
+    listAll: (options?: ListOptions) => Promise<Array<WebhookResource>>;
+    iterate: (options?: ListOptions) => AsyncGenerator<WebhookResource, void, undefined>;
     get: (id: string, options?: RequestScope) => Promise<WebhookResource>;
     create: (body: WebhookCreate, options?: RequestScope) => Promise<CreatedWebhookResource>;
     update: (id: string, patch: WebhookPatch, options?: RequestScope) => Promise<WebhookResource>;
     delete: (id: string, options?: RequestScope) => Promise<DeletedWebhookResource>;
     rotateSecret: (id: string, options?: RequestScope) => Promise<CreatedWebhookResource>;
     test: (id: string, options?: RequestScope) => Promise<WebhookTestResource>;
-    listDeliveries: (id: string, options?: RequestScope) => Promise<Array<WebhookDeliveryResource>>;
+    listDeliveries: (id: string, options?: WebhookDeliveryListOptions) => Promise<Page<WebhookDeliveryResource>>;
+    listAllDeliveries: (id: string, options?: WebhookDeliveryListOptions) => Promise<Array<WebhookDeliveryResource>>;
+    iterateDeliveries: (id: string, options?: WebhookDeliveryListOptions) => AsyncGenerator<WebhookDeliveryResource, void, undefined>;
+    listWorkspaceDeliveries: (options?: WebhookWorkspaceDeliveryListOptions) => Promise<Page<WebhookDeliveryResource>>;
+    listAllWorkspaceDeliveries: (options?: WebhookWorkspaceDeliveryListOptions) => Promise<Array<WebhookDeliveryResource>>;
+    iterateWorkspaceDeliveries: (options?: WebhookWorkspaceDeliveryListOptions) => AsyncGenerator<WebhookDeliveryResource, void, undefined>;
+    listActivity: (id: string, options?: WebhookActivityListOptions) => Promise<Page<WebhookActivityResource>>;
+    listAllActivity: (id: string, options?: WebhookActivityListOptions) => Promise<Array<WebhookActivityResource>>;
+    iterateActivity: (id: string, options?: WebhookActivityListOptions) => AsyncGenerator<WebhookActivityResource, void, undefined>;
+    listWorkspaceActivity: (options?: WebhookWorkspaceActivityListOptions) => Promise<Page<WebhookActivityResource>>;
+    listAllWorkspaceActivity: (options?: WebhookWorkspaceActivityListOptions) => Promise<Array<WebhookActivityResource>>;
+    iterateWorkspaceActivity: (options?: WebhookWorkspaceActivityListOptions) => AsyncGenerator<WebhookActivityResource, void, undefined>;
+    getDelivery: (id: string, deliveryId: string, options?: RequestScope) => Promise<WebhookDeliveryDetailResource>;
+    replayDelivery: (id: string, deliveryId: string, options?: RequestScope) => Promise<WebhookReplayResource>;
 };
 
 declare class OpenEmail {
     private readonly transport;
     readonly mode: ApiKeyMode;
     readonly me: ReturnType<typeof Me>;
+    readonly keys: ReturnType<typeof Keys>;
     readonly addresses: ReturnType<typeof Addresses>;
     readonly languages: ReturnType<typeof Languages>;
     readonly emails: ReturnType<typeof Emails>;
@@ -384,13 +1186,19 @@ declare class OpenEmail {
     readonly drafts: ReturnType<typeof Drafts>;
     readonly labels: ReturnType<typeof Labels>;
     readonly contacts: ReturnType<typeof Contacts>;
+    readonly audiences: ReturnType<typeof Audiences>;
+    readonly broadcasts: ReturnType<typeof Broadcasts>;
     readonly domains: ReturnType<typeof Domains>;
     readonly rules: ReturnType<typeof Rules>;
     readonly webhooks: ReturnType<typeof Webhooks>;
+    readonly imports: ReturnType<typeof Imports>;
+    readonly providerImports: ReturnType<typeof ProviderImports>;
     readonly calendar: ReturnType<typeof Calendar>;
     readonly settings: ReturnType<typeof Settings>;
     readonly roles: ReturnType<typeof Roles>;
     readonly members: ReturnType<typeof Members>;
+    readonly suppressions: ReturnType<typeof Suppressions>;
+    readonly files: ReturnType<typeof Files>;
     readonly tempMail: ReturnType<typeof TempMail>;
     constructor(configuration: ClientOptions | string);
     get raw(): Transport;
@@ -401,23 +1209,16 @@ type InboxScope = {
     inboxToken?: string;
 };
 
-type ListOptions = RequestScope & {
-    limit?: number;
-    cursor?: string;
-};
-
-type Page<T> = {
-    items: Array<T>;
-    hasMore: boolean;
-    nextCursor: string | null;
-};
-
 type QueryValues = Record<string, string | number | boolean | null | undefined>;
 
+type RawBody = Blob | ArrayBuffer | Uint8Array;
+
 type RequestOptions = {
     method?: string;
     query?: QueryValues;
     body?: unknown;
+    raw?: RawBody;
+    contentType?: string;
     signal?: AbortSignal;
     apiKey?: string;
     inboxToken?: string;
@@ -426,6 +1227,8 @@ type RequestOptions = {
     idempotencyKey?: string;
     repeatable?: boolean;
     accept?: string;
+    binary?: boolean;
+    timeoutMs?: number;
 };
 
 type SendScope = RequestScope & {
@@ -436,7 +1239,61 @@ type TempMailOptions = Omit<TransportOptions, 'apiKey'> & {
     inboxToken?: string;
 };
 
-type DomainSendingState = 'verified' | 'pending' | 'failed' | 'no_identity' | 'unknown';
+declare const DOMAIN_SENDING_STATES: {
+    readonly VERIFIED: "verified";
+    readonly PENDING: "pending";
+    readonly FAILED: "failed";
+    readonly NO_IDENTITY: "no_identity";
+    readonly UNKNOWN: "unknown";
+};
+declare const DOMAIN_TRACKING_STATES: {
+    readonly NONE: "none";
+    readonly PENDING: "pending";
+    readonly ACTIVE: "active";
+    readonly FAILED: "failed";
+};
+declare const DOMAIN_STORAGE_STATES: {
+    readonly NONE: "none";
+    readonly PENDING: "pending";
+    readonly ACTIVE: "active";
+    readonly FAILED: "failed";
+};
+
+type DomainSendingState = (typeof DOMAIN_SENDING_STATES)[keyof typeof DOMAIN_SENDING_STATES];
+
+type DomainStorageState = (typeof DOMAIN_STORAGE_STATES)[keyof typeof DOMAIN_STORAGE_STATES];
+
+type DomainStorage = {
+    host: string | null;
+    status: DomainStorageState;
+    active: boolean;
+    target: string;
+    record: {
+        type: 'CNAME';
+        name: string;
+        value: string;
+    } | null;
+    checkedAt: string | null;
+    verifiedAt: string | null;
+    error: string | null;
+};
+
+type DomainTrackingState = (typeof DOMAIN_TRACKING_STATES)[keyof typeof DOMAIN_TRACKING_STATES];
+
+type DomainTracking = {
+    host: string | null;
+    status: DomainTrackingState;
+    active: boolean;
+    target: string;
+    record: {
+        type: 'CNAME';
+        name: string;
+        value: string;
+    } | null;
+    checkedAt: string | null;
+    verifiedAt: string | null;
+    error: string | null;
+};
 
 type DomainResource = {
     object: 'domain';
@@ -456,6 +1313,8 @@ type DomainResource = {
         error: string | null;
         note: string;
     };
+    tracking: DomainTracking;
+    storage: DomainStorage;
     createdAt: string;
 };
 
@@ -466,6 +1325,11 @@ type DomainDetailResource = DomainResource & {
     }>;
 };
 
+type DomainPatch = {
+    trackingHost?: string | null;
+    storageHost?: string | null;
+};
+
 type DeletedDraftResource = {
     object: 'draft';
     id: string;
@@ -513,20 +1377,22 @@ type SavedDraftResource = {
     id: string | null;
 };
 
-type RecipientStatus = 'pending' | 'suppressed' | 'delivered' | 'failed' | 'bounced' | 'complained' | 'uncertain';
+type AttachmentDeliveryMode = (typeof ATTACHMENT_DELIVERY_MODES)[keyof typeof ATTACHMENT_DELIVERY_MODES];
+
+type RecipientKind = (typeof RECIPIENT_KINDS)[keyof typeof RECIPIENT_KINDS];
+
+type RecipientStatus = (typeof RECIPIENT_STATUSES)[keyof typeof RECIPIENT_STATUSES];
 
 type EmailRecipientResource = {
     email: string;
     name: string | null;
-    kind: 'to' | 'cc' | 'bcc';
+    kind: RecipientKind;
     status: RecipientStatus;
     error: string | null;
     deliveredAt: string | null;
 };
 
-type EmailSource = 'composer' | 'api' | 'mcp' | 'ai' | 'queue';
-
-type EmailStatus = 'queued' | 'scheduled' | 'sending' | 'sent' | 'partial' | 'cancelled' | 'failed';
+type EmailStatus = (typeof EMAIL_STATUSES)[keyof typeof EMAIL_STATUSES];
 
 type EmailTrackingSummary = {
     opens: boolean;
@@ -546,7 +1412,7 @@ type EmailTranslationResource = {
     includeOriginal: boolean;
 };
 
-type EmailTransport = 'ses' | 'resend' | 'dev' | 'test';
+type EmailTransport = (typeof EMAIL_TRANSPORTS)[keyof typeof EMAIL_TRANSPORTS];
 
 type TrackingLinkResource = {
     id: string;
@@ -558,7 +1424,7 @@ type TrackingLinkResource = {
 
 type TrackingRecipientResource = {
     email: string | null;
-    kind: 'to' | 'cc' | 'bcc' | null;
+    kind: RecipientKind | null;
     attributed: boolean;
     openCount: number;
     clickCount: number;
@@ -610,6 +1476,7 @@ type EmailResource = {
     cancellableUntil: string | null;
     sentAt: string | null;
     tags: Record<string, string>;
+    broadcastId: string | null;
     source: EmailSource | (string & {});
     createdAt: string;
     recipients?: Array<EmailRecipientResource>;
@@ -653,6 +1520,7 @@ type EmailEventResource = {
 type EmailListOptions = ListOptions & {
     status?: EmailStatus | Array<EmailStatus>;
     from?: string;
+    broadcastId?: string;
 };
 
 type EmailSend = {
@@ -666,6 +1534,7 @@ type EmailSend = {
     text?: string;
     headers?: Record<string, string>;
     attachments?: Array<AttachmentInput>;
+    attachmentDelivery?: AttachmentDeliveryMode;
     threadId?: string;
     draftId?: string;
     template?: {
@@ -688,22 +1557,516 @@ type EmailTranslate = TranslateOptions & {
     subject?: string;
 };
 
-type LanguageResource = {
-    code: string;
-    label: string;
-    native: string;
-    flag: string;
-    rtl: boolean;
+type LanguageResource = {
+    code: string;
+    label: string;
+    native: string;
+    flag: string;
+    rtl: boolean;
+};
+
+type TranslationResource = {
+    object: 'translation';
+    language: LanguageResource;
+    detectedSourceLanguage: LanguageResource | null;
+    subject: string | null;
+    html: string | null;
+    text: string | null;
+    includeOriginal: boolean;
+};
+
+type DeletedFileResource = {
+    object: 'file';
+    id: string;
+    deleted: true;
+};
+
+type FileAddressCount = {
+    address: string;
+    files: number;
+    bytes: number;
+};
+
+declare const FILE_SORTS: {
+    readonly NEWEST: "newest";
+    readonly OLDEST: "oldest";
+    readonly LARGEST: "largest";
+    readonly NAME: "name";
+};
+declare const FILE_KINDS: {
+    readonly IMAGE: "image";
+    readonly PDF: "pdf";
+    readonly AUDIO: "audio";
+    readonly VIDEO: "video";
+    readonly TEXT: "text";
+};
+declare const FILE_DIRECTIONS: {
+    readonly INBOUND: "inbound";
+    readonly OUTBOUND: "outbound";
+    readonly UPLOADED: "uploaded";
+};
+interface FileUsages {
+    RECEIVED: 'received';
+    SENT: 'sent';
+    LINKED: 'linked';
+    SCHEDULED: 'scheduled';
+}
+type FileUsage = FileUsages[keyof FileUsages];
+declare const FILE_USAGES: FileUsages;
+
+type FileKept = {
+    id: string;
+    filename: string;
+    usage: FileUsage;
+    reason: string;
+};
+
+type FileBatchDeleteResource = {
+    object: 'file_batch_delete';
+    deleted: Array<string>;
+    kept: Array<FileKept>;
+    missing: Array<string>;
+};
+
+type FileCount = {
+    files: number;
+    bytes: number;
+};
+
+type FileDayCount = {
+    day: string;
+    files: number;
+    bytes: number;
+};
+
+type FileDirection = (typeof FILE_DIRECTIONS)[keyof typeof FILE_DIRECTIONS];
+
+type FileKind = (typeof FILE_KINDS)[keyof typeof FILE_KINDS];
+
+type FileLinkCount = {
+    shares: number;
+    downloads: number;
+    lastDownloadAt: string | null;
+};
+
+type FileLinkResource = {
+    object: 'file_link';
+    id: string;
+    fileId: string | null;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    host: string | null;
+    url: string;
+    downloads: number;
+    lastDownloadAt: string | null;
+    revokedAt: string | null;
+    createdAt: string;
+};
+
+type FileSort = (typeof FILE_SORTS)[keyof typeof FILE_SORTS];
+
+type FileListOptions = ListOptions & {
+    q?: string;
+    kind?: FileKind;
+    sort?: FileSort;
+};
+
+type FileResource = {
+    object: 'file';
+    id: string;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    direction: FileDirection;
+    threadId: string | null;
+    messageId: string | null;
+    deliveredTo: string | null;
+    usage: FileUsage | null;
+    deletable: boolean;
+    createdAt: string;
+};
+
+type FileTypeCount = {
+    mimeType: string;
+    files: number;
+    bytes: number;
+};
+
+type FileStatsResource = {
+    object: 'file_stats';
+    totals: FileCount;
+    received: FileCount;
+    sent: FileCount;
+    uploaded: FileCount;
+    types: Array<FileTypeCount>;
+    byDay: Array<FileDayCount>;
+    addresses: Array<FileAddressCount>;
+    links: FileLinkCount;
+};
+
+type FileUploadOptions = RequestScope & {
+    filename: string;
+    contentType?: string;
+    timeoutMs?: number;
+};
+
+type ImportChunkResource = {
+    object: 'import_chunk';
+    file: number;
+    chunk: number;
+    bytes: number;
+};
+
+type ImportCounts = {
+    seen: number;
+    imported: number;
+    duplicate: number;
+    filtered: number;
+    failed: number;
+    threads: number;
+};
+
+type ImportFileDescriptor = {
+    name: string;
+    bytes: number;
+};
+
+type ImportOptions = {
+    keepInbox?: boolean;
+    includeSpam?: boolean;
+    includeTrash?: boolean;
+};
+
+type ImportCreate = {
+    addressId: string;
+    files: Array<ImportFileDescriptor>;
+    options?: ImportOptions;
+};
+
+declare const IMPORT_STATUSES: {
+    readonly UPLOADING: "uploading";
+    readonly QUEUED: "queued";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+};
+declare const IMPORT_FAILURE_REASONS: {
+    readonly TOO_LARGE: "too-large";
+    readonly UNPARSEABLE: "unparseable";
+    readonly NO_DATE: "no-date";
+    readonly STORAGE_ERROR: "storage-error";
+    readonly UNREADABLE_ENTRY: "unreadable-entry";
+    readonly ENCRYPTED_ENTRY: "encrypted-entry";
+    readonly ARCHIVE_LIMIT: "archive-limit";
+};
+declare const IMPORT_FORMATS: {
+    readonly GMAIL: "gmail";
+    readonly OPENEMAIL: "openemail";
+    readonly THUNDERBIRD: "thunderbird";
+    readonly MBOX: "mbox";
+    readonly EML: "eml";
+};
+declare const PROVIDER_IMPORT_RESOURCES: {
+    readonly SUPPRESSIONS: "suppressions";
+    readonly AUDIENCES: "audiences";
+    readonly CONTACTS: "contacts";
+    readonly TEMPLATES: "templates";
+    readonly WEBHOOKS: "webhooks";
+    readonly DOMAINS: "domains";
+    readonly API_KEYS: "api-keys";
+};
+declare const PROVIDER_IMPORT_STATUSES: {
+    readonly QUEUED: "queued";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+};
+declare const PROVIDER_IMPORT_DOMAIN_STATES: {
+    readonly ABSENT: "absent";
+    readonly ADDED: "added";
+    readonly VERIFIED: "verified";
+};
+
+type ImportFailureReason = (typeof IMPORT_FAILURE_REASONS)[keyof typeof IMPORT_FAILURE_REASONS];
+
+type ImportFailureResource = {
+    id: string;
+    seq: number;
+    reason: ImportFailureReason;
+    subject: string | null;
+    sender: string | null;
+    messageId: string | null;
+    source: string | null;
+    bytes: number | null;
+    detail: string | null;
+    createdAt: string;
+};
+
+type ImportFailurePage = {
+    object: 'list';
+    data: Array<ImportFailureResource>;
+    nextCursor: number | null;
+};
+
+type ImportFailuresOptions = RequestScope & {
+    after?: number;
+    limit?: number;
+};
+
+type ImportFileInfo = {
+    name: string;
+    bytes: number;
+    chunks: number;
+};
+
+type ImportProgress = (uploadedBytes: number, totalBytes: number) => void;
+
+type ImportSource = {
+    name: string;
+    data: RawBody;
+};
+
+type ImportFilesInput = {
+    addressId: string;
+    files: Array<ImportSource>;
+    options?: ImportOptions;
+    onProgress?: ImportProgress;
+};
+
+type ImportFormat = (typeof IMPORT_FORMATS)[keyof typeof IMPORT_FORMATS];
+
+type ImportListOptions = ListOptions & {
+    addressId?: string;
+};
+
+type ImportStatus = (typeof IMPORT_STATUSES)[keyof typeof IMPORT_STATUSES];
+
+type ImportResource = {
+    object: 'import';
+    id: string;
+    addressId: string | null;
+    address: string;
+    status: ImportStatus;
+    options: Required<ImportOptions>;
+    files: Array<ImportFileInfo>;
+    formats: Array<ImportFormat>;
+    chunkBytes: number;
+    totalBytes: number;
+    processedBytes: number;
+    counts: ImportCounts;
+    labelsCreated: Array<string>;
+    labelsSkipped: Array<string>;
+    lastError: string | null;
+    uploadDeleted: boolean;
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
+
+type ImportUploadResource = {
+    object: 'import_upload';
+    id: string;
+    status: ImportStatus;
+    received: Array<Array<number>>;
+};
+
+type ProviderImportCount = {
+    count: number;
+    more: boolean;
+};
+
+type ProviderImportResourceKind = (typeof PROVIDER_IMPORT_RESOURCES)[keyof typeof PROVIDER_IMPORT_RESOURCES];
+
+type ProviderImportCreate = {
+    apiKey: string;
+    resources: Array<ProviderImportResourceKind>;
+};
+
+type ProviderImportDomainState = (typeof PROVIDER_IMPORT_DOMAIN_STATES)[keyof typeof PROVIDER_IMPORT_DOMAIN_STATES];
+
+type ProviderImportListOptions = ListOptions;
+
+type ProviderImportReport = {
+    suppressions: {
+        added: number;
+        skipped: number;
+    };
+    audiences: {
+        created: number;
+        reused: number;
+        skipped: Array<string>;
+    };
+    contacts: {
+        added: number;
+        created: number;
+        unsubscribed: number;
+    };
+    templates: {
+        created: number;
+        skipped: Array<{
+            name: string;
+            reason: string;
+        }>;
+        warnings: Array<string>;
+    };
+    webhooks: {
+        created: number;
+        skipped: Array<{
+            name: string;
+            reason: string;
+        }>;
+        droppedEvents: Array<string>;
+    };
+    domains: Array<{
+        name: string;
+        state: ProviderImportDomainState;
+        records: Array<{
+            type: string;
+            name: string;
+            value: string;
+        }>;
+    }>;
+    apiKeys: Array<{
+        name: string;
+        createdAt: string | null;
+        lastUsedAt: string | null;
+    }>;
+};
+
+type ProviderImportStatus = (typeof PROVIDER_IMPORT_STATUSES)[keyof typeof PROVIDER_IMPORT_STATUSES];
+
+type ProviderImportResource = {
+    object: 'provider_import';
+    id: string;
+    provider: 'resend';
+    status: ProviderImportStatus;
+    resources: Array<ProviderImportResourceKind>;
+    step: ProviderImportResourceKind | null;
+    report: ProviderImportReport;
+    lastError: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
+
+type ProviderInventoryResource = {
+    object: 'provider_inventory';
+    provider: 'resend';
+    counts: Record<ProviderImportResourceKind, ProviderImportCount>;
+};
+
+type ApiKeyActivityListOptions = ListOptions & LogWindow;
+
+type ApiKeyEventType = (typeof API_KEY_EVENT_TYPES)[keyof typeof API_KEY_EVENT_TYPES];
+
+type ApiKeyActivityResource = {
+    object: 'api_key_event';
+    id: string;
+    keyId: string;
+    keyName: string;
+    type: ApiKeyEventType | (string & {});
+    createdAt: string;
+    actor: AuditActorResource | null;
+    detail: Record<string, unknown>;
+};
+
+type ApiKeyCreate = {
+    name: string;
+    scopes?: Array<ApiScope>;
+    roleId?: string | null;
+    addressAllowlist?: Array<string>;
+    domainAllowlist?: Array<string>;
+    expiresInMinutes?: number;
+};
+
+type ApiKeyPatch = {
+    name?: string;
+    scopes?: Array<ApiScope>;
+    addressAllowlist?: Array<string>;
+    domainAllowlist?: Array<string>;
+    enabled?: boolean;
+};
+
+type ApiKeyRequestListOptions = ApiKeyActivityListOptions & {
+    failedOnly?: boolean;
+};
+
+type ApiKeyRequestResource = {
+    object: 'api_key_request';
+    id: string;
+    keyId: string;
+    keyName: string;
+    requestId: string | null;
+    method: string;
+    path: string;
+    status: number;
+    errorCode: string | null;
+    durationMs: number;
+    ip: string | null;
+    userAgent: string | null;
+    createdAt: string;
+};
+
+type ApiKeyStatus = (typeof API_KEY_STATUSES)[keyof typeof API_KEY_STATUSES];
+
+type ApiKeyResource = {
+    object: 'api_key';
+    id: string;
+    name: string;
+    mode: ApiKeyMode;
+    maskedKey: string;
+    keyLast4: string;
+    status: ApiKeyStatus;
+    scopes: Array<ApiScope>;
+    roleId: string | null;
+    roleName: string | null;
+    addressAllowlist: Array<string> | null;
+    domainAllowlist: Array<string> | null;
+    expiresAt: string | null;
+    lastUsedAt: string | null;
+    totalUses: number;
+    rotatedAt: string | null;
+    rotationCount: number;
+    deactivatedAt: string | null;
+    revokedAt: string | null;
+    revokedReason: string | null;
+    createdAt: string;
+    createdBy: AuditActorResource | null;
+    updatedAt: string;
+    updatedBy: AuditActorResource | null;
+    lastChangeAt: string | null;
+    lastChangeType: ApiKeyEventType | (string & {}) | null;
+};
+
+type ApiKeyRevoke = {
+    reason?: string;
+};
+
+type ApiKeyWorkspaceActivityListOptions = ApiKeyActivityListOptions & {
+    keyIds?: Array<string>;
+};
+
+type ApiKeyWorkspaceRequestListOptions = ApiKeyRequestListOptions & {
+    keyIds?: Array<string>;
+};
+
+type CreatedApiKeyResource = ApiKeyResource & {
+    token: string;
 };
 
-type TranslationResource = {
-    object: 'translation';
-    language: LanguageResource;
-    detectedSourceLanguage: LanguageResource | null;
-    subject: string | null;
-    html: string | null;
-    text: string | null;
-    includeOriginal: boolean;
+type DeletedApiKeyResource = {
+    object: 'api_key';
+    id: string;
+    deleted: true;
+};
+
+type RotatedApiKeyResource = ApiKeyResource & {
+    token: string;
+    rotationCount: number;
+    rotatedAt: string;
 };
 
 type DeletedLabelResource = {
@@ -717,9 +2080,37 @@ type LabelColor = {
     textColor: string;
 };
 
+type LabelColorInput = {
+    backgroundColor: string;
+    textColor?: string;
+};
+
+declare const LABEL_COLOR_KINDS: {
+    readonly SOLID: "solid";
+    readonly GRADIENT: "gradient";
+};
+
+type LabelColorKind = (typeof LABEL_COLOR_KINDS)[keyof typeof LABEL_COLOR_KINDS];
+
+type LabelColorResource = {
+    object: 'label_color';
+    kind: LabelColorKind;
+    name: string;
+    value: string;
+    solid: string;
+    from: string | null;
+    to: string | null;
+    textColor: string;
+};
+
 type LabelInput = {
     name: string;
-    color?: LabelColor;
+    color?: LabelColorInput;
+};
+
+type LabelPatch = {
+    name?: string;
+    color?: LabelColorInput | null;
 };
 
 type LabelResource = {
@@ -728,12 +2119,9 @@ type LabelResource = {
     name: string;
     type: string;
     color: LabelColor | null;
-};
-
-type SavedLabelResource = {
-    object: 'label';
-    id: string | null;
-    name: string;
+    threadCount: number;
+    createdAt: string | null;
+    updatedAt: string | null;
 };
 
 type KeyResource = {
@@ -745,6 +2133,7 @@ type KeyResource = {
     grantedScopes: Array<ApiScope>;
     workspaceId: string;
     addressAllowlist: Array<string> | null;
+    domainAllowlist: Array<string> | null;
 };
 
 type PingResource = {
@@ -757,12 +2146,24 @@ type PingResource = {
     workspaceId: string;
 };
 
-type MemberAccess = 'member' | 'viewer';
+type RotatedKeyResource = KeyResource & {
+    token: string;
+    rotationCount: number;
+    rotatedAt: string;
+};
+
+declare const MEMBER_ACCESS_LEVELS: {
+    readonly MEMBER: "member";
+    readonly VIEWER: "viewer";
+};
+
+type MemberAccess = (typeof MEMBER_ACCESS_LEVELS)[keyof typeof MEMBER_ACCESS_LEVELS];
 
 type MemberAdd = {
     email: string;
     roleId: string;
     addressIds?: Array<string>;
+    domainIds?: Array<string>;
     access?: MemberAccess;
 };
 
@@ -777,6 +2178,31 @@ type MemberAddressResource = {
     access: MemberAccess;
 };
 
+type MemberDomainResource = {
+    domainId: string;
+    domain: string;
+    access: MemberAccess;
+};
+
+type InvitationResource = {
+    object: 'invitation';
+    id: string;
+    email: string;
+    role: {
+        id: string;
+        name: string;
+        builtin: BuiltinRole | null;
+    };
+    addresses: Array<MemberAddressResource>;
+    domains: Array<MemberDomainResource>;
+    expiresAt: string;
+    expired: boolean;
+    lastSentAt: string;
+    delivered: boolean | null;
+    deliveryError: string | null;
+    createdAt: string;
+};
+
 type MemberPatch = {
     roleId: string;
 };
@@ -787,6 +2213,7 @@ type MemberResource = {
     email: string;
     name: string | null;
     image: string | null;
+    isOwner: boolean;
     role: {
         id: string | null;
         name: string;
@@ -795,6 +2222,7 @@ type MemberResource = {
     implied: boolean;
     permissions: Array<Permission>;
     addresses: Array<MemberAddressResource>;
+    domains: Array<MemberDomainResource>;
     createdAt: string | null;
 };
 
@@ -805,6 +2233,13 @@ type RemovedMemberResource = {
     addressesRevoked: number;
 };
 
+type RevokedInvitationResource = {
+    object: 'invitation';
+    id: string;
+    email: string;
+    revoked: true;
+};
+
 type DeletedRoleResource = {
     object: 'role';
     id: string;
@@ -858,20 +2293,73 @@ type DeletedRuleResource = {
     deleted: true;
 };
 
-declare const RULE_FIELDS: readonly ["from", "from_domain", "envelope_from", "to", "cc", "bcc", "recipient", "reply_to", "delivered_to", "subject", "body", "header", "list_id", "attachment_name", "attachment_type", "has_attachment", "attachment_size", "message_size", "spam", "hour", "weekday"];
-declare const RULE_OPERATORS: readonly ["matches", "contains", "equals", "starts_with", "ends_with", "gt", "lt"];
-declare const RULE_ACTIONS: readonly ["label", "remove_label", "archive", "mark_read", "star", "spam", "trash", "forward", "reply", "block_sender", "reject"];
-
-type RuleActionType = (typeof RULE_ACTIONS)[number];
+declare const RULE_FIELDS: {
+    readonly FROM: "from";
+    readonly FROM_DOMAIN: "from_domain";
+    readonly ENVELOPE_FROM: "envelope_from";
+    readonly TO: "to";
+    readonly CC: "cc";
+    readonly BCC: "bcc";
+    readonly RECIPIENT: "recipient";
+    readonly REPLY_TO: "reply_to";
+    readonly DELIVERED_TO: "delivered_to";
+    readonly SUBJECT: "subject";
+    readonly BODY: "body";
+    readonly HEADER: "header";
+    readonly LIST_ID: "list_id";
+    readonly ATTACHMENT_NAME: "attachment_name";
+    readonly ATTACHMENT_TYPE: "attachment_type";
+    readonly HAS_ATTACHMENT: "has_attachment";
+    readonly ATTACHMENT_SIZE: "attachment_size";
+    readonly MESSAGE_SIZE: "message_size";
+    readonly SPAM: "spam";
+    readonly HOUR: "hour";
+    readonly WEEKDAY: "weekday";
+};
+declare const RULE_OPERATORS: {
+    readonly MATCHES: "matches";
+    readonly CONTAINS: "contains";
+    readonly EQUALS: "equals";
+    readonly STARTS_WITH: "starts_with";
+    readonly ENDS_WITH: "ends_with";
+    readonly GT: "gt";
+    readonly LT: "lt";
+};
+declare const RULE_ACTIONS: {
+    readonly LABEL: "label";
+    readonly REMOVE_LABEL: "remove_label";
+    readonly ARCHIVE: "archive";
+    readonly MARK_READ: "mark_read";
+    readonly STAR: "star";
+    readonly SPAM: "spam";
+    readonly TRASH: "trash";
+    readonly FORWARD: "forward";
+    readonly REPLY: "reply";
+    readonly BLOCK_SENDER: "block_sender";
+    readonly REJECT: "reject";
+};
+declare const RULE_MATCH_MODES: {
+    readonly ALL: "all";
+    readonly ANY: "any";
+};
+declare const RULE_TEST_WARNING_CODES: {
+    readonly FORWARD_UNVERIFIED: "forward_unverified";
+    readonly FIELD_UNEVALUABLE: "field_unevaluable";
+    readonly FIELD_APPROXIMATE: "field_approximate";
+    readonly FORWARD_LOOP: "forward_loop";
+    readonly BODY_ENCRYPTED: "body_encrypted";
+};
+
+type RuleActionType = (typeof RULE_ACTIONS)[keyof typeof RULE_ACTIONS];
 
 type RuleAction = {
     type: RuleActionType;
     value?: string;
 };
 
-type RuleField = (typeof RULE_FIELDS)[number];
+type RuleField = (typeof RULE_FIELDS)[keyof typeof RULE_FIELDS];
 
-type RuleOperator = (typeof RULE_OPERATORS)[number];
+type RuleOperator = (typeof RULE_OPERATORS)[keyof typeof RULE_OPERATORS];
 
 type RuleCondition = {
     field: RuleField;
@@ -887,11 +2375,13 @@ type RuleConditionInput = Partial<RuleCondition> & {
     value: string;
 };
 
+type RuleMatchMode = (typeof RULE_MATCH_MODES)[keyof typeof RULE_MATCH_MODES];
+
 type RuleCreate = {
     name: string;
     description?: string | null;
     enabled?: boolean;
-    match?: 'all' | 'any';
+    match?: RuleMatchMode;
     conditions: Array<RuleConditionInput>;
     actions: Array<RuleAction>;
     stopProcessing?: boolean;
@@ -905,7 +2395,7 @@ type RulePatch = {
     name?: string;
     description?: string | null;
     enabled?: boolean;
-    match?: 'all' | 'any';
+    match?: RuleMatchMode;
     conditions?: Array<RuleConditionInput>;
     actions?: Array<RuleAction>;
     stopProcessing?: boolean;
@@ -919,7 +2409,7 @@ type RuleResource = {
     description: string | null;
     enabled: boolean;
     position: number;
-    match: 'all' | 'any';
+    match: RuleMatchMode;
     conditions: Array<RuleCondition>;
     actions: Array<RuleAction>;
     stopProcessing: boolean;
@@ -954,6 +2444,8 @@ type RuleTestInput = {
     limit?: number;
 };
 
+type RuleTestWarningCode = (typeof RULE_TEST_WARNING_CODES)[keyof typeof RULE_TEST_WARNING_CODES];
+
 type RuleTestResource = {
     object: 'rule_test';
     ruleId: string;
@@ -967,11 +2459,15 @@ type RuleTestResource = {
         receivedAt: string | null;
     }>;
     warnings: Array<{
-        code: 'forward_unverified' | 'field_unevaluable' | 'field_approximate' | 'forward_loop' | 'body_encrypted' | (string & {});
+        code: RuleTestWarningCode | (string & {});
         value: string;
     }>;
 };
 
+type SettingsOptions = RequestScope & {
+    address?: string;
+};
+
 type SettingsPatch = {
     signature?: string;
     openEmailSignature?: boolean;
@@ -984,6 +2480,7 @@ type SettingsPatch = {
 
 type SettingsResource = {
     object: 'settings';
+    address: string | null;
     signature: string;
     openEmailSignature: boolean;
     timezone: string;
@@ -994,12 +2491,53 @@ type SettingsResource = {
     [key: string]: unknown;
 };
 
+type RemovedSuppressionResource = {
+    object: 'suppression';
+    id: string;
+    email: string;
+    deleted: true;
+};
+
+type SuppressionAdd = {
+    email: string;
+};
+
+declare const SUPPRESSION_REASONS: {
+    readonly BOUNCE: "bounce";
+    readonly COMPLAINT: "complaint";
+    readonly MANUAL: "manual";
+};
+
+type SuppressionReason = (typeof SUPPRESSION_REASONS)[keyof typeof SUPPRESSION_REASONS];
+
+type SuppressionListOptions = ListOptions & {
+    q?: string;
+    reason?: SuppressionReason;
+};
+
+type SuppressionResource = {
+    object: 'suppression';
+    id: string;
+    email: string;
+    reason: SuppressionReason;
+    detail: string | null;
+    removable: boolean;
+    createdAt: string;
+};
+
 type DeletedTemplateResource = {
     object: 'template';
     id: string;
     deleted: true;
 };
 
+type DeletedTemplateVersionResource = {
+    object: 'template_version';
+    templateId: string;
+    version: number;
+    deleted: true;
+};
+
 type SentTemplateEmailResource = SentEmailResource & {
     template: {
         id: string;
@@ -1007,9 +2545,155 @@ type SentTemplateEmailResource = SentEmailResource & {
     };
 };
 
-type TemplateEngine = 'blocks' | 'html';
+type TemplateAnalyticsOptions = RequestScope & {
+    days?: number;
+    minutes?: number;
+    grain?: TrackingGrain;
+    offsetMinutes?: number;
+};
+
+type TemplateAnalyticsResource = {
+    object: 'template_analytics';
+    templateId: string;
+    sends: number;
+    matched: number;
+    trackedForOpens: number;
+    trackedForClicks: number;
+    opened: number;
+    clicked: number;
+    openRate: number;
+    clickRate: number;
+    totalOpens: number;
+    totalClicks: number;
+    bySource: Array<{
+        source: string;
+        sends: number;
+    }>;
+    byDay: Array<{
+        day: string;
+        sent: number;
+        trackedForOpens: number;
+        trackedForClicks: number;
+        opened: number;
+        clicked: number;
+    }>;
+    byVersion: Array<{
+        version: number;
+        sends: number;
+        trackedForOpens: number;
+        trackedForClicks: number;
+        opened: number;
+        clicked: number;
+    }>;
+    recent: Array<{
+        id: string;
+        version: number;
+        source: string;
+        createdAt: string;
+        matched: boolean;
+        opens: boolean;
+        clicks: boolean;
+        openCount: number;
+        clickCount: number;
+    }>;
+    lifetime: {
+        sends: number;
+        testSends: number;
+        firstAt: string | null;
+        lastAt: string | null;
+    };
+};
+
+declare const TEMPLATE_ENGINES: {
+    readonly BLOCKS: "blocks";
+    readonly HTML: "html";
+};
+declare const TEMPLATE_STATUSES: {
+    readonly DRAFT: "draft";
+    readonly ACTIVE: "active";
+    readonly ARCHIVED: "archived";
+};
+declare const TEMPLATE_CATEGORIES: {
+    readonly ACCOUNT: "account";
+    readonly COMMERCE: "commerce";
+    readonly NOTIFY: "notify";
+    readonly MARKETING: "marketing";
+};
+declare const TEMPLATE_SORTS: {
+    readonly UPDATED_NEWEST: "updated-newest";
+    readonly UPDATED_OLDEST: "updated-oldest";
+    readonly CREATED_NEWEST: "created-newest";
+    readonly CREATED_OLDEST: "created-oldest";
+    readonly NAME: "name";
+    readonly NAME_REVERSED: "name-reversed";
+};
+declare const TEMPLATE_BLOCK_KINDS: {
+    readonly SECTION: "Section";
+    readonly ROW: "Row";
+    readonly COLUMN: "Column";
+    readonly CONTAINER: "Container";
+    readonly TEXT: "Text";
+    readonly HEADING: "Heading";
+    readonly BUTTON: "Button";
+    readonly LINK: "Link";
+    readonly IMG: "Img";
+    readonly HR: "Hr";
+    readonly MARKDOWN: "Markdown";
+    readonly CODE_BLOCK: "CodeBlock";
+    readonly CODE_INLINE: "CodeInline";
+};
+declare const TEMPLATE_FONT_FORMATS: {
+    readonly WOFF2: "woff2";
+    readonly WOFF: "woff";
+    readonly TRUETYPE: "truetype";
+    readonly OPENTYPE: "opentype";
+    readonly EMBEDDED_OPENTYPE: "embedded-opentype";
+    readonly SVG: "svg";
+};
+declare const TEMPLATE_FONT_STYLES: {
+    readonly NORMAL: "normal";
+    readonly ITALIC: "italic";
+    readonly OBLIQUE: "oblique";
+};
+declare const TEMPLATE_VALUE_KINDS: {
+    readonly TEXT: "text";
+    readonly URL: "url";
+    readonly IMAGE: "image";
+};
+declare const TEMPLATE_VERSION_STATES: {
+    readonly DRAFT: "draft";
+    readonly PUBLISHED: "published";
+};
+declare const TEMPLATE_PREVIEW_WARNING_CODES: {
+    readonly UNFILLED_PLACEHOLDER: "unfilled_placeholder";
+};
+
+type TemplateBlockKind = (typeof TEMPLATE_BLOCK_KINDS)[keyof typeof TEMPLATE_BLOCK_KINDS];
+
+type TemplateBlock = {
+    kind: TemplateBlockKind;
+    children?: Array<TemplateBlock>;
+    [field: string]: unknown;
+};
+
+type TemplateCategory = (typeof TEMPLATE_CATEGORIES)[keyof typeof TEMPLATE_CATEGORIES];
+
+type TemplateFontFormat = (typeof TEMPLATE_FONT_FORMATS)[keyof typeof TEMPLATE_FONT_FORMATS];
+
+type TemplateFontStyle = (typeof TEMPLATE_FONT_STYLES)[keyof typeof TEMPLATE_FONT_STYLES];
+
+type TemplateFont = {
+    fontFamily: string;
+    fallbackFontFamily: string;
+    webFont?: {
+        url: string;
+        format: TemplateFontFormat;
+    };
+    fontWeight?: string | number;
+    fontStyle?: TemplateFontStyle;
+};
 
-type TemplateValueKind = 'text' | 'url' | 'image';
+type TemplateValueKind = (typeof TEMPLATE_VALUE_KINDS)[keyof typeof TEMPLATE_VALUE_KINDS];
 
 type TemplateProp = {
     key: string;
@@ -1026,10 +2710,23 @@ type TemplateSlot = {
     default: string;
 };
 
+type TemplateDocument = {
+    body: Array<TemplateBlock>;
+    preview?: string;
+    tailwind?: boolean;
+    fonts?: Array<TemplateFont>;
+    style?: Record<string, string | number>;
+    slots?: Array<TemplateSlot>;
+    props?: Array<TemplateProp>;
+    [setting: string]: unknown;
+};
+
+type TemplateEngine = (typeof TEMPLATE_ENGINES)[keyof typeof TEMPLATE_ENGINES];
+
 type TemplateContent = {
     engine?: TemplateEngine;
     subject?: string;
-    document?: Record<string, unknown>;
+    document?: TemplateDocument;
     html?: string;
     slots?: Array<Partial<TemplateSlot> & {
         key: string;
@@ -1039,14 +2736,21 @@ type TemplateContent = {
     }>;
 };
 
+type TemplateContentSource = {
+    starter?: string;
+    fromTemplateId?: string;
+    expectedVersion?: number;
+};
+
 type TemplateCreate = TemplateContent & {
     name: string;
     slug?: string;
     description?: string | null;
     publish?: boolean;
+    starter?: string;
 };
 
-type TemplateStatus = 'draft' | 'active' | 'archived';
+type TemplateStatus = (typeof TEMPLATE_STATUSES)[keyof typeof TEMPLATE_STATUSES];
 
 type TemplateResource = {
     object: 'template';
@@ -1065,17 +2769,19 @@ type TemplateResource = {
     updatedAt: string;
 };
 
+type TemplateVersionState = (typeof TEMPLATE_VERSION_STATES)[keyof typeof TEMPLATE_VERSION_STATES];
+
 type TemplateVersionResource = {
     object: 'template_version';
     id: string;
     templateId: string;
     version: number;
-    state: 'draft' | 'published';
+    state: TemplateVersionState;
     engine: TemplateEngine;
     subject: string;
     slots: Array<TemplateSlot>;
     props: Array<TemplateProp>;
-    document?: Record<string, unknown> | null;
+    document?: TemplateDocument | null;
     html?: string | null;
     publishedAt: string | null;
     createdAt: string;
@@ -1086,14 +2792,33 @@ type TemplateDetailResource = TemplateResource & {
     latest: TemplateVersionResource;
 };
 
+type TemplateDuplicate = {
+    name?: string;
+};
+
+type TemplateFontResource = {
+    object: 'template_font';
+    family: string;
+    fallback: string;
+    stack: string;
+    weight: string;
+    format: TemplateFontFormat;
+    url: string;
+};
+
+type TemplateSort = (typeof TEMPLATE_SORTS)[keyof typeof TEMPLATE_SORTS];
+
 type TemplateListOptions = ListOptions & {
     status?: TemplateStatus;
+    search?: string;
+    sort?: TemplateSort;
 };
 
 type TemplatePatch = TemplateContent & {
     name?: string;
+    slug?: string;
     description?: string | null;
-    status?: 'active' | 'archived';
+    status?: typeof TEMPLATE_STATUSES.ACTIVE | typeof TEMPLATE_STATUSES.ARCHIVED;
     expectedVersion?: number;
 };
 
@@ -1103,6 +2828,8 @@ type TemplatePreviewInput = {
     slots?: Record<string, unknown>;
 };
 
+type TemplatePreviewWarningCode = (typeof TEMPLATE_PREVIEW_WARNING_CODES)[keyof typeof TEMPLATE_PREVIEW_WARNING_CODES];
+
 type TemplatePreviewResource = {
     object: 'template_preview';
     templateId: string;
@@ -1111,11 +2838,38 @@ type TemplatePreviewResource = {
     html: string;
     text: string;
     warnings: Array<{
-        code: 'unfilled_placeholder' | (string & {});
+        code: TemplatePreviewWarningCode | (string & {});
+        key: string;
+    }>;
+};
+
+type TemplateRenderInput = TemplateContent & {
+    mark?: boolean;
+    values?: {
+        props?: Record<string, unknown>;
+        slots?: Record<string, unknown>;
+    };
+};
+
+type TemplateRenderResource = {
+    object: 'template_render';
+    subject: string;
+    html: string;
+    text: string;
+    warnings: Array<{
+        code: TemplatePreviewWarningCode | (string & {});
         key: string;
     }>;
 };
 
+type TemplateRestoreInput = {
+    expectedVersion?: number;
+};
+
+type TemplateRestoredResource = TemplateDetailResource & {
+    restoredFrom: number;
+};
+
 type TemplateSend = {
     from: RecipientInput;
     to: RecipientInput | Array<RecipientInput>;
@@ -1133,6 +2887,55 @@ type TemplateSend = {
     translate?: SendTranslateOptions;
 };
 
+type TemplateSendListOptions = TemplateAnalyticsOptions & {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    source?: string;
+    version?: number;
+    opened?: boolean;
+    clicked?: boolean;
+    tracked?: boolean;
+};
+
+type TemplateSendResource = {
+    object: 'template_send';
+    id: string;
+    version: number;
+    source: string;
+    subject: string;
+    createdAt: string;
+    recipients: Array<string>;
+    matched: boolean;
+    opens: boolean;
+    clicks: boolean;
+    openCount: number;
+    clickCount: number;
+};
+
+type TemplateSendsResource = {
+    items: Array<TemplateSendResource>;
+    total: number;
+    page: number;
+    pageSize: number;
+};
+
+type TemplateStarterResource = {
+    object: 'template_starter';
+    slug: string;
+    name: string;
+    description: string;
+    category: TemplateCategory;
+    subject: string;
+    slots: Array<TemplateSlot>;
+    props: Array<TemplateProp>;
+};
+
+type TemplateStarterDetailResource = TemplateStarterResource & {
+    document: TemplateDocument;
+    preview: string;
+};
+
 type TempInboxResource = {
     object: 'temp_inbox';
     id: string;
@@ -1197,10 +3000,13 @@ type TempMessageDetailResource = TempMessageResource & {
 
 type TempMessageListOptions = InboxScope & {
     limit?: number;
+    cursor?: string;
 };
 
 type TempMessagesResource = {
     items: Array<TempMessageResource>;
+    hasMore: boolean;
+    nextCursor: string | null;
     expiresAt: string;
 };
 
@@ -1210,10 +3016,23 @@ type SnoozedThreadResource = {
     snoozedUntil: string | null;
 };
 
+declare const THREAD_SORTS: {
+    readonly NEWEST: "newest";
+    readonly OLDEST: "oldest";
+    readonly SENDER: "sender";
+    readonly SUBJECT: "subject";
+};
+
+type ThreadSort = (typeof THREAD_SORTS)[keyof typeof THREAD_SORTS];
+
 type ThreadListOptions = ListOptions & {
     folder?: string;
     query?: string;
     labelIds?: string | Array<string>;
+    sort?: ThreadSort;
+    dateFrom?: Date | string;
+    dateTo?: Date | string;
+    fromContacts?: boolean;
 };
 
 type ThreadPatch = {
@@ -1277,20 +3096,16 @@ type TrackingClickResource = Omit<TrackingOpenResource, 'object'> & {
     url: string;
 };
 
-type TrackingGrain = 'minute' | 'hour' | 'day';
-
-type TrackingHitOptions = RequestScope & {
+type TrackingHitOptions = ListOptions & {
     includeMachine?: boolean;
-    limit?: number;
 };
 
-type TrackingListOptions = RequestScope & {
+type TrackingListOptions = ListOptions & {
     opened?: boolean;
     clicked?: boolean;
     days?: number;
     minutes?: number;
     grain?: TrackingGrain;
-    limit?: number;
 };
 
 type TrackingResource = TrackingSummary & {
@@ -1323,7 +3138,6 @@ type TrackingStatsResource = {
         opened: number;
         clicked: number;
     }>;
-    hitsKnownFrom: string;
     topLinks: Array<{
         url: string;
         label: string | null;
@@ -1339,9 +3153,54 @@ type TrackingStatsResource = {
     }>;
 };
 
-declare const WEBHOOK_EVENTS: readonly ["email.received", "email.sent", "email.failed", "email.cancelled", "email.scheduled", "email.queued", "email.bounced", "email.complained", "email.opened", "email.clicked"];
-
-type WebhookEvent = (typeof WEBHOOK_EVENTS)[number];
+declare const WEBHOOK_EVENTS: {
+    readonly EMAIL_RECEIVED: "email.received";
+    readonly EMAIL_REPLIED: "email.replied";
+    readonly EMAIL_SENT: "email.sent";
+    readonly EMAIL_FAILED: "email.failed";
+    readonly EMAIL_CANCELLED: "email.cancelled";
+    readonly EMAIL_SCHEDULED: "email.scheduled";
+    readonly EMAIL_QUEUED: "email.queued";
+    readonly EMAIL_DELIVERED: "email.delivered";
+    readonly EMAIL_DELIVERY_DELAYED: "email.delivery_delayed";
+    readonly EMAIL_BOUNCED: "email.bounced";
+    readonly EMAIL_COMPLAINED: "email.complained";
+    readonly EMAIL_SUPPRESSED: "email.suppressed";
+    readonly EMAIL_OPENED: "email.opened";
+    readonly EMAIL_CLICKED: "email.clicked";
+    readonly EMAIL_DOWNLOADED: "email.downloaded";
+    readonly DOMAIN_VERIFIED: "domain.verified";
+    readonly DOMAIN_SENDING_CHANGED: "domain.sending_changed";
+    readonly DOMAIN_DELETED: "domain.deleted";
+    readonly SUPPRESSION_ADDED: "suppression.added";
+    readonly SUPPRESSION_REMOVED: "suppression.removed";
+};
+declare const WEBHOOK_DELIVERY_STATUSES: {
+    readonly DELIVERED: "delivered";
+    readonly FAILED: "failed";
+};
+declare const WEBHOOK_CHANGE_TYPES: {
+    readonly CREATED: "created";
+    readonly UPDATED: "updated";
+    readonly ENABLED: "enabled";
+    readonly DISABLED: "disabled";
+    readonly AUTO_DISABLED: "auto_disabled";
+    readonly SECRET_ROTATED: "secret_rotated";
+    readonly TESTED: "tested";
+    readonly REPLAYED: "replayed";
+    readonly REMOVED: "removed";
+};
+declare const WEBHOOK_REPLAY_ERROR_CODES: {
+    readonly RESOURCE_NOT_FOUND: "resource_not_found";
+    readonly WEBHOOK_DISABLED: "webhook_disabled";
+    readonly EVENT_NOT_SUBSCRIBED: "event_not_subscribed";
+    readonly EVENT_OUT_OF_SCOPE: "event_out_of_scope";
+    readonly DELIVERY_NOT_REPLAYABLE: "delivery_not_replayable";
+    readonly RETRY_IN_PROGRESS: "retry_in_progress";
+    readonly REPLAY_IN_PROGRESS: "replay_in_progress";
+};
+
+type WebhookEvent = (typeof WEBHOOK_EVENTS)[keyof typeof WEBHOOK_EVENTS];
 
 type WebhookResource = {
     object: 'webhook';
@@ -1353,6 +3212,8 @@ type WebhookResource = {
     disabledAt: string | null;
     disabledReason: string | null;
     consecutiveFailures: number;
+    addressAllowlist: Array<string>;
+    domainAllowlist: Array<string>;
     lastDeliveryAt: string | null;
     createdAt: string;
 };
@@ -1394,6 +3255,19 @@ type EmailClickedData = Omit<EmailOpenedData, 'openCount' | 'openedAt'> & {
     clickedAt: string;
 };
 
+type EmailDownloadedData = Omit<EmailOpenedData, 'recipient' | 'attributed' | 'openCount' | 'openedAt'> & {
+    recipient: null;
+    attributed: false;
+    shareId: string;
+    fileId: string | null;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    url: string;
+    downloadCount: number;
+    downloadedAt: string;
+};
+
 type WebhookSignatureHeaders = Record<string, string | Array<string> | undefined>;
 
 type VerifyWebhookProps = {
@@ -1403,21 +3277,86 @@ type VerifyWebhookProps = {
     toleranceSeconds?: number;
 };
 
+type WebhookActivityListOptions = ListOptions & LogWindow;
+
+type WebhookChangeType = (typeof WEBHOOK_CHANGE_TYPES)[keyof typeof WEBHOOK_CHANGE_TYPES];
+
+type WebhookActivityResource = {
+    object: 'webhook_event';
+    id: string;
+    endpointId: string;
+    endpointLabel: string;
+    type: WebhookChangeType | (string & {});
+    createdAt: string;
+    actor: AuditActorResource | null;
+    detail: Record<string, unknown>;
+};
+
 type WebhookCreate = {
     url: string;
     eventTypes?: Array<WebhookEvent>;
     description?: string;
+    addressAllowlist?: Array<string>;
+    domainAllowlist?: Array<string>;
+};
+
+type WebhookDeliveryStatus = (typeof WEBHOOK_DELIVERY_STATUSES)[keyof typeof WEBHOOK_DELIVERY_STATUSES];
+
+type WebhookDeliveryAttempt = {
+    id: string;
+    attempt: number | null;
+    maxAttempts: number | null;
+    status: WebhookDeliveryStatus | (string & {});
+    responseCode: number | null;
+    durationMs: number | null;
+    error: string | null;
+    createdAt: string;
+};
+
+type WebhookPayload<T = Record<string, unknown>> = {
+    id: string;
+    type: WebhookEvent | (string & {});
+    createdAt: string;
+    data: T;
+};
+
+type WebhookReplayErrorCode = (typeof WEBHOOK_REPLAY_ERROR_CODES)[keyof typeof WEBHOOK_REPLAY_ERROR_CODES];
+
+type WebhookReplayRefusal = {
+    code: WebhookReplayErrorCode | (string & {});
+    message: string;
+};
+
+type WebhookDeliveryDetailResource = WebhookDeliveryAttempt & {
+    object: 'webhook_delivery';
+    endpointId: string;
+    eventType: WebhookEvent | (string & {});
+    eventId: string | null;
+    nextAttemptAt: string | null;
+    payload: WebhookPayload | null;
+    responseBody: string | null;
+    attempts: Array<WebhookDeliveryAttempt>;
+    replayRefusal: WebhookReplayRefusal | null;
+};
+
+type WebhookDeliveryListOptions = ListOptions & LogWindow & {
+    status?: WebhookDeliveryStatus;
 };
 
 type WebhookDeliveryResource = {
     object: 'webhook_delivery';
     id: string;
+    endpointId: string;
     eventType: WebhookEvent | (string & {});
-    status: 'delivered' | 'failed' | (string & {});
+    eventId: string | null;
+    status: WebhookDeliveryStatus | (string & {});
     responseCode: number | null;
     durationMs: number | null;
+    attempt: number | null;
+    maxAttempts: number | null;
     error: string | null;
     createdAt: string;
+    nextAttemptAt: string | null;
 };
 
 type WebhookPatch = {
@@ -1425,13 +3364,23 @@ type WebhookPatch = {
     eventTypes?: Array<WebhookEvent>;
     description?: string | null;
     enabled?: boolean;
+    addressAllowlist?: Array<string>;
+    domainAllowlist?: Array<string>;
 };
 
-type WebhookPayload<T = Record<string, unknown>> = {
+type WebhookReplayResource = {
+    object: 'webhook_replay';
     id: string;
-    type: WebhookEvent | (string & {});
-    createdAt: string;
-    data: T;
+    endpointId: string;
+    replayOf: string;
+    eventId: string;
+    eventType: WebhookEvent | (string & {});
+    delivery: {
+        status: WebhookDeliveryStatus | (string & {});
+        responseCode: number | null;
+        durationMs: number | null;
+        error: string | null;
+    };
 };
 
 type WebhookTestResource = {
@@ -1445,12 +3394,20 @@ type WebhookTestResource = {
     } | null;
 };
 
+type WebhookWorkspaceActivityListOptions = WebhookActivityListOptions & {
+    endpointIds?: Array<string>;
+};
+
+type WebhookWorkspaceDeliveryListOptions = WebhookDeliveryListOptions & {
+    endpointIds?: Array<string>;
+};
+
 declare class Transport {
     #private;
     readonly baseUrl: string;
     private readonly fetchImpl;
     private readonly maxRetries;
-    private readonly timeoutMs;
+    readonly timeoutMs: number;
     private readonly userAgent;
     private readonly headers;
     constructor(options: TransportOptions & {
@@ -1515,6 +3472,8 @@ declare const createTempMail: (options?: TempMailOptions) => ReturnType<(transpo
     extend: (inboxId: string, options?: InboxScope) => Promise<TempInboxResource>;
     delete: (inboxId: string, options?: InboxScope) => Promise<DeletedTempInboxResource>;
     listMessages: (inboxId: string, options?: TempMessageListOptions) => Promise<TempMessagesResource>;
+    listAllMessages: (inboxId: string, options?: TempMessageListOptions) => Promise<Array<TempMessageResource>>;
+    iterateMessages: (inboxId: string, options?: TempMessageListOptions) => AsyncGenerator<TempMessageResource, void, undefined>;
     getMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<TempMessageDetailResource>;
     deleteMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<DeletedTempMessageResource>;
     listAttachments: (inboxId: string, messageId: string, options?: InboxScope) => Promise<Array<AttachmentResource>>;
@@ -1527,5 +3486,5 @@ declare const resolveLanguage: (input: string | null | undefined) => LanguageRes
 declare const languageByCode: (code: string | null | undefined) => LanguageResource | undefined;
 declare const isRtlLanguage: (code: string | null | undefined) => boolean;
 
-export { API_SCOPES, ERROR_TYPES, LANGUAGES, MESSAGE_ENCRYPTION_FORMATS, OpenEmail, OpenEmailApiError, OpenEmailNetworkError, PAGE_LIMITS, RULE_ACTIONS, RULE_FIELDS, RULE_OPERATORS, VERSION, WEBHOOK_EVENTS, WEBHOOK_SIGNATURE_HEADERS, createClient, createOpenEmail, createTempMail, OpenEmail as default, getClient, init, isApiKey, isRtlLanguage, isSealed, languageByCode, openemail, resetClient, resolveLanguage, toBase64, verifyWebhookSignature };
-export type { AddressBookResource, AddressResource, ApiErrorPayload, ApiErrorProps, ApiKeyMode, ApiScope, AttachmentInput, AttachmentResource, BatchItemResource, BatchResultResource, BuiltinRole, CalendarAttendeeResource, CalendarEventResource, CalendarOccurrenceResource, CalendarRangeOptions, ClientOptions, ContactListOptions, ContactResource, CreatedTempInboxResource, CreatedWebhookResource, DeletedDraftResource, DeletedLabelResource, DeletedRoleResource, DeletedRuleResource, DeletedTempInboxResource, DeletedTempMessageResource, DeletedTemplateResource, DeletedWebhookResource, DomainDetailResource, DomainResource, DomainSendingState, DraftInput, DraftListOptions, DraftResource, DraftSummaryResource, EmailClickedData, EmailEventResource, EmailListOptions, EmailOpenedData, EmailRecipientResource, EmailResource, EmailSend, EmailSource, EmailStatus, EmailTrackingSummary, EmailTranslate, EmailTranslationResource, EmailTransport, ErrorType, FetchLike, HitKind, InboxScope, KeyResource, LabelColor, LabelInput, LabelResource, LanguageResource, ListOptions, MemberAccess, MemberAdd, MemberAddressGrant, MemberAddressResource, MemberPatch, MemberResource, MessageEncryption, MessageEncryptionFormat, MessageResource, Page, Permission, PermissionResource, PingResource, RecipientInput, RecipientStatus, RemovedMemberResource, RequestOptions, RequestScope, RoleCreate, RoleDeleteOptions, RolePatch, RoleResource, RuleAction, RuleActionType, RuleCondition, RuleConditionInput, RuleCreate, RuleField, RuleListOptions, RuleOperator, RulePatch, RuleResource, RuleRunListOptions, RuleRunResource, RuleTestInput, RuleTestResource, SavedDraftResource, SavedLabelResource, SendScope, SendTranslateOptions, SendableDomainResource, SentEmailResource, SentTemplateEmailResource, SettingsPatch, SettingsResource, SnoozedThreadResource, TempDomainResource, TempInboxCreate, TempInboxResource, TempMailOptions, TempMessageDetailResource, TempMessageListOptions, TempMessageResource, TempMessagesResource, TemplateContent, TemplateCreate, TemplateDetailResource, TemplateEngine, TemplateListOptions, TemplatePatch, TemplatePreviewInput, TemplatePreviewResource, TemplateProp, TemplateResource, TemplateSend, TemplateSlot, TemplateStatus, TemplateValueKind, TemplateVersionResource, ThreadListOptions, ThreadPatch, ThreadResource, ThreadSummaryResource, TrackingClickResource, TrackingGrain, TrackingHitOptions, TrackingLinkResource, TrackingListOptions, TrackingOpenResource, TrackingRecipientResource, TrackingRequest, TrackingResource, TrackingStatsOptions, TrackingStatsResource, TrackingSummary, TranslateOptions, TranslationResource, TransportOptions, TrashedThreadResource, UpdatedThreadResource, VerifyWebhookProps, WebhookCreate, WebhookDeliveryResource, WebhookEvent, WebhookPatch, WebhookPayload, WebhookResource, WebhookSignatureHeaders, WebhookTestResource };
+export { API_SCOPES, BROADCAST_STATUSES, CONTACT_BLOCK_LISTS, CONTACT_PHOTO_TYPES, CONTACT_THREAD_SORTS, ERROR_TYPES, FILE_DIRECTIONS, FILE_KINDS, FILE_SORTS, FILE_USAGES, LANGUAGES, MESSAGE_ENCRYPTION_FORMATS, OpenEmail, OpenEmailApiError, OpenEmailNetworkError, PAGE_LIMITS, PEOPLE_SORTS, PROVIDER_IMPORT_DOMAIN_STATES, PROVIDER_IMPORT_RESOURCES, PROVIDER_IMPORT_STATUSES, RULE_ACTIONS, RULE_FIELDS, RULE_OPERATORS, SUPPRESSION_REASONS, THREAD_SORTS, VERSION, WEBHOOK_EVENTS, WEBHOOK_REPLAY_ERROR_CODES, WEBHOOK_SIGNATURE_HEADERS, createClient, createOpenEmail, createTempMail, OpenEmail as default, getClient, init, isApiKey, isRtlLanguage, isSealed, languageByCode, openemail, resetClient, resolveLanguage, toBase64, verifyWebhookSignature };
+export type { AddressBookPage, AddressBookResource, AddressResource, ApiErrorPayload, ApiErrorProps, ApiKeyActivityListOptions, ApiKeyActivityResource, ApiKeyCreate, ApiKeyEventType, ApiKeyMode, ApiKeyPatch, ApiKeyRequestListOptions, ApiKeyRequestResource, ApiKeyResource, ApiKeyRevoke, ApiKeyStatus, ApiKeyWorkspaceActivityListOptions, ApiKeyWorkspaceRequestListOptions, ApiScope, AttachmentDeliveryMode, AttachmentInput, AttachmentResource, AudienceBatchAddResource, AudienceBatchRemoveResource, AudienceBuiltin, AudienceContactAdd, AudienceContactListOptions, AudienceContactResource, AudienceContactsBatch, AudienceCreate, AudienceGrowthBucket, AudienceGrowthOptions, AudienceGrowthResource, AudienceGrowthSeries, AudienceGrowthTotals, AudienceImport, AudienceImportResource, AudienceImportRow, AudienceListOptions, AudienceMemberResource, AudienceMemberSort, AudiencePatch, AudienceResource, AuditActorKind, AuditActorResource, BatchItemResource, BatchResultResource, BroadcastCounts, BroadcastCreate, BroadcastListOptions, BroadcastPreviewInput, BroadcastPreviewResource, BroadcastResource, BroadcastStatus, BuiltinRole, CalendarAttendeeResource, CalendarEventResource, CalendarOccurrenceResource, CalendarRangeOptions, ClientOptions, ConsolePermission, ContactActivityBucket, ContactActivityOptions, ContactActivityResource, ContactActivityTotals, ContactAudienceResource, ContactAudiencesSet, ContactBatchDeleteResource, ContactBlockList, ContactBlockResource, ContactBlockRule, ContactCreate, ContactDetailResource, ContactListOptions, ContactPatch, ContactPhotoOptions, ContactPhotoType, ContactReplyTime, ContactResource, ContactSave, ContactSource, ContactThreadListOptions, ContactThreadResource, ContactThreadSort, CreatedApiKeyResource, CreatedTempInboxResource, CreatedWebhookResource, DeletedApiKeyResource, DeletedAudienceResource, DeletedContactResource, DeletedDraftResource, DeletedFileResource, DeletedLabelResource, DeletedRoleResource, DeletedRuleResource, DeletedTempInboxResource, DeletedTempMessageResource, DeletedTemplateResource, DeletedTemplateVersionResource, DeletedWebhookResource, DomainDetailResource, DomainPatch, DomainResource, DomainSendingState, DomainStorage, DomainStorageState, DomainTracking, DomainTrackingState, DraftInput, DraftListOptions, DraftResource, DraftSummaryResource, EmailClickedData, EmailDownloadedData, EmailEventResource, EmailListOptions, EmailOpenedData, EmailRecipientResource, EmailResource, EmailSend, EmailSource, EmailStatus, EmailTrackingSummary, EmailTranslate, EmailTranslationResource, EmailTransport, EmptiedAudienceResource, ErrorType, FetchLike, FileAddressCount, FileBatchDeleteResource, FileCount, FileDayCount, FileDirection, FileKept, FileKind, FileLinkCount, FileLinkResource, FileListOptions, FileResource, FileSort, FileStatsResource, FileTypeCount, FileUploadOptions, FileUsage, HitKind, ImportChunkResource, ImportCounts, ImportCreate, ImportFailurePage, ImportFailureReason, ImportFailureResource, ImportFailuresOptions, ImportFileDescriptor, ImportFileInfo, ImportFilesInput, ImportFormat, ImportListOptions, ImportOptions, ImportProgress, ImportResource, ImportSource, ImportStatus, ImportUploadResource, InboxScope, InlineAttachmentInput, InvitationResource, KeyResource, LabelColor, LabelColorInput, LabelColorKind, LabelColorResource, LabelInput, LabelPatch, LabelResource, LanguageResource, ListOptions, LogWindow, MemberAccess, MemberAdd, MemberAddressGrant, MemberAddressResource, MemberDomainResource, MemberPatch, MemberResource, MessageEncryption, MessageEncryptionFormat, MessageEncryptionPartRole, MessageResource, Page, PeoplePage, PeopleSort, Permission, PermissionResource, PersonListOptions, PersonResource, PingResource, ProviderImportCount, ProviderImportCreate, ProviderImportDomainState, ProviderImportListOptions, ProviderImportReport, ProviderImportResource, ProviderImportResourceKind, ProviderImportStatus, ProviderInventoryResource, RawBody, RecipientInput, RecipientKind, RecipientStatus, RemovedAudienceContactResource, RemovedMemberResource, RemovedSuppressionResource, RequestOptions, RequestScope, RevokedInvitationResource, RoleCreate, RoleDeleteOptions, RolePatch, RoleResource, RotatedApiKeyResource, RotatedKeyResource, RuleAction, RuleActionType, RuleCondition, RuleConditionInput, RuleCreate, RuleField, RuleListOptions, RuleMatchMode, RuleOperator, RulePatch, RuleResource, RuleRunListOptions, RuleRunResource, RuleTestInput, RuleTestResource, RuleTestWarningCode, SavedDraftResource, SendScope, SendTranslateOptions, SendableDomainResource, SentBroadcastResource, SentEmailResource, SentTemplateEmailResource, SettingsOptions, SettingsPatch, SettingsResource, SnoozedThreadResource, StoredAttachmentInput, SuppressionAdd, SuppressionListOptions, SuppressionReason, SuppressionResource, TempDomainResource, TempInboxCreate, TempInboxResource, TempMailOptions, TempMessageDetailResource, TempMessageListOptions, TempMessageResource, TempMessagesResource, TemplateAnalyticsOptions, TemplateAnalyticsResource, TemplateBlock, TemplateBlockKind, TemplateCategory, TemplateContent, TemplateContentSource, TemplateCreate, TemplateDetailResource, TemplateDocument, TemplateDuplicate, TemplateEngine, TemplateFont, TemplateFontFormat, TemplateFontResource, TemplateFontStyle, TemplateListOptions, TemplatePatch, TemplatePreviewInput, TemplatePreviewResource, TemplatePreviewWarningCode, TemplateProp, TemplateRenderInput, TemplateRenderResource, TemplateResource, TemplateRestoreInput, TemplateRestoredResource, TemplateSend, TemplateSendListOptions, TemplateSendResource, TemplateSendsResource, TemplateSlot, TemplateSort, TemplateStarterDetailResource, TemplateStarterResource, TemplateStatus, TemplateValueKind, TemplateVersionResource, TemplateVersionState, ThreadListOptions, ThreadPatch, ThreadResource, ThreadSort, ThreadSummaryResource, TrackingClickResource, TrackingGrain, TrackingHitOptions, TrackingLinkResource, TrackingListOptions, TrackingOpenResource, TrackingRecipientResource, TrackingRequest, TrackingResource, TrackingStatsOptions, TrackingStatsResource, TrackingSummary, TranslateOptions, TranslationResource, TransportOptions, TrashedThreadResource, UpdatedThreadResource, VerifyWebhookProps, WebhookActivityListOptions, WebhookActivityResource, WebhookChangeType, WebhookCreate, WebhookDeliveryAttempt, WebhookDeliveryDetailResource, WebhookDeliveryListOptions, WebhookDeliveryResource, WebhookDeliveryStatus, WebhookEvent, WebhookPatch, WebhookPayload, WebhookReplayErrorCode, WebhookReplayRefusal, WebhookReplayResource, WebhookResource, WebhookSignatureHeaders, WebhookTestResource, WebhookWorkspaceActivityListOptions, WebhookWorkspaceDeliveryListOptions };