@openemail/sdk 0.0.1 → 0.0.3

package/index.cjs

@@ -2,7 +2,16 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "0.0.1";
+const BROADCAST_STATUSES = {
+    SCHEDULED: 'scheduled',
+    QUEUED: 'queued',
+    SENDING: 'sending',
+    SENT: 'sent',
+    CANCELLED: 'cancelled',
+    FAILED: 'failed'
+};
+
+var version = "0.0.3";
 
 const BUILD_BASE_URL = 'https://api.openemail.uk';
 
@@ -10,6 +19,7 @@ const DEFAULTS = {
     BASE_URL: BUILD_BASE_URL,
     MAX_RETRIES: 2,
     TIMEOUT_MS: 30_000,
+    UPLOAD_TIMEOUT_MS: 600_000,
     USER_AGENT: `openemail-sdk/${version}`
 };
 const BROWSER_REFUSAL = [
@@ -42,46 +52,63 @@ const CLIENT_MESSAGES = {
     BASE_URL_SHAPE: 'is not a usable base URL. Pass an origin such as "https://api.openemail.uk", or the http origin of a server you run yourself.',
     NO_FETCH: 'No global fetch is available. Pass one as { fetch }, or run on Node 20+, Bun, Deno, Cloudflare Workers or a browser.',
     EMPTY_SEGMENT: 'An id must not be empty.',
+    FILENAME_REQUIRED: 'A file name is required. Pass it as { filename }, the name the file is stored and downloaded under.',
     DOT_SEGMENT: 'is not a usable id: a path segment made only of dots is removed by URL parsers, so the request would reach a different endpoint.'
 };
 
-const MESSAGE_ENCRYPTION_FORMATS = [
-    'pgp-mime',
-    'pgp-signed',
-    'pgp-inline',
-    'smime-encrypted',
-    'smime-signed'
+const PEOPLE_SORTS = {
+    RECENT: 'recent',
+    NAME: 'name',
+    THREADS: 'threads'
+};
+const CONTACT_THREAD_SORTS = {
+    NEWEST: 'newest',
+    OLDEST: 'oldest',
+    SENDER: 'sender',
+    SUBJECT: 'subject'
+};
+const CONTACT_BLOCK_LISTS = {
+    BLOCKED_SENDERS: 'blockedSenders',
+    BLOCKED_DOMAINS: 'blockedDomains'
+};
+const CONTACT_PHOTO_TYPES = {
+    PNG: 'image/png',
+    JPEG: 'image/jpeg',
+    WEBP: 'image/webp',
+    GIF: 'image/gif'
+};
+
+const MESSAGE_ENCRYPTION_FORMATS = {
+    PGP_MIME: 'pgp-mime',
+    PGP_SIGNED: 'pgp-signed',
+    PGP_INLINE: 'pgp-inline',
+    SMIME_ENCRYPTED: 'smime-encrypted',
+    SMIME_SIGNED: 'smime-signed'
+};
+const SEALED_ENCRYPTION_FORMATS = [
+    MESSAGE_ENCRYPTION_FORMATS.PGP_MIME,
+    MESSAGE_ENCRYPTION_FORMATS.PGP_INLINE,
+    MESSAGE_ENCRYPTION_FORMATS.SMIME_ENCRYPTED
 ];
-const SEALED_ENCRYPTION_FORMATS = ['pgp-mime', 'pgp-inline', 'smime-encrypted'];
 const BASE64_CHUNK_SIZE = 0x8000;
 
-const ERROR_TYPES = [
-    'invalid_request_error',
-    'authentication_error',
-    'permission_error',
-    'not_found_error',
-    'conflict_error',
-    'validation_error',
-    'rate_limit_error',
-    'api_error'
-];
-const ERROR_TYPE = {
-    INVALID_REQUEST: 'invalid_request_error',
-    AUTHENTICATION: 'authentication_error',
-    PERMISSION: 'permission_error',
-    NOT_FOUND: 'not_found_error',
-    CONFLICT: 'conflict_error',
-    VALIDATION: 'validation_error',
-    RATE_LIMIT: 'rate_limit_error',
-    API: 'api_error'
+const ERROR_TYPES = {
+    INVALID_REQUEST_ERROR: 'invalid_request_error',
+    AUTHENTICATION_ERROR: 'authentication_error',
+    PERMISSION_ERROR: 'permission_error',
+    NOT_FOUND_ERROR: 'not_found_error',
+    CONFLICT_ERROR: 'conflict_error',
+    VALIDATION_ERROR: 'validation_error',
+    RATE_LIMIT_ERROR: 'rate_limit_error',
+    API_ERROR: 'api_error'
 };
 const ERROR_TYPE_BY_STATUS = {
-    401: ERROR_TYPE.AUTHENTICATION,
-    403: ERROR_TYPE.PERMISSION,
-    404: ERROR_TYPE.NOT_FOUND,
-    409: ERROR_TYPE.CONFLICT,
-    422: ERROR_TYPE.VALIDATION,
-    429: ERROR_TYPE.RATE_LIMIT
+    401: ERROR_TYPES.AUTHENTICATION_ERROR,
+    403: ERROR_TYPES.PERMISSION_ERROR,
+    404: ERROR_TYPES.NOT_FOUND_ERROR,
+    409: ERROR_TYPES.CONFLICT_ERROR,
+    422: ERROR_TYPES.VALIDATION_ERROR,
+    429: ERROR_TYPES.RATE_LIMIT_ERROR
 };
 const ERROR_CODES = {
     INSUFFICIENT_SCOPE: 'insufficient_scope',
@@ -92,9 +119,35 @@ const ERROR_NAMES = {
     NETWORK: 'OpenEmailNetworkError',
     TIMEOUT: 'TimeoutError'};
 
+const FILE_SORTS = {
+    NEWEST: 'newest',
+    OLDEST: 'oldest',
+    LARGEST: 'largest',
+    NAME: 'name'
+};
+const FILE_KINDS = {
+    IMAGE: 'image',
+    PDF: 'pdf',
+    AUDIO: 'audio',
+    VIDEO: 'video',
+    TEXT: 'text'
+};
+const FILE_DIRECTIONS = {
+    INBOUND: 'inbound',
+    OUTBOUND: 'outbound',
+    UPLOADED: 'uploaded'
+};
+const FILE_USAGES = {
+    RECEIVED: 'received',
+    SENT: 'sent',
+    LINKED: 'linked',
+    SCHEDULED: 'scheduled'
+};
+
 const HTTP_METHODS = {
     GET: 'GET',
     POST: 'POST',
+    PUT: 'PUT',
     PATCH: 'PATCH',
     DELETE: 'DELETE'
 };
@@ -109,7 +162,8 @@ const HEADER_KEYS = {
 };
 const CONTENT_TYPES = {
     JSON: 'application/json',
-    CALENDAR: 'text/calendar'
+    CALENDAR: 'text/calendar',
+    OCTET_STREAM: 'application/octet-stream'
 };
 const RETRY = {
     STATUSES: [408, 429, 500, 502, 503, 504],
@@ -121,6 +175,28 @@ const RETRY = {
 };
 const IDEMPOTENCY_KEY_PREFIX = 'oe-';
 
+const PROVIDER_IMPORT_RESOURCES = {
+    SUPPRESSIONS: 'suppressions',
+    AUDIENCES: 'audiences',
+    CONTACTS: 'contacts',
+    TEMPLATES: 'templates',
+    WEBHOOKS: 'webhooks',
+    DOMAINS: 'domains',
+    API_KEYS: 'api-keys'
+};
+const PROVIDER_IMPORT_STATUSES = {
+    QUEUED: 'queued',
+    RUNNING: 'running',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled'
+};
+const PROVIDER_IMPORT_DOMAIN_STATES = {
+    ABSENT: 'absent',
+    ADDED: 'added',
+    VERIFIED: 'verified'
+};
+
 const LANGUAGES = [
     { code: 'en', label: 'English', native: 'English', flag: '🇬🇧', rtl: false },
     { code: 'es', label: 'Spanish', native: 'Español', flag: '🇪🇸', rtl: false },
@@ -357,6 +433,7 @@ const CURSOR_STYLES = {
 };
 const QUERY_KEYS = {
     LIMIT: 'limit',
+    CURSOR: 'cursor',
     STATUS: 'status',
     FROM: 'from',
     TO: 'to',
@@ -374,13 +451,42 @@ const QUERY_KEYS = {
     GRAIN: 'grain',
     OFFSET_MINUTES: 'offsetMinutes',
     INCLUDE_MACHINE: 'includeMachine',
-    REASSIGN_TO: 'reassignTo'
+    REASSIGN_TO: 'reassignTo',
+    SOURCE: 'source',
+    ADDRESS: 'address',
+    SEARCH: 'search',
+    SORT: 'sort',
+    PAGE: 'page',
+    PAGE_SIZE: 'pageSize',
+    VERSION: 'version',
+    TRACKED: 'tracked',
+    Q: 'q',
+    AUDIENCE_IDS: 'audienceIds',
+    AUDIENCE_ID: 'audienceId',
+    BROADCAST_ID: 'broadcastId',
+    EMAIL: 'email',
+    BLOCKED: 'blocked',
+    DATE_FROM: 'dateFrom',
+    DATE_TO: 'dateTo',
+    FROM_CONTACTS: 'fromContacts',
+    REASON: 'reason',
+    KIND: 'kind',
+    ENDPOINT_IDS: 'endpointIds',
+    KEY_IDS: 'keyIds',
+    SINCE: 'since',
+    UNTIL: 'until',
+    FAILED_ONLY: 'failedOnly',
+    FILENAME: 'filename'
 };
 const LIST_SEPARATOR = ',';
 
 const PATHS = {
     PING: '/ping',
+    KEYS: '/keys',
+    KEYS_REQUESTS: '/keys/requests',
+    KEYS_ACTIVITY: '/keys/activity',
     KEYS_SELF: '/keys/self',
+    KEYS_SELF_ROTATE: '/keys/self/rotate',
     ADDRESSES: '/addresses',
     LANGUAGES: '/languages',
     EMAILS: '/emails',
@@ -389,10 +495,25 @@ const PATHS = {
     THREADS: '/threads',
     DRAFTS: '/drafts',
     LABELS: '/labels',
+    LABELS_COLORS: '/labels/colors',
     CONTACTS: '/contacts',
+    CONTACTS_PEOPLE: '/contacts/people',
+    CONTACTS_BATCH_DELETE: '/contacts/batch-delete',
+    AUDIENCES: '/audiences',
+    AUDIENCES_GROWTH: '/audiences/growth',
+    BROADCASTS: '/broadcasts',
+    BROADCASTS_PREVIEW: '/broadcasts/preview',
     DOMAINS: '/domains',
     WEBHOOKS: '/webhooks',
+    WEBHOOKS_DELIVERIES: '/webhooks/deliveries',
+    WEBHOOKS_ACTIVITY: '/webhooks/activity',
+    IMPORTS: '/imports',
+    PROVIDER_IMPORTS: '/provider-imports',
+    PROVIDER_IMPORTS_INSPECT: '/provider-imports/inspect',
     TEMPLATES: '/templates',
+    TEMPLATES_FONTS: '/templates/fonts',
+    TEMPLATES_RENDER: '/templates/render',
+    TEMPLATES_STARTERS: '/templates/starters',
     RULES: '/rules',
     RULES_RUNS: '/rules/runs',
     RULES_REORDER: '/rules/reorder',
@@ -403,28 +524,59 @@ const PATHS = {
     ROLES: '/roles',
     ROLES_PERMISSIONS: '/roles/permissions',
     MEMBERS: '/members',
+    MEMBERS_INVITATIONS: '/members/invitations',
+    SUPPRESSIONS: '/suppressions',
+    FILES: '/files',
+    FILES_STATS: '/files/stats',
+    FILES_BATCH_DELETE: '/files/batch-delete',
     TEMP_MAIL_DOMAINS: '/temp-mail/domains',
     TEMP_MAIL_INBOXES: '/temp-mail/inboxes'
 };
 const SEGMENTS = {
+    ACTIVITY: 'activity',
     ADDRESSES: 'addresses',
+    ANALYTICS: 'analytics',
     ATTACHMENTS: 'attachments',
+    AUDIENCES: 'audiences',
+    BATCH: 'batch',
+    BATCH_REMOVE: 'batch-remove',
+    BLOCK: 'block',
     CANCEL: 'cancel',
+    CHUNKS: 'chunks',
     CLICKS: 'clicks',
+    CONTACTS: 'contacts',
+    CONTENT: 'content',
     DELIVERIES: 'deliveries',
+    DUPLICATE: 'duplicate',
+    EMPTY: 'empty',
     EVENTS: 'events',
     EXTEND: 'extend',
+    FAILURES: 'failures',
+    FILES: 'files',
     ICS: 'ics',
+    IMPORT: 'import',
+    LINKS: 'links',
     MESSAGES: 'messages',
     OPENS: 'opens',
+    PHOTO: 'photo',
     PREVIEW: 'preview',
+    REPLAY: 'replay',
+    REQUESTS: 'requests',
+    RESEND: 'resend',
+    RESTORE: 'restore',
+    REVOKE: 'revoke',
+    ROTATE: 'rotate',
     ROTATE_SECRET: 'rotate-secret',
     SEND: 'send',
+    SENDS: 'sends',
     SNOOZE: 'snooze',
+    START: 'start',
     TEST: 'test',
+    THREADS: 'threads',
     TRACKING: 'tracking',
     TRASH: 'trash',
     UNSNOOZE: 'unsnooze',
+    UPLOAD: 'upload',
     VERSIONS: 'versions'
 };
 
@@ -434,89 +586,135 @@ const UPDATE_NOTICE = {
     ENV_DISABLE: 'OPENEMAIL_DISABLE_UPDATE_NOTICE',
     TIMEOUT_MS: 2_000,
     PACKAGE: '@openemail/sdk',
-    CHANGELOG_URL: 'https://www.npmjs.com/package/@openemail/sdk?activeTab=versions',
+    CHANGELOG_URL: 'https://openemail.uk/docs/sdk/changelog',
     ICON: 'ℹ'
 };
 
-const RULE_FIELDS = [
-    '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'
-];
-const RULE_OPERATORS = ['matches', 'contains', 'equals', 'starts_with', 'ends_with', 'gt', 'lt'];
-const RULE_ACTIONS = [
-    'label',
-    'remove_label',
-    'archive',
-    'mark_read',
-    'star',
-    'spam',
-    'trash',
-    'forward',
-    'reply',
-    'block_sender',
-    'reject'
-];
+const RULE_FIELDS = {
+    FROM: 'from',
+    FROM_DOMAIN: 'from_domain',
+    ENVELOPE_FROM: 'envelope_from',
+    TO: 'to',
+    CC: 'cc',
+    BCC: 'bcc',
+    RECIPIENT: 'recipient',
+    REPLY_TO: 'reply_to',
+    DELIVERED_TO: 'delivered_to',
+    SUBJECT: 'subject',
+    BODY: 'body',
+    HEADER: 'header',
+    LIST_ID: 'list_id',
+    ATTACHMENT_NAME: 'attachment_name',
+    ATTACHMENT_TYPE: 'attachment_type',
+    HAS_ATTACHMENT: 'has_attachment',
+    ATTACHMENT_SIZE: 'attachment_size',
+    MESSAGE_SIZE: 'message_size',
+    SPAM: 'spam',
+    HOUR: 'hour',
+    WEEKDAY: 'weekday'
+};
+const RULE_OPERATORS = {
+    MATCHES: 'matches',
+    CONTAINS: 'contains',
+    EQUALS: 'equals',
+    STARTS_WITH: 'starts_with',
+    ENDS_WITH: 'ends_with',
+    GT: 'gt',
+    LT: 'lt'
+};
+const RULE_ACTIONS = {
+    LABEL: 'label',
+    REMOVE_LABEL: 'remove_label',
+    ARCHIVE: 'archive',
+    MARK_READ: 'mark_read',
+    STAR: 'star',
+    SPAM: 'spam',
+    TRASH: 'trash',
+    FORWARD: 'forward',
+    REPLY: 'reply',
+    BLOCK_SENDER: 'block_sender',
+    REJECT: 'reject'
+};
 
-const API_SCOPES = [
-    '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'
-];
+const API_SCOPES = {
+    EMAILS_SEND: 'emails:send',
+    EMAILS_READ: 'emails:read',
+    DRAFTS_READ: 'drafts:read',
+    DRAFTS_WRITE: 'drafts:write',
+    THREADS_READ: 'threads:read',
+    THREADS_WRITE: 'threads:write',
+    LABELS_READ: 'labels:read',
+    LABELS_WRITE: 'labels:write',
+    CONTACTS_READ: 'contacts:read',
+    CONTACTS_WRITE: 'contacts:write',
+    AUDIENCES_READ: 'audiences:read',
+    AUDIENCES_WRITE: 'audiences:write',
+    CALENDAR_READ: 'calendar:read',
+    CALENDAR_WRITE: 'calendar:write',
+    TEMPLATES_READ: 'templates:read',
+    TEMPLATES_WRITE: 'templates:write',
+    DOMAINS_READ: 'domains:read',
+    DOMAINS_WRITE: 'domains:write',
+    WEBHOOKS_READ: 'webhooks:read',
+    WEBHOOKS_WRITE: 'webhooks:write',
+    RULES_READ: 'rules:read',
+    RULES_WRITE: 'rules:write',
+    CONNECTIONS_READ: 'connections:read',
+    MEMBERS_READ: 'members:read',
+    MEMBERS_WRITE: 'members:write',
+    ROLES_READ: 'roles:read',
+    ROLES_WRITE: 'roles:write',
+    SETTINGS_READ: 'settings:read',
+    SETTINGS_WRITE: 'settings:write',
+    KEYS_WRITE: 'keys:write',
+    KEYS_READ: 'keys:read',
+    KEYS_MANAGE: 'keys:manage'
+};
 
-const WEBHOOK_EVENTS = [
-    'email.received',
-    'email.sent',
-    'email.failed',
-    'email.cancelled',
-    'email.scheduled',
-    'email.queued',
-    'email.bounced',
-    'email.complained',
-    'email.opened',
-    'email.clicked'
-];
+const SUPPRESSION_REASONS = {
+    BOUNCE: 'bounce',
+    COMPLAINT: 'complaint',
+    MANUAL: 'manual'
+};
+
+const THREAD_SORTS = {
+    NEWEST: 'newest',
+    OLDEST: 'oldest',
+    SENDER: 'sender',
+    SUBJECT: 'subject'
+};
+
+const WEBHOOK_EVENTS = {
+    EMAIL_RECEIVED: 'email.received',
+    EMAIL_REPLIED: 'email.replied',
+    EMAIL_SENT: 'email.sent',
+    EMAIL_FAILED: 'email.failed',
+    EMAIL_CANCELLED: 'email.cancelled',
+    EMAIL_SCHEDULED: 'email.scheduled',
+    EMAIL_QUEUED: 'email.queued',
+    EMAIL_DELIVERED: 'email.delivered',
+    EMAIL_DELIVERY_DELAYED: 'email.delivery_delayed',
+    EMAIL_BOUNCED: 'email.bounced',
+    EMAIL_COMPLAINED: 'email.complained',
+    EMAIL_SUPPRESSED: 'email.suppressed',
+    EMAIL_OPENED: 'email.opened',
+    EMAIL_CLICKED: 'email.clicked',
+    EMAIL_DOWNLOADED: 'email.downloaded',
+    DOMAIN_VERIFIED: 'domain.verified',
+    DOMAIN_SENDING_CHANGED: 'domain.sending_changed',
+    DOMAIN_DELETED: 'domain.deleted',
+    SUPPRESSION_ADDED: 'suppression.added',
+    SUPPRESSION_REMOVED: 'suppression.removed'
+};
+const WEBHOOK_REPLAY_ERROR_CODES = {
+    RESOURCE_NOT_FOUND: 'resource_not_found',
+    WEBHOOK_DISABLED: 'webhook_disabled',
+    EVENT_NOT_SUBSCRIBED: 'event_not_subscribed',
+    EVENT_OUT_OF_SCOPE: 'event_out_of_scope',
+    DELIVERY_NOT_REPLAYABLE: 'delivery_not_replayable',
+    RETRY_IN_PROGRESS: 'retry_in_progress',
+    REPLAY_IN_PROGRESS: 'replay_in_progress'
+};
 const WEBHOOK_HEADERS = {
     SIGNATURE: 'X-OpenEmail-Signature',
     EVENT: 'X-OpenEmail-Event',
@@ -549,6 +747,108 @@ const ENDPOINT_SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*:\/\//i;
 const RETRYABLE_STATUSES = new Set(RETRY.STATUSES);
 const RETRYABLE_METHODS = new Set(RETRY.METHODS);
 
+({
+    scopes: [API_SCOPES.KEYS_MANAGE]});
+
+({
+    scopes: [API_SCOPES.KEYS_MANAGE]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_READ]});
+
+({
+    scopes: [API_SCOPES.KEYS_MANAGE]});
+
+({
+    scopes: [API_SCOPES.KEYS_MANAGE]});
+
+({
+    scopes: [API_SCOPES.KEYS_MANAGE]});
+
+({
+    scopes: [API_SCOPES.KEYS_WRITE]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
+({
+    scopes: [API_SCOPES.WEBHOOKS_READ]});
+
 const IsApiKey = (value) => typeof value === 'string' && (value.startsWith(API_KEY_PREFIXES.LIVE) || value.startsWith(API_KEY_PREFIXES.TEST));
 const ModeOf = (apiKey) => apiKey.startsWith(API_KEY_PREFIXES.TEST) ? API_KEY_MODES.TEST : API_KEY_MODES.LIVE;
 const AssertApiKey = (apiKey, where) => {
@@ -586,28 +886,28 @@ class OpenEmailApiError extends Error {
         this.retryAfterSeconds = retryAfterSeconds;
     }
     get isAuth() {
-        return this.type === ERROR_TYPE.AUTHENTICATION;
+        return this.type === ERROR_TYPES.AUTHENTICATION_ERROR;
     }
     get isPermission() {
-        return this.type === ERROR_TYPE.PERMISSION;
+        return this.type === ERROR_TYPES.PERMISSION_ERROR;
     }
     get isScopeMissing() {
         return this.code === ERROR_CODES.INSUFFICIENT_SCOPE;
     }
     get isInvalidRequest() {
-        return this.type === ERROR_TYPE.INVALID_REQUEST;
+        return this.type === ERROR_TYPES.INVALID_REQUEST_ERROR;
     }
     get isValidation() {
-        return this.type === ERROR_TYPE.VALIDATION;
+        return this.type === ERROR_TYPES.VALIDATION_ERROR;
     }
     get isNotFound() {
-        return this.type === ERROR_TYPE.NOT_FOUND;
+        return this.type === ERROR_TYPES.NOT_FOUND_ERROR;
     }
     get isConflict() {
-        return this.type === ERROR_TYPE.CONFLICT;
+        return this.type === ERROR_TYPES.CONFLICT_ERROR;
     }
     get isRateLimited() {
-        return this.type === ERROR_TYPE.RATE_LIMIT;
+        return this.type === ERROR_TYPES.RATE_LIMIT_ERROR;
     }
     get isServerError() {
         return this.status !== null && this.status >= 500;
@@ -773,12 +1073,13 @@ const Sleep = (ms, signal) => new Promise((resolve, reject) => {
     signal?.addEventListener('abort', onAbort, { once: true });
 });
 
-const IsErrorType = (value) => typeof value === 'string' && ERROR_TYPES.includes(value);
+const errorTypes = new Set(Object.values(ERROR_TYPES));
+const IsErrorType = (value) => typeof value === 'string' && errorTypes.has(value);
 const TypeForStatus = (status) => {
     if (status >= 500)
-        return ERROR_TYPE.API;
+        return ERROR_TYPES.API_ERROR;
     const mapped = ERROR_TYPE_BY_STATUS[status];
-    return IsErrorType(mapped) ? mapped : ERROR_TYPE.INVALID_REQUEST;
+    return IsErrorType(mapped) ? mapped : ERROR_TYPES.INVALID_REQUEST_ERROR;
 };
 const ReadPayload = (body) => {
     if (typeof body !== 'object' || body === null || !('error' in body))
@@ -853,11 +1154,13 @@ class Transport {
         const method = (options.method ?? HTTP_METHODS.GET).toUpperCase();
         const url = BuildUrl(this.baseUrl, path, options.query);
         const headers = this.headersFor(options);
-        const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+        const body = options.raw !== undefined
+            ? options.raw
+            : options.body === undefined ? undefined : JSON.stringify(options.body);
         const repeatable = options.repeatable ?? RETRYABLE_METHODS.has(method);
         let attempt = 0;
         for (;;) {
-            const outcome = await this.attempt(url, method, headers, body, options.signal);
+            const outcome = await this.attempt(url, method, headers, body, options.signal, options.binary === true, options.timeoutMs ?? this.timeoutMs);
             if (outcome instanceof OpenEmailNetworkError) {
                 if (options.signal?.aborted || !repeatable || attempt >= this.maxRetries)
                     throw outcome;
@@ -865,7 +1168,9 @@ class Transport {
                 attempt += 1;
                 continue;
             }
-            const { response, text } = outcome;
+            const { response, text, bytes } = outcome;
+            if (response.ok && bytes !== undefined)
+                return bytes;
             if (response.ok)
                 return this.parse(response, text, options.accept);
             const retryAfter = RetryAfter(response.headers.get(HEADER_KEYS.RETRY_AFTER));
@@ -887,7 +1192,9 @@ class Transport {
         };
         if (!IsBrowser())
             headers[HEADER_KEYS.USER_AGENT] = this.userAgent;
-        if (options.body !== undefined)
+        if (options.raw !== undefined)
+            headers[HEADER_KEYS.CONTENT_TYPE] = options.contentType ?? CONTENT_TYPES.OCTET_STREAM;
+        else if (options.body !== undefined)
             headers[HEADER_KEYS.CONTENT_TYPE] = CONTENT_TYPES.JSON;
         if (options.anonymous !== true) {
             if (options.apiKey !== undefined)
@@ -900,13 +1207,13 @@ class Transport {
             headers[HEADER_KEYS.IDEMPOTENCY_KEY] = options.idempotencyKey ?? IdempotencyKey();
         return headers;
     }
-    async attempt(url, method, headers, body, signal) {
-        const deadline = Deadline(this.timeoutMs, signal);
+    async attempt(url, method, headers, body, signal, binary, timeoutMs) {
+        const deadline = Deadline(timeoutMs, signal);
         const Failure = (error, fallback) => {
             if (signal?.aborted)
                 return new OpenEmailNetworkError('Request aborted by the caller.', error);
             if (deadline.timedOut())
-                return new OpenEmailNetworkError(`Request timed out after ${this.timeoutMs}ms.`, error, true);
+                return new OpenEmailNetworkError(`Request timed out after ${timeoutMs}ms.`, error, true);
             return new OpenEmailNetworkError(`${fallback}: ${Describe(error)}`, error);
         };
         try {
@@ -918,6 +1225,8 @@ class Transport {
                 return Failure(error, `Could not reach ${this.baseUrl}`);
             }
             try {
+                if (binary && response.ok)
+                    return { response, text: '', bytes: new Uint8Array(await response.arrayBuffer()) };
                 return { response, text: await response.text() };
             }
             catch (error) {
@@ -941,24 +1250,13 @@ class Transport {
         throw new OpenEmailApiError({
             message: `The API answered ${response.status} with a body that is not JSON.`,
             status: response.status,
-            type: ERROR_TYPE.API,
+            type: ERROR_TYPES.API_ERROR,
             code: ERROR_CODES.UNRECOGNISED_RESPONSE,
             requestId: response.headers.get(HEADER_KEYS.REQUEST_ID) ?? undefined
         });
     }
 }
 
-const Addresses = (transport) => ({
-    list: async (options = {}) => {
-        const envelope = await transport.request(PATHS.ADDRESSES, { signal: options.signal, apiKey: options.apiKey });
-        return {
-            unrestricted: envelope.unrestricted,
-            addresses: envelope.data ?? [],
-            domains: envelope.domains ?? []
-        };
-    }
-});
-
 const FetchPage = async (transport, path, style, options = {}, query = {}) => {
     const payload = await transport.request(path, {
         query: { ...query, [QUERY_KEYS.LIMIT]: options.limit, [style.PARAM]: options.cursor },
@@ -1014,11 +1312,31 @@ const ThreadMessageAttachmentsPath = (id, messageId) => `${ThreadPath(id)}/${SEG
 const DraftPath = (id) => `${PATHS.DRAFTS}/${Segment(id)}`;
 const LabelPath = (id) => `${PATHS.LABELS}/${Segment(id)}`;
 const ContactPath = (email) => `${PATHS.CONTACTS}/${Segment(email)}`;
+const ContactChildPath = (email, segment) => `${ContactPath(email)}/${segment}`;
+const AudiencePath = (id) => `${PATHS.AUDIENCES}/${Segment(id)}`;
+const AudienceChildPath = (id, segment) => `${AudiencePath(id)}/${segment}`;
+const AudienceContactsPath = (id) => `${AudiencePath(id)}/${SEGMENTS.CONTACTS}`;
+const AudienceContactsChildPath = (id, segment) => `${AudienceContactsPath(id)}/${segment}`;
+const AudienceContactPath = (id, email) => `${AudienceContactsPath(id)}/${Segment(email)}`;
+const BroadcastPath = (id) => `${PATHS.BROADCASTS}/${Segment(id)}`;
+const BroadcastChildPath = (id, segment) => `${BroadcastPath(id)}/${segment}`;
 const DomainPath = (id) => `${PATHS.DOMAINS}/${Segment(id)}`;
 const WebhookPath = (id) => `${PATHS.WEBHOOKS}/${Segment(id)}`;
 const WebhookChildPath = (id, segment) => `${WebhookPath(id)}/${segment}`;
+const WebhookDeliveryPath = (id, deliveryId) => `${WebhookChildPath(id, SEGMENTS.DELIVERIES)}/${Segment(deliveryId)}`;
+const WebhookDeliveryReplayPath = (id, deliveryId) => `${WebhookDeliveryPath(id, deliveryId)}/${SEGMENTS.REPLAY}`;
+const KeyPath = (id) => `${PATHS.KEYS}/${Segment(id)}`;
+const KeyChildPath = (id, segment) => `${KeyPath(id)}/${segment}`;
+const ImportPath = (id) => `${PATHS.IMPORTS}/${Segment(id)}`;
+const ProviderImportPath = (id) => `${PATHS.PROVIDER_IMPORTS}/${Segment(id)}`;
+const ProviderImportChildPath = (id, segment) => `${ProviderImportPath(id)}/${segment}`;
+const ImportChildPath = (id, segment) => `${ImportPath(id)}/${segment}`;
+const ImportChunkPath = (id, file, chunk) => `${ImportPath(id)}/${SEGMENTS.FILES}/${Segment(String(file))}/${SEGMENTS.CHUNKS}/${Segment(String(chunk))}`;
 const TemplatePath = (idOrSlug) => `${PATHS.TEMPLATES}/${Segment(idOrSlug)}`;
 const TemplateChildPath = (idOrSlug, segment) => `${TemplatePath(idOrSlug)}/${segment}`;
+const TemplateStarterPath = (slug) => `${PATHS.TEMPLATES_STARTERS}/${Segment(slug)}`;
+const TemplateVersionPath = (idOrSlug, version) => `${TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS)}/${Segment(String(version))}`;
+const TemplateVersionChildPath = (idOrSlug, version, segment) => `${TemplateVersionPath(idOrSlug, version)}/${segment}`;
 const RulePath = (id) => `${PATHS.RULES}/${Segment(id)}`;
 const RuleChildPath = (id, segment) => `${RulePath(id)}/${segment}`;
 const TrackingPath = (id) => `${PATHS.TRACKING}/${Segment(id)}`;
@@ -1029,12 +1347,131 @@ const RolePath = (id) => `${PATHS.ROLES}/${Segment(id)}`;
 const MemberPath = (userId) => `${PATHS.MEMBERS}/${Segment(userId)}`;
 const MemberAddressesPath = (userId) => `${MemberPath(userId)}/${SEGMENTS.ADDRESSES}`;
 const MemberAddressPath = (userId, addressId) => `${MemberAddressesPath(userId)}/${Segment(addressId)}`;
+const MemberInvitationPath = (id) => `${PATHS.MEMBERS_INVITATIONS}/${Segment(id)}`;
+const MemberInvitationResendPath = (id) => `${MemberInvitationPath(id)}/${SEGMENTS.RESEND}`;
+const SuppressionPath = (id) => `${PATHS.SUPPRESSIONS}/${Segment(id)}`;
+const FilePath = (id) => `${PATHS.FILES}/${Segment(id)}`;
+const FileChildPath = (id, segment) => `${FilePath(id)}/${segment}`;
 const TempInboxPath = (id) => `${PATHS.TEMP_MAIL_INBOXES}/${Segment(id)}`;
 const TempInboxExtendPath = (id) => `${TempInboxPath(id)}/${SEGMENTS.EXTEND}`;
 const TempMessagesPath = (id) => `${TempInboxPath(id)}/${SEGMENTS.MESSAGES}`;
 const TempMessagePath = (id, messageId) => `${TempMessagesPath(id)}/${Segment(messageId)}`;
 const TempMessageAttachmentsPath = (id, messageId) => `${TempMessagePath(id, messageId)}/${SEGMENTS.ATTACHMENTS}`;
 
+const Addresses = (transport) => {
+    const page = async (options = {}) => {
+        const envelope = await transport.request(PATHS.ADDRESSES, {
+            query: { [QUERY_KEYS.LIMIT]: options.limit, [CURSOR_STYLES.CURSOR.PARAM]: options.cursor },
+            signal: options.signal,
+            apiKey: options.apiKey
+        });
+        const nextCursor = typeof envelope.nextCursor === 'string' && envelope.nextCursor.length > 0 ? envelope.nextCursor : null;
+        return {
+            unrestricted: envelope.unrestricted,
+            addresses: envelope.data ?? [],
+            domains: envelope.domains ?? [],
+            hasMore: typeof envelope.hasMore === 'boolean' ? envelope.hasMore : nextCursor !== null,
+            nextCursor
+        };
+    };
+    return {
+        list: page,
+        listAll: async (options = {}) => {
+            let current = await page(options);
+            const addresses = [...current.addresses];
+            while (current.hasMore && current.nextCursor) {
+                current = await page({ ...options, cursor: current.nextCursor });
+                addresses.push(...current.addresses);
+            }
+            return { unrestricted: current.unrestricted, addresses, domains: current.domains };
+        },
+        iterate: (options = {}) => IteratePages(transport, PATHS.ADDRESSES, CURSOR_STYLES.CURSOR, options)
+    };
+};
+
+const MemberQuery = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.SOURCE]: options.source,
+    [QUERY_KEYS.SORT]: options.sort
+});
+const GrowthQuery = (options) => ({
+    [QUERY_KEYS.AUDIENCE_IDS]: options.audienceIds?.join(LIST_SEPARATOR),
+    [QUERY_KEYS.DAYS]: options.days,
+    [QUERY_KEYS.MINUTES]: options.minutes,
+    [QUERY_KEYS.GRAIN]: options.grain,
+    [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+});
+const Audiences = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.AUDIENCES, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.AUDIENCES, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.AUDIENCES, CURSOR_STYLES.CURSOR, options),
+    growth: (options = {}) => transport.request(PATHS.AUDIENCES_GROWTH, {
+        query: GrowthQuery(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    get: (id, options = {}) => transport.request(AudiencePath(id), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.AUDIENCES, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (id, patch, options = {}) => transport.request(AudiencePath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(AudiencePath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    empty: (id, options = {}) => transport.request(AudienceChildPath(id, SEGMENTS.EMPTY), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listContacts: (id, options = {}) => FetchPage(transport, AudienceContactsPath(id), CURSOR_STYLES.CURSOR, options, MemberQuery(options)),
+    listAllContacts: (id, options = {}) => CollectAll(transport, AudienceContactsPath(id), CURSOR_STYLES.CURSOR, options, MemberQuery(options)),
+    iterateContacts: (id, options = {}) => IteratePages(transport, AudienceContactsPath(id), CURSOR_STYLES.CURSOR, options, MemberQuery(options)),
+    addContact: (id, body, options = {}) => transport.request(AudienceContactsPath(id), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removeContact: (id, email, options = {}) => transport.request(AudienceContactPath(id, email), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    addContacts: (id, body, options = {}) => transport.request(AudienceContactsChildPath(id, SEGMENTS.BATCH), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removeContacts: (id, body, options = {}) => transport.request(AudienceContactsChildPath(id, SEGMENTS.BATCH_REMOVE), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    importContacts: (id, body, options = {}) => transport.request(AudienceChildPath(id, SEGMENTS.IMPORT), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
 const ToBase64 = (bytes) => {
     const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
     let binary = '';
@@ -1050,11 +1487,13 @@ const Many = (value) => {
     return Array.isArray(value) ? value : [value];
 };
 const Instant = (value) => value instanceof Date ? value.toISOString() : value;
-const Attachment = (attachment) => ({
-    filename: attachment.filename,
-    content: typeof attachment.content === 'string' ? attachment.content : ToBase64(attachment.content),
-    ...(attachment.contentType === undefined ? {} : { contentType: attachment.contentType })
-});
+const Attachment = (attachment) => 'fileId' in attachment
+    ? { fileId: attachment.fileId }
+    : {
+        filename: attachment.filename,
+        content: typeof attachment.content === 'string' ? attachment.content : ToBase64(attachment.content),
+        ...(attachment.contentType === undefined ? {} : { contentType: attachment.contentType })
+    };
 const EmailToWire = (body) => ({
     ...body,
     to: Many(body.to),
@@ -1072,12 +1511,47 @@ const TemplateSendToWire = (body) => ({
 });
 const ToInstant = Instant;
 
-const Calendar = (transport) => ({
-    listEvents: (options) => FetchList(transport, PATHS.CALENDAR_EVENTS, options, {
-        [QUERY_KEYS.FROM]: ToInstant(options.from),
-        [QUERY_KEYS.TO]: ToInstant(options.to),
-        [QUERY_KEYS.TIMEZONE]: options.timezone
+const ListQuery$a = (options) => ({
+    [QUERY_KEYS.AUDIENCE_ID]: options.audienceId
+});
+const Broadcasts = (transport) => ({
+    preview: (body, options = {}) => transport.request(PATHS.BROADCASTS_PREVIEW, {
+        method: HTTP_METHODS.POST,
+        body: { audienceIds: body.audienceIds },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
     }),
+    send: (body, options = {}) => transport.request(PATHS.BROADCASTS, {
+        method: HTTP_METHODS.POST,
+        body: { ...body, scheduledAt: ToInstant(body.scheduledAt) },
+        idempotent: true,
+        idempotencyKey: options.idempotencyKey,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    list: (options = {}) => FetchPage(transport, PATHS.BROADCASTS, CURSOR_STYLES.CURSOR, options, ListQuery$a(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.BROADCASTS, CURSOR_STYLES.CURSOR, options, ListQuery$a(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.BROADCASTS, CURSOR_STYLES.CURSOR, options, ListQuery$a(options)),
+    get: (id, options = {}) => transport.request(BroadcastPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    cancel: (id, options = {}) => transport.request(BroadcastChildPath(id, SEGMENTS.CANCEL), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const RangeQuery = (options) => ({
+    [QUERY_KEYS.FROM]: ToInstant(options.from),
+    [QUERY_KEYS.TO]: ToInstant(options.to),
+    [QUERY_KEYS.TIMEZONE]: options.timezone
+});
+const Calendar = (transport) => ({
+    listEvents: (options) => FetchPage(transport, PATHS.CALENDAR_EVENTS, CURSOR_STYLES.CURSOR, options, RangeQuery(options)),
+    listAllEvents: (options) => CollectAll(transport, PATHS.CALENDAR_EVENTS, CURSOR_STYLES.CURSOR, options, RangeQuery(options)),
+    iterateEvents: (options) => IteratePages(transport, PATHS.CALENDAR_EVENTS, CURSOR_STYLES.CURSOR, options, RangeQuery(options)),
     getEvent: (id, options = {}) => transport.request(CalendarEventPath(id), { signal: options.signal, apiKey: options.apiKey }),
     getEventIcs: (id, options = {}) => transport.request(CalendarEventIcsPath(id), {
         accept: CONTENT_TYPES.CALENDAR,
@@ -1086,21 +1560,150 @@ const Calendar = (transport) => ({
     })
 });
 
+const ListQuery$9 = (options) => ({
+    [QUERY_KEYS.SOURCE]: options.source,
+    [QUERY_KEYS.Q]: options.q
+});
+const PeopleQuery = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.EMAIL]: options.email,
+    [QUERY_KEYS.SORT]: options.sort,
+    [QUERY_KEYS.BLOCKED]: options.blocked === undefined ? undefined : String(options.blocked)
+});
+const ThreadQuery = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.SORT]: options.sort
+});
+const ActivityQuery = (options) => ({
+    [QUERY_KEYS.MINUTES]: options.minutes,
+    [QUERY_KEYS.GRAIN]: options.grain,
+    [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+});
+const PhotoType = (data, options) => {
+    if (options.contentType)
+        return options.contentType;
+    return typeof Blob !== 'undefined' && data instanceof Blob && data.type ? data.type : undefined;
+};
 const Contacts = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.CONTACTS, options, { [QUERY_KEYS.LIMIT]: options.limit }),
-    get: (email, options = {}) => transport.request(ContactPath(email), { signal: options.signal, apiKey: options.apiKey })
+    list: (options = {}) => FetchPage(transport, PATHS.CONTACTS, CURSOR_STYLES.CURSOR, options, ListQuery$9(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.CONTACTS, CURSOR_STYLES.CURSOR, options, ListQuery$9(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.CONTACTS, CURSOR_STYLES.CURSOR, options, ListQuery$9(options)),
+    get: (email, options = {}) => transport.request(ContactPath(email), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.CONTACTS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (email, patch, options = {}) => transport.request(ContactPath(email), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (email, options = {}) => transport.request(ContactPath(email), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setAudiences: (email, body, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.AUDIENCES), {
+        method: HTTP_METHODS.PUT,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listPeople: async (options = {}) => {
+        const payload = await transport.request(PATHS.CONTACTS_PEOPLE, {
+            query: {
+                ...PeopleQuery(options),
+                [QUERY_KEYS.LIMIT]: options.limit,
+                [CURSOR_STYLES.CURSOR.PARAM]: options.cursor
+            },
+            signal: options.signal,
+            apiKey: options.apiKey
+        });
+        const next = payload?.[CURSOR_STYLES.CURSOR.FIELD];
+        const nextCursor = typeof next === 'string' && next.length > 0 ? next : null;
+        return {
+            items: (Array.isArray(payload?.data) ? payload.data : []),
+            hasMore: typeof payload?.hasMore === 'boolean' ? payload.hasMore : nextCursor !== null,
+            nextCursor,
+            seen: payload?.seen === true
+        };
+    },
+    listAllPeople: (options = {}) => CollectAll(transport, PATHS.CONTACTS_PEOPLE, CURSOR_STYLES.CURSOR, options, PeopleQuery(options)),
+    iteratePeople: (options = {}) => IteratePages(transport, PATHS.CONTACTS_PEOPLE, CURSOR_STYLES.CURSOR, options, PeopleQuery(options)),
+    save: (email, body = {}, options = {}) => transport.request(ContactPath(email), {
+        method: HTTP_METHODS.PUT,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteMany: (emails, options = {}) => transport.request(PATHS.CONTACTS_BATCH_DELETE, {
+        method: HTTP_METHODS.POST,
+        body: { emails },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setPhoto: (email, data, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.PHOTO), {
+        method: HTTP_METHODS.PUT,
+        raw: data,
+        contentType: PhotoType(data, options),
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removePhoto: (email, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.PHOTO), {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    block: (email, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.BLOCK), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    unblock: (email, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.BLOCK), {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listThreads: (email, options = {}) => FetchPage(transport, ContactChildPath(email, SEGMENTS.THREADS), CURSOR_STYLES.CURSOR, options, ThreadQuery(options)),
+    listAllThreads: (email, options = {}) => CollectAll(transport, ContactChildPath(email, SEGMENTS.THREADS), CURSOR_STYLES.CURSOR, options, ThreadQuery(options)),
+    iterateThreads: (email, options = {}) => IteratePages(transport, ContactChildPath(email, SEGMENTS.THREADS), CURSOR_STYLES.CURSOR, options, ThreadQuery(options)),
+    activity: (email, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.ACTIVITY), {
+        query: ActivityQuery(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
 });
 
 const Domains = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.DOMAINS, options),
-    get: (id, options = {}) => transport.request(DomainPath(id), { signal: options.signal, apiKey: options.apiKey })
+    list: (options = {}) => FetchPage(transport, PATHS.DOMAINS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.DOMAINS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.DOMAINS, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(DomainPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    update: (id, patch, options = {}) => transport.request(DomainPath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
 });
 
-const ListQuery$4 = (options) => ({ [QUERY_KEYS.QUERY]: options.query });
+const ListQuery$8 = (options) => ({ [QUERY_KEYS.QUERY]: options.query });
 const Drafts = (transport) => ({
-    list: (options = {}) => FetchPage(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$4(options)),
-    listAll: (options = {}) => CollectAll(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$4(options)),
-    iterate: (options = {}) => IteratePages(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$4(options)),
+    list: (options = {}) => FetchPage(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$8(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$8(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$8(options)),
     get: (id, options = {}) => transport.request(DraftPath(id), { signal: options.signal, apiKey: options.apiKey }),
     create: (body, options = {}) => transport.request(PATHS.DRAFTS, {
         method: HTTP_METHODS.POST,
@@ -1121,9 +1724,10 @@ const Drafts = (transport) => ({
     })
 });
 
-const ListQuery$3 = (options) => ({
+const ListQuery$7 = (options) => ({
     [QUERY_KEYS.STATUS]: Array.isArray(options.status) ? options.status.join(LIST_SEPARATOR) : options.status,
-    [QUERY_KEYS.FROM]: options.from
+    [QUERY_KEYS.FROM]: options.from,
+    [QUERY_KEYS.BROADCAST_ID]: options.broadcastId
 });
 const Emails = (transport) => ({
     send: (body, options = {}) => transport.request(PATHS.EMAILS, {
@@ -1153,11 +1757,13 @@ const Emails = (transport) => ({
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    list: (options = {}) => FetchPage(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
-    listAll: (options = {}) => CollectAll(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
-    iterate: (options = {}) => IteratePages(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
+    list: (options = {}) => FetchPage(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$7(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$7(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$7(options)),
     get: (id, options = {}) => transport.request(EmailPath(id), { signal: options.signal, apiKey: options.apiKey }),
-    listEvents: (id, options = {}) => FetchList(transport, EmailChildPath(id, SEGMENTS.EVENTS), options),
+    listEvents: (id, options = {}) => FetchPage(transport, EmailChildPath(id, SEGMENTS.EVENTS), CURSOR_STYLES.CURSOR, options),
+    listAllEvents: (id, options = {}) => CollectAll(transport, EmailChildPath(id, SEGMENTS.EVENTS), CURSOR_STYLES.CURSOR, options),
+    iterateEvents: (id, options = {}) => IteratePages(transport, EmailChildPath(id, SEGMENTS.EVENTS), CURSOR_STYLES.CURSOR, options),
     getTracking: (id, options = {}) => transport.request(EmailChildPath(id, SEGMENTS.TRACKING), { signal: options.signal, apiKey: options.apiKey }),
     cancel: (id, options = {}) => transport.request(EmailChildPath(id, SEGMENTS.CANCEL), {
         method: HTTP_METHODS.POST,
@@ -1174,8 +1780,238 @@ const Emails = (transport) => ({
     })
 });
 
+const ListQuery$6 = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.KIND]: options.kind,
+    [QUERY_KEYS.SORT]: options.sort
+});
+const UploadName = (options) => {
+    const filename = typeof options?.filename === 'string' ? options.filename.trim() : '';
+    if (!filename)
+        throw new Error(CLIENT_MESSAGES.FILENAME_REQUIRED);
+    return filename;
+};
+const UploadType = (data, options) => {
+    if (options.contentType)
+        return options.contentType;
+    return typeof Blob !== 'undefined' && data instanceof Blob && data.type ? data.type : undefined;
+};
+const UploadTimeout = (transport, options) => {
+    if (options.timeoutMs !== undefined)
+        return options.timeoutMs;
+    return transport.timeoutMs > 0 ? Math.max(transport.timeoutMs, DEFAULTS.UPLOAD_TIMEOUT_MS) : transport.timeoutMs;
+};
+const Files = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.FILES, CURSOR_STYLES.CURSOR, options, ListQuery$6(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.FILES, CURSOR_STYLES.CURSOR, options, ListQuery$6(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.FILES, CURSOR_STYLES.CURSOR, options, ListQuery$6(options)),
+    get: (id, options = {}) => transport.request(FilePath(id), { signal: options.signal, apiKey: options.apiKey }),
+    stats: (options = {}) => transport.request(PATHS.FILES_STATS, { signal: options.signal, apiKey: options.apiKey }),
+    download: (id, options = {}) => transport.request(FileChildPath(id, SEGMENTS.CONTENT), {
+        binary: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listLinks: (id, options = {}) => FetchPage(transport, FileChildPath(id, SEGMENTS.LINKS), CURSOR_STYLES.CURSOR, options),
+    listAllLinks: (id, options = {}) => CollectAll(transport, FileChildPath(id, SEGMENTS.LINKS), CURSOR_STYLES.CURSOR, options),
+    iterateLinks: (id, options = {}) => IteratePages(transport, FileChildPath(id, SEGMENTS.LINKS), CURSOR_STYLES.CURSOR, options),
+    upload: (data, options) => transport.request(PATHS.FILES, {
+        method: HTTP_METHODS.POST,
+        query: { [QUERY_KEYS.FILENAME]: UploadName(options) },
+        raw: data,
+        contentType: UploadType(data, options),
+        timeoutMs: UploadTimeout(transport, options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(FilePath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteMany: (ids, options = {}) => transport.request(PATHS.FILES_BATCH_DELETE, {
+        method: HTTP_METHODS.POST,
+        body: { ids },
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const ListQuery$5 = (options) => ({ addressId: options.addressId });
+const SizeOf = (data) => data instanceof Blob ? data.size : data.byteLength;
+const SliceOf = (data, start, end) => {
+    if (data instanceof Blob)
+        return data.slice(start, end);
+    if (data instanceof Uint8Array)
+        return data.subarray(start, end);
+    return new Uint8Array(data, start, end - start);
+};
+const Imports = (transport) => {
+    const create = (body, options = {}) => transport.request(PATHS.IMPORTS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    });
+    const uploadChunk = (id, file, chunk, data, options = {}) => transport.request(ImportChunkPath(id, file, chunk), {
+        method: HTTP_METHODS.PUT,
+        raw: data,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    });
+    const start = (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.START), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    });
+    return {
+        list: (options = {}) => FetchPage(transport, PATHS.IMPORTS, CURSOR_STYLES.CURSOR, options, ListQuery$5(options)),
+        listAll: (options = {}) => CollectAll(transport, PATHS.IMPORTS, CURSOR_STYLES.CURSOR, options, ListQuery$5(options)),
+        iterate: (options = {}) => IteratePages(transport, PATHS.IMPORTS, CURSOR_STYLES.CURSOR, options, ListQuery$5(options)),
+        get: (id, options = {}) => transport.request(ImportPath(id), { signal: options.signal, apiKey: options.apiKey }),
+        create,
+        uploadState: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.UPLOAD), {
+            signal: options.signal,
+            apiKey: options.apiKey
+        }),
+        uploadChunk,
+        start,
+        cancel: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.CANCEL), {
+            method: HTTP_METHODS.POST,
+            signal: options.signal,
+            apiKey: options.apiKey
+        }),
+        listFailures: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.FAILURES), {
+            query: { after: options.after, limit: options.limit },
+            signal: options.signal,
+            apiKey: options.apiKey
+        }),
+        deleteUpload: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.UPLOAD), {
+            method: HTTP_METHODS.DELETE,
+            signal: options.signal,
+            apiKey: options.apiKey
+        }),
+        importFiles: async (input, options = {}) => {
+            const created = await create({
+                addressId: input.addressId,
+                files: input.files.map(file => ({ name: file.name, bytes: SizeOf(file.data) })),
+                options: input.options
+            }, options);
+            if (input.files.length === 0)
+                return created;
+            const total = created.totalBytes;
+            let uploaded = 0;
+            for (const [index, file] of input.files.entries()) {
+                const chunks = created.files[index]?.chunks ?? 1;
+                for (let chunk = 0; chunk < chunks; chunk++) {
+                    const begin = chunk * created.chunkBytes;
+                    const end = Math.min(SizeOf(file.data), begin + created.chunkBytes);
+                    await uploadChunk(created.id, index, chunk, SliceOf(file.data, begin, end), options);
+                    uploaded += end - begin;
+                    input.onProgress?.(uploaded, total);
+                }
+            }
+            return start(created.id, options);
+        }
+    };
+};
+
+const WindowQuery$2 = (options) => ({
+    [QUERY_KEYS.SINCE]: options.since === undefined ? undefined : ToInstant(options.since),
+    [QUERY_KEYS.UNTIL]: options.until === undefined ? undefined : ToInstant(options.until)
+});
+const RequestQuery = (options) => ({
+    ...WindowQuery$2(options),
+    [QUERY_KEYS.FAILED_ONLY]: options.failedOnly === undefined ? undefined : String(options.failedOnly)
+});
+const WorkspaceRequestQuery = (options) => ({
+    ...RequestQuery(options),
+    [QUERY_KEYS.KEY_IDS]: options.keyIds?.join(LIST_SEPARATOR)
+});
+const WorkspaceActivityQuery$1 = (options) => ({
+    ...WindowQuery$2(options),
+    [QUERY_KEYS.KEY_IDS]: options.keyIds?.join(LIST_SEPARATOR)
+});
+const Keys = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.KEYS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.KEYS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.KEYS, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(KeyPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.KEYS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (id, patch, options = {}) => transport.request(KeyPath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(KeyPath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    rotate: (id, options = {}) => transport.request(KeyChildPath(id, SEGMENTS.ROTATE), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    revoke: (id, body = {}, options = {}) => transport.request(KeyChildPath(id, SEGMENTS.REVOKE), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listRequests: (id, options = {}) => FetchPage(transport, KeyChildPath(id, SEGMENTS.REQUESTS), CURSOR_STYLES.CURSOR, options, RequestQuery(options)),
+    listAllRequests: (id, options = {}) => CollectAll(transport, KeyChildPath(id, SEGMENTS.REQUESTS), CURSOR_STYLES.CURSOR, options, RequestQuery(options)),
+    iterateRequests: (id, options = {}) => IteratePages(transport, KeyChildPath(id, SEGMENTS.REQUESTS), CURSOR_STYLES.CURSOR, options, RequestQuery(options)),
+    listActivity: (id, options = {}) => FetchPage(transport, KeyChildPath(id, SEGMENTS.ACTIVITY), CURSOR_STYLES.CURSOR, options, WindowQuery$2(options)),
+    listAllActivity: (id, options = {}) => CollectAll(transport, KeyChildPath(id, SEGMENTS.ACTIVITY), CURSOR_STYLES.CURSOR, options, WindowQuery$2(options)),
+    iterateActivity: (id, options = {}) => IteratePages(transport, KeyChildPath(id, SEGMENTS.ACTIVITY), CURSOR_STYLES.CURSOR, options, WindowQuery$2(options)),
+    listWorkspaceRequests: (options = {}) => FetchPage(transport, PATHS.KEYS_REQUESTS, CURSOR_STYLES.CURSOR, options, WorkspaceRequestQuery(options)),
+    listAllWorkspaceRequests: (options = {}) => CollectAll(transport, PATHS.KEYS_REQUESTS, CURSOR_STYLES.CURSOR, options, WorkspaceRequestQuery(options)),
+    iterateWorkspaceRequests: (options = {}) => IteratePages(transport, PATHS.KEYS_REQUESTS, CURSOR_STYLES.CURSOR, options, WorkspaceRequestQuery(options)),
+    listWorkspaceActivity: (options = {}) => FetchPage(transport, PATHS.KEYS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery$1(options)),
+    listAllWorkspaceActivity: (options = {}) => CollectAll(transport, PATHS.KEYS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery$1(options)),
+    iterateWorkspaceActivity: (options = {}) => IteratePages(transport, PATHS.KEYS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery$1(options))
+});
+
+const ProviderImports = (transport) => ({
+    inspect: (apiKey, options = {}) => transport.request(PATHS.PROVIDER_IMPORTS_INSPECT, {
+        method: HTTP_METHODS.POST,
+        body: { apiKey },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    create: (body, options = {}) => transport.request(PATHS.PROVIDER_IMPORTS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    list: (options = {}) => FetchPage(transport, PATHS.PROVIDER_IMPORTS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.PROVIDER_IMPORTS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.PROVIDER_IMPORTS, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(ProviderImportPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    cancel: (id, options = {}) => transport.request(ProviderImportChildPath(id, SEGMENTS.CANCEL), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
 const Labels = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.LABELS, options),
+    list: (options = {}) => FetchPage(transport, PATHS.LABELS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.LABELS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.LABELS, CURSOR_STYLES.CURSOR, options),
+    listColors: (options = {}) => FetchList(transport, PATHS.LABELS_COLORS, options),
     get: (id, options = {}) => transport.request(LabelPath(id), { signal: options.signal, apiKey: options.apiKey }),
     create: (body, options = {}) => transport.request(PATHS.LABELS, {
         method: HTTP_METHODS.POST,
@@ -1183,9 +2019,9 @@ const Labels = (transport) => ({
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, body, options = {}) => transport.request(LabelPath(id), {
+    update: (id, patch, options = {}) => transport.request(LabelPath(id), {
         method: HTTP_METHODS.PATCH,
-        body,
+        body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
@@ -1203,11 +2039,18 @@ const Languages = (transport) => ({
 
 const Me = (transport) => ({
     get: (options = {}) => transport.request(PATHS.KEYS_SELF, { signal: options.signal, apiKey: options.apiKey }),
-    ping: (options = {}) => transport.request(PATHS.PING, { signal: options.signal, apiKey: options.apiKey })
+    ping: (options = {}) => transport.request(PATHS.PING, { signal: options.signal, apiKey: options.apiKey }),
+    rotate: (options = {}) => transport.request(PATHS.KEYS_SELF_ROTATE, {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
 });
 
 const Members = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.MEMBERS, options),
+    list: (options = {}) => FetchPage(transport, PATHS.MEMBERS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.MEMBERS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.MEMBERS, CURSOR_STYLES.CURSOR, options),
     get: (userId, options = {}) => transport.request(MemberPath(userId), { signal: options.signal, apiKey: options.apiKey }),
     add: (body, options = {}) => transport.request(PATHS.MEMBERS, {
         method: HTTP_METHODS.POST,
@@ -1238,11 +2081,26 @@ const Members = (transport) => ({
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
+    }),
+    listInvitations: (options = {}) => FetchPage(transport, PATHS.MEMBERS_INVITATIONS, CURSOR_STYLES.CURSOR, options),
+    listAllInvitations: (options = {}) => CollectAll(transport, PATHS.MEMBERS_INVITATIONS, CURSOR_STYLES.CURSOR, options),
+    iterateInvitations: (options = {}) => IteratePages(transport, PATHS.MEMBERS_INVITATIONS, CURSOR_STYLES.CURSOR, options),
+    revokeInvitation: (invitationId, options = {}) => transport.request(MemberInvitationPath(invitationId), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    resendInvitation: (invitationId, options = {}) => transport.request(MemberInvitationResendPath(invitationId), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
     })
 });
 
 const Roles = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.ROLES, options),
+    list: (options = {}) => FetchPage(transport, PATHS.ROLES, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.ROLES, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.ROLES, CURSOR_STYLES.CURSOR, options),
     get: (id, options = {}) => transport.request(RolePath(id), { signal: options.signal, apiKey: options.apiKey }),
     create: (body, options = {}) => transport.request(PATHS.ROLES, {
         method: HTTP_METHODS.POST,
@@ -1266,7 +2124,7 @@ const Roles = (transport) => ({
     listPermissions: (options = {}) => FetchList(transport, PATHS.ROLES_PERMISSIONS, options)
 });
 
-const ListQuery$2 = (options) => ({
+const ListQuery$4 = (options) => ({
     [QUERY_KEYS.ENABLED]: options.enabled === undefined ? undefined : String(options.enabled)
 });
 const RunsQuery = (options) => ({
@@ -1274,9 +2132,9 @@ const RunsQuery = (options) => ({
     [QUERY_KEYS.THREAD_ID]: options.threadId
 });
 const Rules = (transport) => ({
-    list: (options = {}) => FetchPage(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
-    listAll: (options = {}) => CollectAll(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
-    iterate: (options = {}) => IteratePages(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    list: (options = {}) => FetchPage(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$4(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$4(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$4(options)),
     get: (id, options = {}) => transport.request(RulePath(id), { signal: options.signal, apiKey: options.apiKey }),
     create: (body, options = {}) => transport.request(PATHS.RULES, {
         method: HTTP_METHODS.POST,
@@ -1318,9 +2176,14 @@ const Rules = (transport) => ({
 });
 
 const Settings = (transport) => ({
-    get: (options = {}) => transport.request(PATHS.SETTINGS, { signal: options.signal, apiKey: options.apiKey }),
+    get: (options = {}) => transport.request(PATHS.SETTINGS, {
+        query: { [QUERY_KEYS.ADDRESS]: options.address },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
     update: (patch, options = {}) => transport.request(PATHS.SETTINGS, {
         method: HTTP_METHODS.PATCH,
+        query: { [QUERY_KEYS.ADDRESS]: options.address },
         body: patch,
         repeatable: true,
         signal: options.signal,
@@ -1328,6 +2191,54 @@ const Settings = (transport) => ({
     })
 });
 
+const ListQuery$3 = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.REASON]: options.reason
+});
+const Suppressions = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.SUPPRESSIONS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.SUPPRESSIONS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.SUPPRESSIONS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
+    get: (id, options = {}) => transport.request(SuppressionPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    add: (body, options = {}) => transport.request(PATHS.SUPPRESSIONS, {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    remove: (id, options = {}) => transport.request(SuppressionPath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const MessagePage = async (transport, inboxId, options) => {
+    const envelope = await transport.request(TempMessagesPath(inboxId), {
+        query: { [QUERY_KEYS.LIMIT]: options.limit, [QUERY_KEYS.CURSOR]: options.cursor },
+        inboxToken: options.inboxToken,
+        signal: options.signal
+    });
+    const nextCursor = typeof envelope?.nextCursor === 'string' && envelope.nextCursor.length > 0 ? envelope.nextCursor : null;
+    return {
+        items: envelope?.data ?? [],
+        hasMore: typeof envelope?.hasMore === 'boolean' ? envelope.hasMore : nextCursor !== null,
+        nextCursor,
+        expiresAt: envelope?.expiresAt
+    };
+};
+const IterateMessages = async function* (transport, inboxId, options) {
+    let cursor = options.cursor;
+    for (;;) {
+        const page = await MessagePage(transport, inboxId, { ...options, cursor });
+        for (const item of page.items)
+            yield item;
+        if (!page.hasMore || !page.nextCursor || page.nextCursor === cursor)
+            return;
+        cursor = page.nextCursor;
+    }
+};
 const TempMail = (transport) => ({
     listDomains: async (options = {}) => (await transport.request(PATHS.TEMP_MAIL_DOMAINS, {
         anonymous: true,
@@ -1353,14 +2264,14 @@ const TempMail = (transport) => ({
         inboxToken: options.inboxToken,
         signal: options.signal
     }),
-    listMessages: async (inboxId, options = {}) => {
-        const envelope = await transport.request(TempMessagesPath(inboxId), {
-            query: { [QUERY_KEYS.LIMIT]: options.limit },
-            inboxToken: options.inboxToken,
-            signal: options.signal
-        });
-        return { items: envelope?.data ?? [], expiresAt: envelope?.expiresAt };
+    listMessages: (inboxId, options = {}) => MessagePage(transport, inboxId, options),
+    listAllMessages: async (inboxId, options = {}) => {
+        const all = [];
+        for await (const message of IterateMessages(transport, inboxId, options))
+            all.push(message);
+        return all;
     },
+    iterateMessages: (inboxId, options = {}) => IterateMessages(transport, inboxId, options),
     getMessage: (inboxId, messageId, options = {}) => transport.request(TempMessagePath(inboxId, messageId), {
         inboxToken: options.inboxToken,
         signal: options.signal
@@ -1376,11 +2287,32 @@ const TempMail = (transport) => ({
     }))?.data ?? []
 });
 
-const ListQuery$1 = (options) => ({ [QUERY_KEYS.STATUS]: options.status });
+const ListQuery$2 = (options) => ({
+    [QUERY_KEYS.STATUS]: options.status,
+    [QUERY_KEYS.SEARCH]: options.search,
+    [QUERY_KEYS.SORT]: options.sort
+});
+const Flag$1 = (value) => value === undefined ? undefined : String(value);
+const WindowQuery$1 = (options) => ({
+    [QUERY_KEYS.DAYS]: options.days,
+    [QUERY_KEYS.MINUTES]: options.minutes,
+    [QUERY_KEYS.GRAIN]: options.grain,
+    [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+});
 const Templates = (transport) => ({
-    list: (options = {}) => FetchPage(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
-    listAll: (options = {}) => CollectAll(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
-    iterate: (options = {}) => IteratePages(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
+    list: (options = {}) => FetchPage(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    listStarters: (options = {}) => FetchList(transport, PATHS.TEMPLATES_STARTERS, options),
+    listFonts: (options = {}) => FetchList(transport, PATHS.TEMPLATES_FONTS, options),
+    getStarter: (slug, options = {}) => transport.request(TemplateStarterPath(slug), { signal: options.signal, apiKey: options.apiKey }),
+    render: (body, options = {}) => transport.request(PATHS.TEMPLATES_RENDER, {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
     get: (idOrSlug, options = {}) => transport.request(TemplatePath(idOrSlug), { signal: options.signal, apiKey: options.apiKey }),
     create: (body, options = {}) => transport.request(PATHS.TEMPLATES, {
         method: HTTP_METHODS.POST,
@@ -1399,7 +2331,33 @@ const Templates = (transport) => ({
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    listVersions: (idOrSlug, options = {}) => FetchList(transport, TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), options),
+    duplicate: (idOrSlug, body = {}, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.DUPLICATE), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    replaceContent: (idOrSlug, body, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.CONTENT), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listVersions: (idOrSlug, options = {}) => FetchPage(transport, TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), CURSOR_STYLES.CURSOR, options),
+    listAllVersions: (idOrSlug, options = {}) => CollectAll(transport, TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), CURSOR_STYLES.CURSOR, options),
+    iterateVersions: (idOrSlug, options = {}) => IteratePages(transport, TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), CURSOR_STYLES.CURSOR, options),
+    getVersion: (idOrSlug, version, options = {}) => transport.request(TemplateVersionPath(idOrSlug, version), { signal: options.signal, apiKey: options.apiKey }),
+    deleteVersion: (idOrSlug, version, options = {}) => transport.request(TemplateVersionPath(idOrSlug, version), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    restoreVersion: (idOrSlug, version, body = {}, options = {}) => transport.request(TemplateVersionChildPath(idOrSlug, version, SEGMENTS.RESTORE), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
     publish: (idOrSlug, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), {
         method: HTTP_METHODS.POST,
         repeatable: true,
@@ -1413,6 +2371,34 @@ const Templates = (transport) => ({
         signal: options.signal,
         apiKey: options.apiKey
     }),
+    getAnalytics: (idOrSlug, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.ANALYTICS), {
+        query: WindowQuery$1(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listSends: async (idOrSlug, options = {}) => {
+        const envelope = await transport.request(TemplateChildPath(idOrSlug, SEGMENTS.SENDS), {
+            query: {
+                ...WindowQuery$1(options),
+                [QUERY_KEYS.PAGE]: options.page,
+                [QUERY_KEYS.PAGE_SIZE]: options.pageSize,
+                [QUERY_KEYS.SEARCH]: options.search,
+                [QUERY_KEYS.SOURCE]: options.source,
+                [QUERY_KEYS.VERSION]: options.version,
+                [QUERY_KEYS.OPENED]: Flag$1(options.opened),
+                [QUERY_KEYS.CLICKED]: Flag$1(options.clicked),
+                [QUERY_KEYS.TRACKED]: Flag$1(options.tracked)
+            },
+            signal: options.signal,
+            apiKey: options.apiKey
+        });
+        return {
+            items: envelope?.data ?? [],
+            total: envelope?.total ?? 0,
+            page: envelope?.page ?? 1,
+            pageSize: envelope?.pageSize ?? 0
+        };
+    },
     send: (idOrSlug, body, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.SEND), {
         method: HTTP_METHODS.POST,
         body: TemplateSendToWire(body),
@@ -1424,15 +2410,19 @@ const Templates = (transport) => ({
     })
 });
 
-const ListQuery = (options) => ({
+const ListQuery$1 = (options) => ({
     [QUERY_KEYS.FOLDER]: options.folder,
     [QUERY_KEYS.QUERY]: options.query,
-    [QUERY_KEYS.LABEL_IDS]: Array.isArray(options.labelIds) ? options.labelIds.join(LIST_SEPARATOR) : options.labelIds
+    [QUERY_KEYS.LABEL_IDS]: Array.isArray(options.labelIds) ? options.labelIds.join(LIST_SEPARATOR) : options.labelIds,
+    [QUERY_KEYS.SORT]: options.sort,
+    [QUERY_KEYS.DATE_FROM]: options.dateFrom === undefined ? undefined : ToInstant(options.dateFrom),
+    [QUERY_KEYS.DATE_TO]: options.dateTo === undefined ? undefined : ToInstant(options.dateTo),
+    [QUERY_KEYS.FROM_CONTACTS]: options.fromContacts === undefined ? undefined : String(options.fromContacts)
 });
 const Threads = (transport) => ({
-    list: (options = {}) => FetchPage(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery(options)),
-    listAll: (options = {}) => CollectAll(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery(options)),
-    iterate: (options = {}) => IteratePages(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery(options)),
+    list: (options = {}) => FetchPage(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$1(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$1(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$1(options)),
     get: (id, options = {}) => transport.request(ThreadPath(id), { signal: options.signal, apiKey: options.apiKey }),
     update: (id, patch, options = {}) => transport.request(ThreadPath(id), {
         method: HTTP_METHODS.PATCH,
@@ -1465,18 +2455,19 @@ const Threads = (transport) => ({
 
 const Flag = (value) => value === undefined ? undefined : String(value);
 const HitQuery = (options) => ({
-    [QUERY_KEYS.INCLUDE_MACHINE]: Flag(options.includeMachine),
-    [QUERY_KEYS.LIMIT]: options.limit
+    [QUERY_KEYS.INCLUDE_MACHINE]: Flag(options.includeMachine)
+});
+const ListQuery = (options) => ({
+    [QUERY_KEYS.OPENED]: Flag(options.opened),
+    [QUERY_KEYS.CLICKED]: Flag(options.clicked),
+    [QUERY_KEYS.DAYS]: options.days,
+    [QUERY_KEYS.MINUTES]: options.minutes,
+    [QUERY_KEYS.GRAIN]: options.grain
 });
 const Tracking = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.TRACKING, options, {
-        [QUERY_KEYS.OPENED]: Flag(options.opened),
-        [QUERY_KEYS.CLICKED]: Flag(options.clicked),
-        [QUERY_KEYS.DAYS]: options.days,
-        [QUERY_KEYS.MINUTES]: options.minutes,
-        [QUERY_KEYS.GRAIN]: options.grain,
-        [QUERY_KEYS.LIMIT]: options.limit
-    }),
+    list: (options = {}) => FetchPage(transport, PATHS.TRACKING, CURSOR_STYLES.CURSOR, options, ListQuery(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.TRACKING, CURSOR_STYLES.CURSOR, options, ListQuery(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.TRACKING, CURSOR_STYLES.CURSOR, options, ListQuery(options)),
     getStats: (options = {}) => transport.request(PATHS.TRACKING_STATS, {
         query: {
             [QUERY_KEYS.DAYS]: options.days,
@@ -1488,12 +2479,34 @@ const Tracking = (transport) => ({
         apiKey: options.apiKey
     }),
     get: (id, options = {}) => transport.request(TrackingPath(id), { signal: options.signal, apiKey: options.apiKey }),
-    listOpens: (id, options = {}) => FetchList(transport, TrackingChildPath(id, SEGMENTS.OPENS), options, HitQuery(options)),
-    listClicks: (id, options = {}) => FetchList(transport, TrackingChildPath(id, SEGMENTS.CLICKS), options, HitQuery(options))
+    listOpens: (id, options = {}) => FetchPage(transport, TrackingChildPath(id, SEGMENTS.OPENS), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    listAllOpens: (id, options = {}) => CollectAll(transport, TrackingChildPath(id, SEGMENTS.OPENS), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    iterateOpens: (id, options = {}) => IteratePages(transport, TrackingChildPath(id, SEGMENTS.OPENS), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    listClicks: (id, options = {}) => FetchPage(transport, TrackingChildPath(id, SEGMENTS.CLICKS), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    listAllClicks: (id, options = {}) => CollectAll(transport, TrackingChildPath(id, SEGMENTS.CLICKS), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    iterateClicks: (id, options = {}) => IteratePages(transport, TrackingChildPath(id, SEGMENTS.CLICKS), CURSOR_STYLES.CURSOR, options, HitQuery(options))
 });
 
+const WindowQuery = (options) => ({
+    [QUERY_KEYS.SINCE]: options.since === undefined ? undefined : ToInstant(options.since),
+    [QUERY_KEYS.UNTIL]: options.until === undefined ? undefined : ToInstant(options.until)
+});
+const DeliveryQuery = (options) => ({
+    ...WindowQuery(options),
+    [QUERY_KEYS.STATUS]: options.status
+});
+const WorkspaceDeliveryQuery = (options) => ({
+    ...DeliveryQuery(options),
+    [QUERY_KEYS.ENDPOINT_IDS]: options.endpointIds?.join(LIST_SEPARATOR)
+});
+const WorkspaceActivityQuery = (options) => ({
+    ...WindowQuery(options),
+    [QUERY_KEYS.ENDPOINT_IDS]: options.endpointIds?.join(LIST_SEPARATOR)
+});
 const Webhooks = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.WEBHOOKS, options),
+    list: (options = {}) => FetchPage(transport, PATHS.WEBHOOKS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, PATHS.WEBHOOKS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, PATHS.WEBHOOKS, CURSOR_STYLES.CURSOR, options),
     get: (id, options = {}) => transport.request(WebhookPath(id), { signal: options.signal, apiKey: options.apiKey }),
     create: (body, options = {}) => transport.request(PATHS.WEBHOOKS, {
         method: HTTP_METHODS.POST,
@@ -1523,13 +2536,34 @@ const Webhooks = (transport) => ({
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    listDeliveries: (id, options = {}) => FetchList(transport, WebhookChildPath(id, SEGMENTS.DELIVERIES), options)
+    listDeliveries: (id, options = {}) => FetchPage(transport, WebhookChildPath(id, SEGMENTS.DELIVERIES), CURSOR_STYLES.CURSOR, options, DeliveryQuery(options)),
+    listAllDeliveries: (id, options = {}) => CollectAll(transport, WebhookChildPath(id, SEGMENTS.DELIVERIES), CURSOR_STYLES.CURSOR, options, DeliveryQuery(options)),
+    iterateDeliveries: (id, options = {}) => IteratePages(transport, WebhookChildPath(id, SEGMENTS.DELIVERIES), CURSOR_STYLES.CURSOR, options, DeliveryQuery(options)),
+    listWorkspaceDeliveries: (options = {}) => FetchPage(transport, PATHS.WEBHOOKS_DELIVERIES, CURSOR_STYLES.CURSOR, options, WorkspaceDeliveryQuery(options)),
+    listAllWorkspaceDeliveries: (options = {}) => CollectAll(transport, PATHS.WEBHOOKS_DELIVERIES, CURSOR_STYLES.CURSOR, options, WorkspaceDeliveryQuery(options)),
+    iterateWorkspaceDeliveries: (options = {}) => IteratePages(transport, PATHS.WEBHOOKS_DELIVERIES, CURSOR_STYLES.CURSOR, options, WorkspaceDeliveryQuery(options)),
+    listActivity: (id, options = {}) => FetchPage(transport, WebhookChildPath(id, SEGMENTS.ACTIVITY), CURSOR_STYLES.CURSOR, options, WindowQuery(options)),
+    listAllActivity: (id, options = {}) => CollectAll(transport, WebhookChildPath(id, SEGMENTS.ACTIVITY), CURSOR_STYLES.CURSOR, options, WindowQuery(options)),
+    iterateActivity: (id, options = {}) => IteratePages(transport, WebhookChildPath(id, SEGMENTS.ACTIVITY), CURSOR_STYLES.CURSOR, options, WindowQuery(options)),
+    listWorkspaceActivity: (options = {}) => FetchPage(transport, PATHS.WEBHOOKS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery(options)),
+    listAllWorkspaceActivity: (options = {}) => CollectAll(transport, PATHS.WEBHOOKS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery(options)),
+    iterateWorkspaceActivity: (options = {}) => IteratePages(transport, PATHS.WEBHOOKS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery(options)),
+    getDelivery: (id, deliveryId, options = {}) => transport.request(WebhookDeliveryPath(id, deliveryId), {
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    replayDelivery: (id, deliveryId, options = {}) => transport.request(WebhookDeliveryReplayPath(id, deliveryId), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
 });
 
 class OpenEmail {
     transport;
     mode;
     me;
+    keys;
     addresses;
     languages;
     emails;
@@ -1539,13 +2573,19 @@ class OpenEmail {
     drafts;
     labels;
     contacts;
+    audiences;
+    broadcasts;
     domains;
     rules;
     webhooks;
+    imports;
+    providerImports;
     calendar;
     settings;
     roles;
     members;
+    suppressions;
+    files;
     tempMail;
     constructor(configuration) {
         const options = typeof configuration === 'string' ? { apiKey: configuration } : configuration;
@@ -1555,6 +2595,7 @@ class OpenEmail {
         this.transport = new Transport(options);
         this.mode = ModeOf(options.apiKey);
         this.me = Me(this.transport);
+        this.keys = Keys(this.transport);
         this.addresses = Addresses(this.transport);
         this.languages = Languages(this.transport);
         this.emails = Emails(this.transport);
@@ -1564,13 +2605,19 @@ class OpenEmail {
         this.drafts = Drafts(this.transport);
         this.labels = Labels(this.transport);
         this.contacts = Contacts(this.transport);
+        this.audiences = Audiences(this.transport);
+        this.broadcasts = Broadcasts(this.transport);
         this.domains = Domains(this.transport);
         this.rules = Rules(this.transport);
         this.webhooks = Webhooks(this.transport);
+        this.imports = Imports(this.transport);
+        this.providerImports = ProviderImports(this.transport);
         this.calendar = Calendar(this.transport);
         this.settings = Settings(this.transport);
         this.roles = Roles(this.transport);
         this.members = Members(this.transport);
+        this.suppressions = Suppressions(this.transport);
+        this.files = Files(this.transport);
         this.tempMail = TempMail(this.transport);
     }
     get raw() {
@@ -1746,18 +2793,33 @@ const languageByCode = LanguageByCode;
 const isRtlLanguage = IsRtlLanguage;
 
 exports.API_SCOPES = API_SCOPES;
+exports.BROADCAST_STATUSES = BROADCAST_STATUSES;
+exports.CONTACT_BLOCK_LISTS = CONTACT_BLOCK_LISTS;
+exports.CONTACT_PHOTO_TYPES = CONTACT_PHOTO_TYPES;
+exports.CONTACT_THREAD_SORTS = CONTACT_THREAD_SORTS;
 exports.ERROR_TYPES = ERROR_TYPES;
+exports.FILE_DIRECTIONS = FILE_DIRECTIONS;
+exports.FILE_KINDS = FILE_KINDS;
+exports.FILE_SORTS = FILE_SORTS;
+exports.FILE_USAGES = FILE_USAGES;
 exports.LANGUAGES = LANGUAGES;
 exports.MESSAGE_ENCRYPTION_FORMATS = MESSAGE_ENCRYPTION_FORMATS;
 exports.OpenEmail = OpenEmail;
 exports.OpenEmailApiError = OpenEmailApiError;
 exports.OpenEmailNetworkError = OpenEmailNetworkError;
 exports.PAGE_LIMITS = PAGE_LIMITS;
+exports.PEOPLE_SORTS = PEOPLE_SORTS;
+exports.PROVIDER_IMPORT_DOMAIN_STATES = PROVIDER_IMPORT_DOMAIN_STATES;
+exports.PROVIDER_IMPORT_RESOURCES = PROVIDER_IMPORT_RESOURCES;
+exports.PROVIDER_IMPORT_STATUSES = PROVIDER_IMPORT_STATUSES;
 exports.RULE_ACTIONS = RULE_ACTIONS;
 exports.RULE_FIELDS = RULE_FIELDS;
 exports.RULE_OPERATORS = RULE_OPERATORS;
+exports.SUPPRESSION_REASONS = SUPPRESSION_REASONS;
+exports.THREAD_SORTS = THREAD_SORTS;
 exports.VERSION = VERSION;
 exports.WEBHOOK_EVENTS = WEBHOOK_EVENTS;
+exports.WEBHOOK_REPLAY_ERROR_CODES = WEBHOOK_REPLAY_ERROR_CODES;
 exports.WEBHOOK_SIGNATURE_HEADERS = WEBHOOK_SIGNATURE_HEADERS;
 exports.createClient = createClient;
 exports.createOpenEmail = createOpenEmail;