@openemail/sdk 0.0.6 → 0.0.8

package/index.cjs

@@ -2,11 +2,136 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+const APP_HOST_STATUSES = {
+    NONE: 'none',
+    PENDING: 'pending',
+    ACTIVE: 'active',
+    FAILED: 'failed'
+};
+
 const AUDIENCE_MEMBER_STATUSES = {
     SUBSCRIBED: 'subscribed',
     UNSUBSCRIBED: 'unsubscribed'
 };
 
+const PLAN_IDS = {
+    FREE: 'free',
+    STARTER: 'starter',
+    BUSINESS: 'business',
+    ENTERPRISE: 'enterprise'
+};
+const PAID_PLAN_IDS = {
+    STARTER: 'starter',
+    BUSINESS: 'business',
+    ENTERPRISE: 'enterprise'
+};
+const BILLING_INTERVALS = {
+    MONTH: 'month',
+    YEAR: 'year'
+};
+const BILLING_THEMES = {
+    LIGHT: 'light',
+    DARK: 'dark'
+};
+const BILLING_USAGE_WINDOWS = {
+    ALL: 'all'
+};
+const BILLING_ALERT_KINDS = {
+    PAYMENT_FAILED: 'payment_failed',
+    PAY_AS_YOU_GO_PAUSED: 'pay_as_you_go_paused',
+    SENDING_PAUSED: 'sending_paused',
+    SPEND_LIMIT_REACHED: 'spend_limit_reached',
+    AI_USED_UP: 'ai_used_up',
+    PLAN_ENDING: 'plan_ending',
+    SENDS_NEARLY_USED: 'sends_nearly_used',
+    SPEND_NEARLY_REACHED: 'spend_nearly_reached',
+    UPCOMING_CHARGE: 'upcoming_charge'
+};
+const BILLING_ALERT_SEVERITIES = {
+    BLOCKED: 'blocked',
+    WARNING: 'warning',
+    INFO: 'info'
+};
+const BILLING_ALERT_TARGETS = {
+    BILLING: 'billing',
+    USAGE: 'usage'
+};
+const BILLING_INVOICE_SORTS = {
+    NEWEST: 'newest',
+    OLDEST: 'oldest'
+};
+const BILLING_INVOICE_STATUSES = {
+    DRAFT: 'draft',
+    PENDING: 'pending',
+    PAID: 'paid',
+    REFUNDED: 'refunded',
+    PARTIALLY_REFUNDED: 'partially_refunded',
+    VOID: 'void'
+};
+const BILLING_INVOICE_STARTS = {
+    READY: 'ready',
+    STARTED: 'started',
+    REFUSED: 'refused'
+};
+const PAY_AS_YOU_GO_LIMITS_CENTS = [1_000, 2_500, 5_000, 10_000, 25_000, 50_000, 100_000, 250_000, 500_000];
+
+const BRAND_IMAGE_VARIANTS = {
+    MARK: 'mark',
+    WORDMARK: 'wordmark',
+    WORDMARK_DARK: 'wordmark-dark',
+    LOGIN_BACKGROUND: 'login-background'
+};
+const BRAND_IMAGE_TYPES = {
+    SVG: 'image/svg+xml',
+    PNG: 'image/png',
+    JPEG: 'image/jpeg',
+    WEBP: 'image/webp',
+    GIF: 'image/gif'
+};
+const BRAND_FONT_IDS = {
+    SYSTEM: 'system',
+    ARIAL: 'arial',
+    HELVETICA: 'helvetica',
+    VERDANA: 'verdana',
+    TAHOMA: 'tahoma',
+    TREBUCHET_MS: 'trebuchet-ms',
+    GEORGIA: 'georgia',
+    TIMES_NEW_ROMAN: 'times-new-roman',
+    COURIER_NEW: 'courier-new',
+    DM_SANS: 'dm-sans',
+    INTER: 'inter',
+    ROBOTO: 'roboto',
+    OPEN_SANS: 'open-sans',
+    LATO: 'lato',
+    MONTSERRAT: 'montserrat',
+    POPPINS: 'poppins',
+    NUNITO: 'nunito',
+    WORK_SANS: 'work-sans',
+    SOURCE_SANS_3: 'source-sans-3',
+    IBM_PLEX_SANS: 'ibm-plex-sans',
+    MERRIWEATHER: 'merriweather',
+    PLAYFAIR_DISPLAY: 'playfair-display',
+    INSTRUMENT_SERIF: 'instrument-serif',
+    JETBRAINS_MONO: 'jetbrains-mono',
+    DM_MONO: 'dm-mono',
+    GEIST_MONO: 'geist-mono'
+};
+const LOGIN_BACKGROUND_KINDS = {
+    PRESET: 'preset',
+    COLOR: 'color',
+    IMAGE: 'image'
+};
+const LOGIN_BACKGROUND_PRESETS = {
+    DUSK: 'dusk',
+    MIST: 'mist',
+    SAND: 'sand',
+    NIGHT: 'night'
+};
+const LOGIN_LOGOS = {
+    DARK: 'dark',
+    LIGHT: 'light'
+};
+
 const BROADCAST_STATUSES = {
     SCHEDULED: 'scheduled',
     QUEUED: 'queued',
@@ -28,7 +153,61 @@ const BROADCAST_RECIPIENT_FILTERS = {
     UNSUBSCRIBED: 'unsubscribed'
 };
 
-var version = "0.0.6";
+const CALENDAR_RESPONSES = {
+    ACCEPTED: 'ACCEPTED',
+    DECLINED: 'DECLINED',
+    TENTATIVE: 'TENTATIVE'
+};
+const CALENDAR_TRANSPARENCIES = {
+    OPAQUE: 'OPAQUE',
+    TRANSPARENT: 'TRANSPARENT'
+};
+const CALENDAR_VISIBILITIES = {
+    PUBLIC: 'PUBLIC',
+    PRIVATE: 'PRIVATE',
+    CONFIDENTIAL: 'CONFIDENTIAL'
+};
+const CALENDAR_REMINDER_ACTIONS = {
+    DISPLAY: 'DISPLAY',
+    EMAIL: 'EMAIL',
+    AUDIO: 'AUDIO'
+};
+const CALENDAR_FEED_MODES = {
+    FULL: 'full',
+    BUSY: 'busy'
+};
+const CALENDAR_COLORS = {
+    BLUE: 'blue',
+    SKY: 'sky',
+    TEAL: 'teal',
+    GREEN: 'green',
+    LIME: 'lime',
+    YELLOW: 'yellow',
+    ORANGE: 'orange',
+    RED: 'red',
+    PINK: 'pink',
+    PURPLE: 'purple',
+    GRAY: 'gray'
+};
+const CALENDAR_SUBSCRIPTION_STATUSES = {
+    ACTIVE: 'active',
+    FAILING: 'failing',
+    STOPPED: 'stopped'
+};
+const CALENDAR_SUBSCRIPTION_ERRORS = {
+    UNREACHABLE: 'unreachable',
+    TOO_LARGE: 'too-large',
+    NOT_A_CALENDAR: 'not-a-calendar',
+    TOO_MANY_EVENTS: 'too-many-events'
+};
+
+const CHAT_SORTS = {
+    NEWEST: 'newest',
+    OLDEST: 'oldest',
+    TITLE: 'title'
+};
+
+var version = "0.0.8";
 
 const BUILD_BASE_URL = 'https://api.openemail.uk';
 
@@ -83,9 +262,17 @@ const CLIENT_MESSAGES = {
     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.'
+    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.',
+    PATH_SHAPE: 'is not a usable request path. Pass a path on the API that begins with a single "/", such as "/threads". Anything else could send the request, and the credential it carries, to another host.',
+    OFF_ORIGIN: 'leaves the API origin, so the request was not sent. Pass a path on the API that begins with a single "/", such as "/threads".'
 };
+const DOT_ONLY_SEGMENT = /^\.+$/;
 
+const CONTACT_SOURCES = {
+    MANUAL: 'manual',
+    AUTO: 'auto',
+    FORM: 'form'
+};
 const PEOPLE_SORTS = {
     RECENT: 'recent',
     NAME: 'name',
@@ -107,6 +294,47 @@ const CONTACT_PHOTO_TYPES = {
     WEBP: 'image/webp',
     GIF: 'image/gif'
 };
+const CONTACT_CARD_LABELS = {
+    HOME: 'home',
+    WORK: 'work',
+    MOBILE: 'mobile',
+    MAIN: 'main',
+    FAX: 'fax',
+    PAGER: 'pager',
+    OTHER: 'other'
+};
+
+const DNS_CONNECTION_STATUSES = {
+    ACTIVE: 'active',
+    NEEDS_REAUTH: 'needs-reauth',
+    REVOKED: 'revoked',
+    ERROR: 'error'
+};
+const DNS_PROVISION_STATES = {
+    UNMANAGED: 'unmanaged',
+    READY: 'ready',
+    AWAITING_SYNC: 'awaiting-sync',
+    AWAITING_SIGNING: 'awaiting-signing',
+    CONFLICT: 'conflict',
+    BLOCKED: 'blocked'
+};
+const DNS_ZONE_RESOLUTION_KINDS = {
+    RESOLVED: 'resolved',
+    AMBIGUOUS: 'ambiguous',
+    NONE: 'none',
+    UNUSABLE: 'unusable'
+};
+const DNS_SYNC_PURPOSES = {
+    DMARC: 'dmarc',
+    TRACKING: 'tracking',
+    STORAGE: 'storage',
+    BIMI: 'bimi',
+    APP_HOST: 'app-host'
+};
+const DNS_SYNC_OUTCOMES = {
+    SYNCED: 'synced',
+    REFUSED: 'refused'
+};
 
 const DOMAIN_RECORD_STATUSES = {
     FOUND: 'found',
@@ -119,6 +347,61 @@ const DOMAIN_DMARC_STAGES = {
     QUARANTINE: 'quarantine',
     REJECT: 'reject'
 };
+const DOMAIN_DMARC_POLICIES = {
+    NONE: 'none',
+    QUARANTINE: 'quarantine',
+    REJECT: 'reject'
+};
+const DOMAIN_LOGO_MARK_KINDS = {
+    VERIFIED: 'verified',
+    COMMON: 'common',
+    UNKNOWN: 'unknown'
+};
+const DOMAIN_LOGO_RECORD_OUTCOMES = {
+    PUBLISHED: 'published',
+    MANUAL: 'manual',
+    BLOCKED: 'blocked',
+    BUSY: 'busy',
+    FAILED: 'failed'
+};
+const DOMAIN_ADDRESS_DESTINATIONS = {
+    MAILBOX: 'mailbox',
+    FORWARD: 'forward'
+};
+const ADDRESS_FORWARD_STATUSES = {
+    LIVE: 'live',
+    PENDING: 'pending',
+    REFUSED: 'refused',
+    PAUSED: 'paused'
+};
+const ADDRESS_FORWARD_CONSENT_STATUSES = {
+    SENT: 'sent',
+    ALREADY_CONFIRMED: 'already-confirmed',
+    REVOKED: 'revoked',
+    TOO_SOON: 'too-soon',
+    SEND_FAILED: 'send-failed'
+};
+const ADDRESS_MEMBER_VIAS = {
+    OWNER: 'owner',
+    EVERY_ADDRESS: 'every-address',
+    WHOLE_DOMAIN: 'whole-domain',
+    DIRECT: 'direct'
+};
+const MAIL_APP_SECURITIES = {
+    SSL_TLS: 'ssl-tls'
+};
+const MAIL_APP_PROTOCOLS = {
+    IMAP: 'imap',
+    SMTP: 'smtp',
+    POP3: 'pop3',
+    CALDAV: 'caldav',
+    CARDDAV: 'carddav'
+};
+const APP_PASSWORD_ORIGINS = {
+    SETTINGS: 'settings',
+    SETUP_LINK: 'setup-link',
+    API: 'api'
+};
 
 const MESSAGE_ENCRYPTION_FORMATS = {
     PGP_MIME: 'pgp-mime',
@@ -161,6 +444,25 @@ const ERROR_NAMES = {
     NETWORK: 'OpenEmailNetworkError',
     TIMEOUT: 'TimeoutError'};
 
+const EXPORT_STATUSES = {
+    QUEUED: 'queued',
+    RUNNING: 'running',
+    READY: 'ready',
+    FAILED: 'failed',
+    EXPIRED: 'expired'
+};
+const EXPORT_PHASES = {
+    PLANNING: 'planning',
+    MAIL: 'mail',
+    RECORDS: 'records',
+    FINISHING: 'finishing'
+};
+const EXPORT_REFUSALS = {
+    NOT_PERMITTED: 'not-permitted',
+    MAILBOX_LOGIN: 'mailbox-login',
+    TWO_FACTOR_REQUIRED: 'two-factor-required'
+};
+
 const FILE_SORTS = {
     NEWEST: 'newest',
     OLDEST: 'oldest',
@@ -190,6 +492,109 @@ const FILE_VISIBILITIES = {
     PRIVATE: 'private'
 };
 
+const FORM_STATUSES = {
+    DRAFT: 'draft',
+    LIVE: 'live',
+    PAUSED: 'paused'
+};
+const FORM_SUBMISSION_STATUSES = {
+    PENDING: 'pending',
+    ADDED: 'added'
+};
+const FORM_FIELD_TYPES = {
+    EMAIL: 'email',
+    TEXT: 'text',
+    TEXTAREA: 'textarea',
+    NUMBER: 'number',
+    PHONE: 'phone',
+    URL: 'url',
+    DATE: 'date',
+    SELECT: 'select',
+    RADIO: 'radio',
+    CHECKBOXES: 'checkboxes',
+    CHECKBOX: 'checkbox',
+    CONSENT: 'consent',
+    AUDIENCES: 'audiences',
+    HIDDEN: 'hidden',
+    HEADING: 'heading',
+    PARAGRAPH: 'paragraph',
+    DIVIDER: 'divider'
+};
+const FORM_STARTER_SLUGS = {
+    BLANK: 'blank',
+    NEWSLETTER: 'newsletter',
+    WAITLIST: 'waitlist',
+    EVENT: 'event',
+    EARLY_ACCESS: 'early-access',
+    CONTACT: 'contact'
+};
+const FORM_CONFIRM_SOURCES = {
+    LINK: 'link',
+    APPROVAL: 'approval'
+};
+const FORM_CONTACT_FIELDS = {
+    EMAIL: 'email',
+    FIRST_NAME: 'firstName',
+    LAST_NAME: 'lastName',
+    NAME: 'name'
+};
+const FORM_FIELD_WIDTHS = {
+    FULL: 'full',
+    HALF: 'half'
+};
+const FORM_FONTS = {
+    SYSTEM: 'system',
+    SANS: 'sans',
+    SERIF: 'serif',
+    MONO: 'mono'
+};
+const FORM_RADII = {
+    NONE: 'none',
+    SM: 'sm',
+    MD: 'md',
+    LG: 'lg',
+    FULL: 'full'
+};
+const FORM_WIDTHS = {
+    NARROW: 'narrow',
+    NORMAL: 'normal',
+    WIDE: 'wide'
+};
+const FORM_LAYOUTS = {
+    CARD: 'card',
+    PLAIN: 'plain'
+};
+const FORM_ALIGNS = {
+    LEFT: 'left',
+    CENTER: 'center'
+};
+const FORM_SUCCESS_ACTIONS = {
+    MESSAGE: 'message',
+    REDIRECT: 'redirect'
+};
+const FORM_SENDER_ISSUES = {
+    MISSING: 'missing',
+    NOT_SENDABLE: 'not_sendable',
+    NOT_ALLOWED: 'not_allowed'
+};
+const FORM_FIELD_ERRORS = {
+    REQUIRED: 'required',
+    EMAIL: 'email',
+    NUMBER: 'number',
+    MIN: 'min',
+    MAX: 'max',
+    TOO_SHORT: 'too_short',
+    TOO_LONG: 'too_long',
+    URL: 'url',
+    DATE: 'date',
+    PHONE: 'phone',
+    OPTION: 'option'
+};
+const FORM_SUBSCRIBE_OUTCOMES = {
+    ADDED: 'added',
+    PENDING: 'pending'
+};
+
 const HTTP_METHODS = {
     GET: 'GET',
     POST: 'POST',
@@ -221,6 +626,21 @@ const RETRY = {
 };
 const IDEMPOTENCY_KEY_PREFIX = 'oe-';
 
+const IMPORT_FORMATS = {
+    GMAIL: 'gmail',
+    OPENEMAIL: 'openemail',
+    THUNDERBIRD: 'thunderbird',
+    PROTON: 'proton',
+    MBOX: 'mbox',
+    EML: 'eml'
+};
+const PROVIDER_IMPORT_PROVIDERS = {
+    RESEND: 'resend',
+    SENDGRID: 'sendgrid',
+    POSTMARK: 'postmark',
+    MAILGUN: 'mailgun',
+    MAILCHIMP: 'mailchimp'
+};
 const PROVIDER_IMPORT_RESOURCES = {
     SUPPRESSIONS: 'suppressions',
     AUDIENCES: 'audiences',
@@ -243,6 +663,74 @@ const PROVIDER_IMPORT_DOMAIN_STATES = {
     VERIFIED: 'verified'
 };
 
+const KNOWLEDGE_KINDS = {
+    NOTE: 'note',
+    FILE: 'file',
+    LINK: 'link'
+};
+const KNOWLEDGE_LEVELS = {
+    WORKSPACE: 'workspace',
+    DOMAIN: 'domain',
+    ADDRESS: 'address'
+};
+const KNOWLEDGE_STATUSES = {
+    QUEUED: 'queued',
+    PROCESSING: 'processing',
+    READY: 'ready',
+    FAILED: 'failed'
+};
+const KNOWLEDGE_FAILURES = {
+    UNSUPPORTED: 'unsupported',
+    EMPTY: 'empty',
+    TOO_LARGE: 'too_large',
+    FETCH_FAILED: 'fetch_failed',
+    BLOCKED_URL: 'blocked_url',
+    CONVERSION_FAILED: 'conversion_failed',
+    INDEX_FAILED: 'index_failed',
+    OVER_ALLOWANCE: 'over_allowance',
+    MISSING_FILE: 'missing_file'
+};
+const KNOWLEDGE_ORIGINS = {
+    APP: 'app',
+    API: 'api',
+    ASSISTANT: 'assistant',
+    MCP: 'mcp'
+};
+const KNOWLEDGE_REFRESH_DAY_CHOICES = {
+    DAY: 1,
+    WEEK: 7,
+    MONTH: 30
+};
+const KNOWLEDGE_SUGGESTION_KINDS = {
+    LEARNED: 'learned',
+    QUESTION: 'question'
+};
+const KNOWLEDGE_SUGGESTION_STATUSES = {
+    PENDING: 'pending',
+    ACCEPTED: 'accepted',
+    DISMISSED: 'dismissed'
+};
+const KNOWLEDGE_FLAG_KINDS = {
+    DUPLICATE: 'duplicate',
+    CONFLICT: 'conflict'
+};
+const KNOWLEDGE_FLAG_STATUSES = {
+    OPEN: 'open',
+    DISMISSED: 'dismissed'
+};
+const KNOWLEDGE_CONNECTOR_KINDS = {
+    SITE: 'site',
+    SITEMAP: 'sitemap',
+    FEED: 'feed',
+    ZENDESK: 'zendesk'
+};
+const KNOWLEDGE_CONNECTOR_STATUSES = {
+    QUEUED: 'queued',
+    SYNCING: 'syncing',
+    READY: 'ready',
+    FAILED: 'failed'
+};
+
 const LANGUAGES = [
     { code: 'en', label: 'English', native: 'English', flag: '🇬🇧', rtl: false },
     { code: 'es', label: 'Spanish', native: 'Español', flag: '🇪🇸', rtl: false },
@@ -469,6 +957,47 @@ const LANGUAGE_ALIASES = [
 ];
 const LANGUAGE_SUBTAG_PATTERN = /[-_]/;
 
+const THREAD_SUMMARY_STATES = {
+    READY: 'ready',
+    PENDING: 'pending',
+    NONE: 'none'
+};
+const REPLY_SUGGESTION_STATES = {
+    READY: 'ready',
+    PENDING: 'pending',
+    NONE: 'none'
+};
+const MAIL_SERVICES = {
+    OPENEMAIL: 'openemail',
+    GMAIL: 'gmail',
+    OUTLOOK: 'outlook',
+    ICLOUD: 'icloud',
+    YAHOO: 'yahoo',
+    PROTON: 'proton',
+    ZOHO: 'zoho',
+    FASTMAIL: 'fastmail',
+    RESEND: 'resend',
+    SENDGRID: 'sendgrid',
+    MAILGUN: 'mailgun',
+    POSTMARK: 'postmark',
+    MAILCHIMP: 'mailchimp',
+    BREVO: 'brevo',
+    SPARKPOST: 'sparkpost',
+    HUBSPOT: 'hubspot',
+    AMAZON_SES: 'amazon-ses'
+};
+
+const THREAD_NOTE_COLORS = {
+    DEFAULT: 'default',
+    RED: 'red',
+    ORANGE: 'orange',
+    YELLOW: 'yellow',
+    GREEN: 'green',
+    BLUE: 'blue',
+    PURPLE: 'purple',
+    PINK: 'pink'
+};
+
 const PAGINATION = {
     MAX_LIMIT: 100,
     DEFAULT_LIMIT: 25
@@ -512,11 +1041,14 @@ const QUERY_KEYS = {
     AUDIENCE_IDS: 'audienceIds',
     AUDIENCE_ID: 'audienceId',
     BROADCAST_ID: 'broadcastId',
+    BROADCAST_IDS: 'broadcastIds',
     EMAIL: 'email',
+    WITHOUT_EMAIL: 'withoutEmail',
     BLOCKED: 'blocked',
     DATE_FROM: 'dateFrom',
     DATE_TO: 'dateTo',
     FROM_CONTACTS: 'fromContacts',
+    SEMANTIC: 'semantic',
     REASON: 'reason',
     KIND: 'kind',
     ENDPOINT_IDS: 'endpointIds',
@@ -524,124 +1056,42 @@ const QUERY_KEYS = {
     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',
-    EMAILS_BATCH: '/emails/batch',
-    EMAILS_TRANSLATE: '/emails/translate',
-    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',
-    TRACKING: '/tracking',
-    TRACKING_STATS: '/tracking/stats',
-    CALENDAR_EVENTS: '/calendar/events',
-    SETTINGS: '/settings',
-    SECURITY_STEP_UP: '/security/step-up',
-    SECURITY_STEP_UP_VERIFY: '/security/step-up/verify',
-    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',
+    FILENAME: 'filename',
+    DOMAIN: 'domain',
+    SCHEDULED_FROM: 'scheduledFrom',
+    SCHEDULED_TO: 'scheduledTo',
     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',
-    RECIPIENTS: 'recipients',
-    SEND: 'send',
+    OFFSET: 'offset',
+    REFRESH: 'refresh',
+    CONFIRM: 'confirm',
+    USERNAME: 'username',
+    SCOPE: 'scope',
+    LEVEL: 'level',
+    PINNED: 'pinned',
+    TITLE: 'title',
+    ITEM_ID: 'itemId',
     SENDS: 'sends',
-    STATS: 'stats',
-    SNOOZE: 'snooze',
-    START: 'start',
-    TEST: 'test',
-    THREADS: 'threads',
-    TRACKING: 'tracking',
-    TRASH: 'trash',
-    UNSNOOZE: 'unsnooze',
-    UPLOAD: 'upload',
-    VERIFY: 'verify',
-    VERSIONS: 'versions'
+    DOMAINS: 'domains',
+    PEOPLE: 'people',
+    AI_ACTIONS: 'aiActions',
+    INTERVAL: 'interval'
 };
+const LIST_SEPARATOR = ',';
 
+const DOCS_PATHS = {
+    SDK_CHANGELOG: '/docs/sdk/changelog'};
+
+const APP_ORIGIN = 'https://openemail.uk';
 const VERSION = version;
 const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@openemail/sdk';
 const UPDATE_NOTICE = {
     ENV_DISABLE: 'OPENEMAIL_DISABLE_UPDATE_NOTICE',
     TIMEOUT_MS: 2_000,
     PACKAGE: '@openemail/sdk',
-    CHANGELOG_URL: 'https://openemail.uk/docs/sdk/changelog',
+    CHANGELOG_URL: `${APP_ORIGIN}${DOCS_PATHS.SDK_CHANGELOG}`,
     ICON: 'ℹ'
 };
+const VERSION_TAG_PREFIX = /^v/;
 
 const RULE_FIELDS = {
     FROM: 'from',
@@ -723,7 +1173,23 @@ const API_SCOPES = {
     SETTINGS_WRITE: 'settings:write',
     KEYS_WRITE: 'keys:write',
     KEYS_READ: 'keys:read',
-    KEYS_MANAGE: 'keys:manage'
+    KEYS_MANAGE: 'keys:manage',
+    FORMS_READ: 'forms:read',
+    FORMS_WRITE: 'forms:write',
+    KNOWLEDGE_READ: 'knowledge:read',
+    KNOWLEDGE_WRITE: 'knowledge:write',
+    BILLING_READ: 'billing:read',
+    BILLING_WRITE: 'billing:write',
+    ACCOUNT_READ: 'account:read',
+    ACCOUNT_WRITE: 'account:write'
+};
+const CONSOLE_PERMISSIONS = {
+    ADDRESSES_ALL: 'addresses:all',
+    API_KEYS_READ: 'api-keys:read',
+    API_KEYS_WRITE: 'api-keys:write',
+    BILLING_READ: 'billing:read',
+    BILLING_WRITE: 'billing:write',
+    WORKSPACE_MANAGE: 'workspace:manage'
 };
 
 const STEP_UP_METHODS = {
@@ -746,6 +1212,14 @@ const SUPPRESSION_REASONS = {
     MANUAL: 'manual'
 };
 
+const TEMPLATE_IMAGE_TYPES = {
+    PNG: 'image/png',
+    JPEG: 'image/jpeg',
+    WEBP: 'image/webp',
+    GIF: 'image/gif',
+    SVG: 'image/svg+xml'
+};
+
 const THREAD_SORTS = {
     NEWEST: 'newest',
     OLDEST: 'oldest',
@@ -753,6 +1227,38 @@ const THREAD_SORTS = {
     SUBJECT: 'subject'
 };
 
+const BIMI_STATUSES = {
+    PRESENT: 'present',
+    PARTIAL: 'partial',
+    ABSENT: 'absent',
+    INVALID: 'invalid'
+};
+const DELIVERABILITY_CHECK_IDS = {
+    MX: 'mx',
+    SPF: 'spf',
+    DKIM: 'dkim',
+    DMARC: 'dmarc',
+    BIMI: 'bimi'
+};
+const DELIVERABILITY_CHECK_STATUSES = {
+    PASS: 'pass',
+    WARN: 'warn',
+    FAIL: 'fail',
+    ABSENT: 'absent'
+};
+const DELIVERABILITY_GRADES = {
+    A: 'A',
+    B: 'B',
+    C: 'C',
+    D: 'D',
+    F: 'F'
+};
+const PLAN_BLOCKERS = {
+    DOMAINS: 'domains',
+    PEOPLE: 'people',
+    SENDS: 'sends'
+};
+
 const WEBHOOK_EVENTS = {
     EMAIL_RECEIVED: 'email.received',
     EMAIL_REPLIED: 'email.replied',
@@ -775,7 +1281,9 @@ const WEBHOOK_EVENTS = {
     SUPPRESSION_ADDED: 'suppression.added',
     SUPPRESSION_REMOVED: 'suppression.removed',
     FILE_UPLOADED: 'file.uploaded',
-    FILE_DELETED: 'file.deleted'
+    FILE_DELETED: 'file.deleted',
+    FORM_SUBMITTED: 'form.submitted',
+    FORM_CONFIRMED: 'form.confirmed'
 };
 const WEBHOOK_REPLAY_ERROR_CODES = {
     RESOURCE_NOT_FOUND: 'resource_not_found',
@@ -798,6 +1306,7 @@ const WEBHOOK_SIGNATURE = {
     VALUE_SEPARATOR: '=',
     TOLERANCE_SECONDS: 300
 };
+const HMAC_SIGN_USAGES = ['sign'];
 const WEBHOOK_MESSAGES = {
     MISSING_HEADER: 'Missing the X-OpenEmail-Signature header.',
     MALFORMED_HEADER: 'X-OpenEmail-Signature is not in the form t=<seconds>,v1=<hex>.',
@@ -806,6 +1315,95 @@ const WEBHOOK_MESSAGES = {
     NO_WEBCRYPTO: 'No WebCrypto is available. Verifying a webhook signature needs globalThis.crypto.subtle, which Node 20+, Bun, Deno, Cloudflare Workers and browsers over HTTPS all provide.'
 };
 
+const REWRITE_TARGETS = {
+    SUBJECT: 'subject',
+    BODY: 'body'
+};
+const REWRITE_ACTIONS = {
+    SHORTEN: 'shorten',
+    LENGTHEN: 'lengthen',
+    REPHRASE: 'rephrase',
+    FORMAL: 'formal',
+    CASUAL: 'casual',
+    CUSTOM: 'custom'
+};
+
+const SUBSCRIPTION_STATUSES = {
+    ACTIVE: 'active',
+    UNSUBSCRIBED: 'unsubscribed'
+};
+const SUBSCRIPTION_SORTS = {
+    RECENT: 'recent',
+    MOST: 'most',
+    UNREAD: 'unread',
+    NAME: 'name'
+};
+const SUBSCRIPTION_DESTINATIONS = {
+    ARCHIVE: 'archive',
+    BIN: 'bin',
+    LABEL: 'label'
+};
+const UNSUBSCRIBE_METHODS = {
+    ONE_CLICK: 'one-click',
+    EMAIL: 'email',
+    LINK: 'link'
+};
+
+const EMAIL_NOTIFICATION_CATEGORIES = {
+    ACCOUNT: 'account',
+    BILLING: 'billing',
+    ACTIVITY: 'activity',
+    PRODUCT: 'product'
+};
+const USERNAME_STATUSES = {
+    AVAILABLE: 'available',
+    CURRENT: 'current',
+    TAKEN: 'taken',
+    RESERVED: 'reserved',
+    INVALID: 'invalid',
+    TOO_SHORT: 'too_short',
+    TOO_LONG: 'too_long'
+};
+const CONNECTED_APP_KINDS = {
+    APP: 'app',
+    CLI: 'cli'
+};
+const CONNECTED_APP_STATUSES = {
+    ACTIVE: 'active',
+    EXPIRED: 'expired',
+    NEEDS_APPROVAL: 'needs-approval',
+    ACCESS_LOST: 'access-lost'
+};
+
+const WORKSPACE_KINDS = {
+    BUSINESS: 'business',
+    PERSONAL: 'personal'
+};
+
+const SETTINGS_TIME_FORMATS = {
+    H12: '12h',
+    H24: '24h'
+};
+const SETTINGS_DATE_FORMATS = {
+    DMY: 'dmy',
+    MDY: 'mdy',
+    YMD: 'ymd'
+};
+const SETTINGS_WEEK_STARTS = {
+    MONDAY: 'monday',
+    SUNDAY: 'sunday'
+};
+const SETTINGS_COLOR_THEMES = {
+    LIGHT: 'light',
+    DARK: 'dark',
+    SYSTEM: 'system'
+};
+const SETTINGS_IMAGE_COMPRESSIONS = {
+    LOW: 'low',
+    MEDIUM: 'medium',
+    ORIGINAL: 'original'
+};
+
 const PAGE_LIMITS = PAGINATION;
 const WEBHOOK_SIGNATURE_HEADERS = WEBHOOK_HEADERS;
 
@@ -819,32 +1417,325 @@ const LOOPBACK_IPV6_ADDRESS = '[::1]';
 const UNSPECIFIED_HOSTNAMES = ['0.0.0.0', '::', '[::]'];
 const LOCAL_HOSTS = [...LOOPBACK_HOSTNAMES, LOOPBACK_IPV4_ADDRESS, ...UNSPECIFIED_HOSTNAMES];
 const ENDPOINT_SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*:\/\//i;
+const TRAILING_SLASHES = /\/+$/;
 
 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]});
-
-({
+const API_PATHS = {
+    PING: '/ping',
+    LANGUAGES: '/languages',
+    EMAILS: '/emails',
+    EMAILS_BATCH: '/emails/batch',
+    EMAILS_TRANSLATE: '/emails/translate',
+    EMAILS_CHECK: '/emails/check',
+    EMAILS_COMPOSE: '/emails/compose',
+    EMAILS_REWRITE: '/emails/rewrite',
+    EMAILS_SUBJECT: '/emails/subject',
+    EMAIL: '/emails/:id',
+    EMAIL_CANCEL: '/emails/:id/cancel',
+    EMAIL_EVENTS: '/emails/:id/events',
+    EMAIL_TRACKING: '/emails/:id/tracking',
+    TRACKING: '/tracking',
+    TRACKING_STATS: '/tracking/stats',
+    TRACKED: '/tracking/:id',
+    TRACKED_OPENS: '/tracking/:id/opens',
+    TRACKED_CLICKS: '/tracking/:id/clicks',
+    TEMPLATES: '/templates',
+    TEMPLATE_FONTS: '/templates/fonts',
+    TEMPLATE_STARTERS: '/templates/starters',
+    TEMPLATE_STARTER: '/templates/starters/:slug',
+    TEMPLATE_RENDER: '/templates/render',
+    TEMPLATE_IMAGES: '/templates/images',
+    TEMPLATES_DESIGN: '/templates/design',
+    TEMPLATE_REDESIGN: '/templates/:id/redesign',
+    TEMPLATE: '/templates/:id',
+    TEMPLATE_DUPLICATE: '/templates/:id/duplicate',
+    TEMPLATE_CONTENT: '/templates/:id/content',
+    TEMPLATE_VERSIONS: '/templates/:id/versions',
+    TEMPLATE_VERSION: '/templates/:id/versions/:version',
+    TEMPLATE_VERSION_RESTORE: '/templates/:id/versions/:version/restore',
+    TEMPLATE_PREVIEW: '/templates/:id/preview',
+    TEMPLATE_ANALYTICS: '/templates/:id/analytics',
+    TEMPLATE_SENDS: '/templates/:id/sends',
+    TEMPLATE_SEND: '/templates/:id/send',
+    RULES: '/rules',
+    RULE_RUNS: '/rules/runs',
+    RULES_REORDER: '/rules/reorder',
+    RULE: '/rules/:id',
+    RULE_TEST: '/rules/:id/test',
+    THREADS: '/threads',
+    THREAD: '/threads/:id',
+    THREAD_TRASH: '/threads/:id/trash',
+    THREAD_SNOOZE: '/threads/:id/snooze',
+    THREAD_UNSNOOZE: '/threads/:id/unsnooze',
+    THREAD_MESSAGE_ATTACHMENTS: '/threads/:id/messages/:messageId/attachments',
+    THREADS_COUNTS: '/threads/counts',
+    THREAD_RESTORE: '/threads/:id/restore',
+    THREAD_SUMMARY: '/threads/:id/summary',
+    THREAD_REPLY_SUGGESTIONS: '/threads/:id/reply-suggestions',
+    THREAD_EVENT: '/threads/:id/event',
+    THREAD_NOTES: '/threads/:id/notes',
+    THREAD_NOTES_REORDER: '/threads/:id/notes/reorder',
+    THREAD_NOTE: '/threads/:id/notes/:noteId',
+    THREAD_UNSUBSCRIBE: '/threads/:id/unsubscribe',
+    DRAFTS: '/drafts',
+    DRAFT: '/drafts/:id',
+    LABELS: '/labels',
+    LABEL_COLORS: '/labels/colors',
+    LABEL: '/labels/:id',
+    CONTACTS: '/contacts',
+    CONTACTS_PEOPLE: '/contacts/people',
+    CONTACTS_BATCH_DELETE: '/contacts/batch-delete',
+    CONTACT_CARDS: '/contacts/cards',
+    CONTACT_CARD: '/contacts/cards/:id',
+    CONTACT: '/contacts/:email',
+    CONTACT_PHOTO: '/contacts/:email/photo',
+    CONTACT_BLOCK: '/contacts/:email/block',
+    CONTACT_THREADS: '/contacts/:email/threads',
+    CONTACT_ACTIVITY: '/contacts/:email/activity',
+    CONTACT_AUDIENCES: '/contacts/:email/audiences',
+    AUDIENCES: '/audiences',
+    AUDIENCES_GROWTH: '/audiences/growth',
+    AUDIENCE: '/audiences/:id',
+    AUDIENCE_CONTACTS: '/audiences/:id/contacts',
+    AUDIENCE_CONTACT: '/audiences/:id/contacts/:email',
+    AUDIENCE_CONTACTS_BATCH: '/audiences/:id/contacts/batch',
+    AUDIENCE_CONTACTS_BATCH_REMOVE: '/audiences/:id/contacts/batch-remove',
+    AUDIENCE_IMPORT: '/audiences/:id/import',
+    AUDIENCE_EMPTY: '/audiences/:id/empty',
+    FORMS: '/forms',
+    FORM_STARTERS: '/forms/starters',
+    FORM_STARTER: '/forms/starters/:slug',
+    FORM: '/forms/:id',
+    FORM_PUBLISH: '/forms/:id/publish',
+    FORM_PAUSE: '/forms/:id/pause',
+    FORM_RESUME: '/forms/:id/resume',
+    FORM_DUPLICATE: '/forms/:id/duplicate',
+    FORM_ANALYTICS: '/forms/:id/analytics',
+    FORM_SUBMISSIONS: '/forms/:id/submissions',
+    FORM_SUBMISSIONS_BATCH_REMOVE: '/forms/:id/submissions/batch-remove',
+    FORM_SUBMISSION: '/forms/:id/submissions/:submissionId',
+    FORM_SUBMISSION_APPROVE: '/forms/:id/submissions/:submissionId/approve',
+    FORM_SUBMISSION_RESEND: '/forms/:id/submissions/:submissionId/resend',
+    FORMS_DESIGN: '/forms/design',
+    FORM_REDESIGN: '/forms/:id/redesign',
+    BROADCASTS: '/broadcasts',
+    BROADCASTS_PREVIEW: '/broadcasts/preview',
+    BROADCASTS_ANALYTICS: '/broadcasts/analytics',
+    BROADCAST: '/broadcasts/:id',
+    BROADCAST_RECIPIENTS: '/broadcasts/:id/recipients',
+    BROADCAST_RECIPIENT: '/broadcasts/:id/recipients/:emailId',
+    BROADCAST_STATS: '/broadcasts/:id/stats',
+    BROADCAST_CANCEL: '/broadcasts/:id/cancel',
+    DOMAINS: '/domains',
+    DOMAIN: '/domains/:id',
+    DOMAIN_VERIFY: '/domains/:id/verify',
+    DOMAIN_LOGO: '/domains/:id/logo',
+    DOMAIN_LOGO_CERTIFICATE: '/domains/:id/logo/certificate',
+    DOMAIN_ADDRESSES: '/domains/:id/addresses',
+    DOMAIN_ADDRESS: '/domains/:id/addresses/:addressId',
+    DOMAIN_ADDRESS_PHOTO: '/domains/:id/addresses/:addressId/photo',
+    DOMAIN_ADDRESS_FORWARDS: '/domains/:id/addresses/:addressId/forwards',
+    DOMAIN_ADDRESS_FORWARD: '/domains/:id/addresses/:addressId/forwards/:forwardId',
+    DOMAIN_ADDRESS_FORWARD_RESEND: '/domains/:id/addresses/:addressId/forwards/:forwardId/resend',
+    DOMAIN_ADDRESS_MEMBERS: '/domains/:id/addresses/:addressId/members',
+    DOMAIN_ADDRESS_LOGIN: '/domains/:id/addresses/:addressId/login',
+    DOMAIN_ADDRESS_MAIL_APPS: '/domains/:id/addresses/:addressId/mail-apps',
+    DOMAIN_ADDRESS_APP_PASSWORDS: '/domains/:id/addresses/:addressId/app-passwords',
+    DOMAIN_ADDRESS_APP_PASSWORD: '/domains/:id/addresses/:addressId/app-passwords/:passwordId',
+    DOMAIN_ADDRESS_MAIL_APP_SETUP: '/domains/:id/addresses/:addressId/mail-app-setup',
+    DOMAIN_DNS: '/domains/:id/dns',
+    DOMAIN_DNS_SYNC: '/domains/:id/dns/sync',
+    DNS_CONNECTIONS: '/dns-connections',
+    DNS_CONNECTION: '/dns-connections/:id',
+    APP_HOST: '/app-host',
+    APP_HOST_VERIFY: '/app-host/verify',
+    BRANDING: '/branding',
+    BRANDING_IMAGE: '/branding/images/:variant',
+    ADDRESSES: '/addresses',
+    WEBHOOKS: '/webhooks',
+    WEBHOOKS_DELIVERIES: '/webhooks/deliveries',
+    WEBHOOKS_ACTIVITY: '/webhooks/activity',
+    WEBHOOKS_EVENTS: '/webhooks/events',
+    WEBHOOKS_STATS: '/webhooks/stats',
+    WEBHOOK: '/webhooks/:id',
+    WEBHOOK_ROTATE_SECRET: '/webhooks/:id/rotate-secret',
+    WEBHOOK_TEST: '/webhooks/:id/test',
+    WEBHOOK_DELIVERIES: '/webhooks/:id/deliveries',
+    WEBHOOK_DELIVERY: '/webhooks/:id/deliveries/:deliveryId',
+    WEBHOOK_DELIVERY_REPLAY: '/webhooks/:id/deliveries/:deliveryId/replay',
+    WEBHOOK_ACTIVITY: '/webhooks/:id/activity',
+    IMPORTS: '/imports',
+    IMPORT: '/imports/:id',
+    IMPORT_UPLOAD: '/imports/:id/upload',
+    IMPORT_FILE_CHUNK: '/imports/:id/files/:file/chunks/:chunk',
+    IMPORT_START: '/imports/:id/start',
+    IMPORT_CANCEL: '/imports/:id/cancel',
+    IMPORT_FAILURES: '/imports/:id/failures',
+    PROVIDER_IMPORTS: '/provider-imports',
+    PROVIDER_IMPORTS_INSPECT: '/provider-imports/inspect',
+    PROVIDER_IMPORT: '/provider-imports/:id',
+    PROVIDER_IMPORT_CANCEL: '/provider-imports/:id/cancel',
+    CALENDAR_EVENTS: '/calendar/events',
+    CALENDAR_EVENT: '/calendar/events/:id',
+    CALENDAR_EVENT_ICS: '/calendar/events/:id/ics',
+    CALENDAR_EVENT_CANCEL: '/calendar/events/:id/cancel',
+    CALENDAR_EVENT_RESPOND: '/calendar/events/:id/respond',
+    CALENDAR_EVENT_DECLINE_PROPOSAL: '/calendar/events/:id/decline-proposal',
+    CALENDAR_FEEDS: '/calendar/feeds',
+    CALENDAR_FEED: '/calendar/feeds/:id',
+    CALENDAR_FEED_RESET: '/calendar/feeds/:id/reset',
+    CALENDAR_SUBSCRIPTIONS: '/calendar/subscriptions',
+    CALENDAR_SUBSCRIPTION: '/calendar/subscriptions/:id',
+    CALENDAR_SUBSCRIPTION_REFRESH: '/calendar/subscriptions/:id/refresh',
+    SETTINGS: '/settings',
+    ROLES: '/roles',
+    ROLE_PERMISSIONS: '/roles/permissions',
+    ROLE: '/roles/:id',
+    MEMBERS: '/members',
+    MEMBER: '/members/:userId',
+    MEMBER_ADDRESSES: '/members/:userId/addresses',
+    MEMBER_ADDRESS: '/members/:userId/addresses/:addressId',
+    MEMBER_DOMAINS: '/members/:userId/domains',
+    MEMBER_DOMAIN: '/members/:userId/domains/:domainId',
+    MEMBER_INVITATIONS: '/members/invitations',
+    MEMBER_INVITATION: '/members/invitations/:invitationId',
+    MEMBER_INVITATION_RESEND: '/members/invitations/:invitationId/resend',
+    KEYS: '/keys',
+    KEYS_REQUESTS: '/keys/requests',
+    KEYS_ACTIVITY: '/keys/activity',
+    KEYS_STATS: '/keys/stats',
+    KEY_SELF: '/keys/self',
+    KEY_SELF_ROTATE: '/keys/self/rotate',
+    KEY: '/keys/:id',
+    KEY_ROTATE: '/keys/:id/rotate',
+    KEY_REVOKE: '/keys/:id/revoke',
+    KEY_REQUESTS: '/keys/:id/requests',
+    KEY_ACTIVITY: '/keys/:id/activity',
+    SUPPRESSIONS: '/suppressions',
+    SUPPRESSION: '/suppressions/:id',
+    FILES: '/files',
+    FILES_STATS: '/files/stats',
+    FILES_BATCH_DELETE: '/files/batch-delete',
+    FILE: '/files/:id',
+    FILE_CONTENT: '/files/:id/content',
+    FILE_LINKS: '/files/:id/links',
+    FILE_LINK: '/files/:id/links/:linkId',
+    KNOWLEDGE: '/knowledge',
+    KNOWLEDGE_LEVELS: '/knowledge/levels',
+    KNOWLEDGE_USAGE: '/knowledge/usage',
+    KNOWLEDGE_SEARCH: '/knowledge/search',
+    KNOWLEDGE_NOTES: '/knowledge/notes',
+    KNOWLEDGE_LINKS: '/knowledge/links',
+    KNOWLEDGE_FILES: '/knowledge/files',
+    KNOWLEDGE_ITEM: '/knowledge/:id',
+    KNOWLEDGE_ITEM_REFRESH: '/knowledge/:id/refresh',
+    KNOWLEDGE_SUGGESTIONS: '/knowledge/suggestions',
+    KNOWLEDGE_SUGGESTION_ACCEPT: '/knowledge/suggestions/:id/accept',
+    KNOWLEDGE_SUGGESTION_DISMISS: '/knowledge/suggestions/:id/dismiss',
+    KNOWLEDGE_FLAGS: '/knowledge/flags',
+    KNOWLEDGE_FLAG_DISMISS: '/knowledge/flags/:id/dismiss',
+    KNOWLEDGE_CONNECTORS: '/knowledge/connectors',
+    KNOWLEDGE_CONNECTOR: '/knowledge/connectors/:id',
+    KNOWLEDGE_CONNECTOR_SYNC: '/knowledge/connectors/:id/sync',
+    KNOWLEDGE_DRAFTS: '/knowledge/drafts',
+    KNOWLEDGE_STATS: '/knowledge/stats',
+    SECURITY_STEP_UP: '/security/step-up',
+    SECURITY_STEP_UP_VERIFY: '/security/step-up/verify',
+    SENDER: '/senders/:email',
+    SENDER_RESEARCH: '/senders/:email/research',
+    ANALYTICS_MAILBOX: '/analytics/mailbox',
+    ANALYTICS_SENDING: '/analytics/sending',
+    CHATS: '/chats',
+    CHAT: '/chats/:id',
+    MAILBOX_EXPORTS: '/exports',
+    MAILBOX_EXPORTS_PREVIEW: '/exports/preview',
+    MAILBOX_EXPORT: '/exports/:id',
+    MAILBOX_EXPORT_CONTENT: '/exports/:id/content',
+    ENCRYPTION_KEYS: '/encryption/keys',
+    ENCRYPTION_KEYS_LOOKUP: '/encryption/keys/lookup',
+    BILLING: '/billing',
+    BILLING_PLANS: '/billing/plans',
+    BILLING_USAGE: '/billing/usage',
+    BILLING_ALERTS: '/billing/alerts',
+    BILLING_COUNTRIES: '/billing/countries',
+    BILLING_PAY_AS_YOU_GO: '/billing/pay-as-you-go',
+    BILLING_PAY_AS_YOU_GO_LIMIT: '/billing/pay-as-you-go/limit',
+    BILLING_PAY_AS_YOU_GO_CONFIRM: '/billing/pay-as-you-go/confirm',
+    BILLING_CHECKOUT: '/billing/checkout',
+    BILLING_PORTAL: '/billing/portal',
+    BILLING_INVOICES: '/billing/invoices',
+    BILLING_INVOICE: '/billing/invoices/:orderId',
+    BILLING_INVOICE_DETAILS: '/billing/invoices/:orderId/details',
+    SUPPORT: '/support',
+    TOOLS_DMARC: '/tools/dmarc',
+    TOOLS_BIMI: '/tools/bimi',
+    TOOLS_DELIVERABILITY: '/tools/deliverability',
+    TOOLS_VERIFICATION_CODE: '/tools/verification-code',
+    TOOLS_COST: '/tools/cost',
+    SUBSCRIPTIONS: '/subscriptions',
+    SUBSCRIPTION_UNSUBSCRIBE: '/subscriptions/:id/unsubscribe',
+    SUBSCRIPTION_MOVE: '/subscriptions/:id/move',
+    SUBSCRIPTION_DOMAINS: '/subscriptions/domains',
+    SUBSCRIPTION_DOMAIN_UNSUBSCRIBE: '/subscriptions/domains/:domain/unsubscribe',
+    WORKSPACES: '/workspaces',
+    WORKSPACES_ACTIVE: '/workspaces/active',
+    WORKSPACE: '/workspaces/:id',
+    ACCOUNT_NOTIFICATIONS: '/account/notifications',
+    ACCOUNT_NOTIFICATION_EMAIL: '/account/notifications/email/:category',
+    ACCOUNT_NOTIFICATION_PUSH: '/account/notifications/push/:workspaceId',
+    ACCOUNT_PHOTO: '/account/photo',
+    ACCOUNT_USERNAME: '/account/username',
+    ACCOUNT_USERNAME_AVAILABILITY: '/account/username/availability',
+    ACCOUNT_CONNECTED_APPS: '/account/connected-apps',
+    ACCOUNT_CONNECTED_APP: '/account/connected-apps/:clientId',
+    ACCOUNT_INVITATIONS: '/account/invitations',
+    ACCOUNT_INVITATION_ACCEPT: '/account/invitations/:invitationId/accept',
+    ACCOUNT_INVITATION_DECLINE: '/account/invitations/:invitationId/decline',
+    TEMP_MAIL_DOMAINS: '/temp-mail/domains',
+    TEMP_MAIL_INBOXES: '/temp-mail/inboxes',
+    TEMP_MAIL_INBOX: '/temp-mail/inboxes/:id',
+    TEMP_MAIL_INBOX_EXTEND: '/temp-mail/inboxes/:id/extend',
+    TEMP_MAIL_MESSAGES: '/temp-mail/inboxes/:id/messages',
+    TEMP_MAIL_MESSAGE: '/temp-mail/inboxes/:id/messages/:messageId',
+    TEMP_MAIL_MESSAGE_ATTACHMENTS: '/temp-mail/inboxes/:id/messages/:messageId/attachments',
+    SUBSCRIBE_FORM: '/subscribe/:formId'};
+
+const PATH_PARAM = /:([A-Za-z0-9_]+)(?:\{[^}]*\})?/g;
+const OPTIONAL_PATH_PARAM = /\/:([A-Za-z0-9_]+)\?/g;
+const fillPath = (pattern, params) => {
+    const values = params;
+    return pattern
+        .replace(OPTIONAL_PATH_PARAM, (_, name) => {
+        const value = values[name];
+        return value === undefined || value === '' ? '' : `/${encodeURIComponent(String(value))}`;
+    })
+        .replace(PATH_PARAM, (_, name) => encodeURIComponent(String(values[name] ?? '')));
+};
+
+({
+    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]});
 
 ({
@@ -972,8 +1863,10 @@ class OpenEmailApiError extends Error {
     docUrl;
     requestId;
     retryAfterSeconds;
+    fields;
+    body;
     constructor(props) {
-        const { message, status, type, code, param, docUrl, requestId, retryAfterSeconds } = props;
+        const { message, status, type, code, param, docUrl, requestId, retryAfterSeconds, fields, body } = props;
         super(message);
         this.name = ERROR_NAMES.API;
         this.status = status;
@@ -983,6 +1876,8 @@ class OpenEmailApiError extends Error {
         this.docUrl = docUrl;
         this.requestId = requestId;
         this.retryAfterSeconds = retryAfterSeconds;
+        this.fields = fields;
+        this.body = body;
     }
     get isAuth() {
         return this.type === ERROR_TYPES.AUTHENTICATION_ERROR;
@@ -1032,7 +1927,7 @@ class OpenEmailNetworkError extends Error {
 let checked = false;
 const Parts = (value) => value
     .trim()
-    .replace(/^v/, '')
+    .replace(VERSION_TAG_PREFIX, '')
     .split('.')
     .map(part => Number.parseInt(part, 10));
 const IsNewer = (candidate, current) => {
@@ -1095,20 +1990,18 @@ const Backoff = (attempt) => {
     return Math.round(ceiling * (0.5 + Math.random() * 0.5));
 };
 
-const PATH_SHAPE = 'is not a usable request path. Pass a path on the API that begins with a single "/", such as "/threads". Anything else could send the request, and the credential it carries, to another host.';
-const OFF_ORIGIN = 'leaves the API origin, so the request was not sent. Pass a path on the API that begins with a single "/", such as "/threads".';
 const ApiUrl = (baseUrl, path) => {
     if (typeof path !== 'string' || !path.startsWith('/') || path.startsWith('//') || path.startsWith('/\\')) {
-        throw new Error(`${JSON.stringify(path)} ${PATH_SHAPE}`);
+        throw new Error(`${JSON.stringify(path)} ${CLIENT_MESSAGES.PATH_SHAPE}`);
     }
-    const url = `${baseUrl.replace(/\/+$/, '')}${path}`;
+    const url = `${baseUrl.replace(TRAILING_SLASHES, '')}${path}`;
     let origin = null;
     try {
         origin = new URL(url).origin;
     }
     catch { }
     if (origin === null || origin !== new URL(baseUrl).origin)
-        throw new Error(`${JSON.stringify(path)} ${OFF_ORIGIN}`);
+        throw new Error(`${JSON.stringify(path)} ${CLIENT_MESSAGES.OFF_ORIGIN}`);
     return url;
 };
 
@@ -1226,6 +2119,11 @@ const ReadPayload = (body) => {
     return typeof error === 'object' && error !== null ? error : {};
 };
 const Text = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
+const IsFieldProblem = (value) => typeof value === 'object'
+    && value !== null
+    && typeof value.key === 'string'
+    && typeof value.error === 'string';
+const Fields = (value) => Array.isArray(value) ? value.filter(IsFieldProblem) : undefined;
 const ToErrorProps = (response, body, rawText, retryAfterSeconds) => {
     const payload = ReadPayload(body);
     return {
@@ -1237,14 +2135,16 @@ const ToErrorProps = (response, body, rawText, retryAfterSeconds) => {
         param: Text(payload.param),
         docUrl: Text(payload.docUrl),
         requestId: Text(payload.requestId) ?? response.headers.get(HEADER_KEYS.REQUEST_ID) ?? undefined,
-        retryAfterSeconds
+        retryAfterSeconds,
+        fields: Fields(payload.fields),
+        body
     };
 };
 
 const Substitute = (url) => {
     const suggestion = new URL(url.href);
     suggestion.hostname = url.hostname.startsWith('[') ? LOOPBACK_IPV6_ADDRESS : LOOPBACK_IPV4_ADDRESS;
-    return suggestion.href.replace(/\/+$/, '');
+    return suggestion.href.replace(TRAILING_SLASHES, '');
 };
 const UnspecifiedHostMessage = (baseUrl, url) => `${JSON.stringify(baseUrl)} names ${url.hostname}, an address a server listens on, not one to send requests to. For a server on this machine, use ${Substitute(url)}.`;
 
@@ -1269,7 +2169,7 @@ const ParseBaseUrl = (value) => {
     }
 };
 const ValidBaseUrl = (value) => {
-    const trimmed = value.trim().replace(/\/+$/, '');
+    const trimmed = value.trim().replace(TRAILING_SLASHES, '');
     const parsed = ParseBaseUrl(trimmed);
     if (!parsed)
         throw new Error(`${JSON.stringify(value)} ${CLIENT_MESSAGES.BASE_URL_SHAPE}`);
@@ -1465,75 +2365,9 @@ const FetchList = async (transport, path, options = {}, query) => {
     return (payload?.data ?? []);
 };
 
-const Segment = (value) => {
-    if (typeof value !== 'string' || value.length === 0)
-        throw new Error(CLIENT_MESSAGES.EMPTY_SEGMENT);
-    if (/^\.+$/.test(value))
-        throw new Error(`${JSON.stringify(value)} ${CLIENT_MESSAGES.DOT_SEGMENT}`);
-    return encodeURIComponent(value);
-};
-const EmailPath = (id) => `${PATHS.EMAILS}/${Segment(id)}`;
-const EmailChildPath = (id, segment) => `${EmailPath(id)}/${segment}`;
-const ThreadPath = (id) => `${PATHS.THREADS}/${Segment(id)}`;
-const ThreadChildPath = (id, segment) => `${ThreadPath(id)}/${segment}`;
-const ThreadMessageAttachmentsPath = (id, messageId) => `${ThreadPath(id)}/${SEGMENTS.MESSAGES}/${Segment(messageId)}/${SEGMENTS.ATTACHMENTS}`;
-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 BroadcastRecipientPath = (id, emailId) => `${BroadcastChildPath(id, SEGMENTS.RECIPIENTS)}/${Segment(emailId)}`;
-const DomainPath = (id) => `${PATHS.DOMAINS}/${Segment(id)}`;
-const DomainChildPath = (id, segment) => `${DomainPath(id)}/${segment}`;
-const DomainAddressesPath = (id) => `${DomainPath(id)}/${SEGMENTS.ADDRESSES}`;
-const DomainAddressPath = (id, addressId) => `${DomainAddressesPath(id)}/${Segment(addressId)}`;
-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)}`;
-const TrackingChildPath = (id, segment) => `${TrackingPath(id)}/${segment}`;
-const CalendarEventPath = (id) => `${PATHS.CALENDAR_EVENTS}/${Segment(id)}`;
-const CalendarEventIcsPath = (id) => `${CalendarEventPath(id)}/${SEGMENTS.ICS}`;
-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 FileLinkPath = (id, linkId) => `${FileChildPath(id, SEGMENTS.LINKS)}/${Segment(linkId)}`;
-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, {
+        const envelope = await transport.request(API_PATHS.ADDRESSES, {
             query: { [QUERY_KEYS.LIMIT]: options.limit, [CURSOR_STYLES.CURSOR.PARAM]: options.cursor },
             signal: options.signal,
             apiKey: options.apiKey
@@ -1550,18 +2384,56 @@ const Addresses = (transport) => {
     return {
         list: page,
         listAll: async (options = {}) => {
+            let cursor = options.cursor;
             let current = await page(options);
             const addresses = [...current.addresses];
-            while (current.hasMore && current.nextCursor) {
-                current = await page({ ...options, cursor: current.nextCursor });
+            while (current.hasMore && current.nextCursor && current.nextCursor !== cursor) {
+                cursor = current.nextCursor;
+                current = await page({ ...options, cursor });
                 addresses.push(...current.addresses);
             }
             return { unrestricted: current.unrestricted, addresses, domains: current.domains };
         },
-        iterate: (options = {}) => IteratePages(transport, PATHS.ADDRESSES, CURSOR_STYLES.CURSOR, options)
+        iterate: (options = {}) => IteratePages(transport, API_PATHS.ADDRESSES, CURSOR_STYLES.CURSOR, options)
     };
 };
 
+const AppHost = (transport) => ({
+    get: (options = {}) => transport.request(API_PATHS.APP_HOST, { signal: options.signal, apiKey: options.apiKey }),
+    set: (body, options = {}) => transport.request(API_PATHS.APP_HOST, {
+        method: HTTP_METHODS.PUT,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    verify: (options = {}) => transport.request(API_PATHS.APP_HOST_VERIFY, {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (options = {}) => transport.request(API_PATHS.APP_HOST, {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const AssertSegment = (value) => {
+    if ((typeof value !== 'string' && typeof value !== 'number') || String(value).length === 0)
+        throw new Error(CLIENT_MESSAGES.EMPTY_SEGMENT);
+    if (DOT_ONLY_SEGMENT.test(String(value)))
+        throw new Error(`${JSON.stringify(String(value))} ${CLIENT_MESSAGES.DOT_SEGMENT}`);
+};
+const RequestPath = (pattern, params) => {
+    const values = params;
+    for (const [, name] of pattern.matchAll(PATH_PARAM))
+        AssertSegment(values[name]);
+    return fillPath(pattern, params);
+};
+
 const MemberQuery = (options) => ({
     [QUERY_KEYS.Q]: options.q,
     [QUERY_KEYS.SOURCE]: options.source,
@@ -1576,70 +2448,162 @@ const GrowthQuery = (options) => ({
     [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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.AUDIENCES, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.AUDIENCES, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.AUDIENCES, CURSOR_STYLES.CURSOR, options),
+    growth: (options = {}) => transport.request(API_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, {
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.AUDIENCES, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, patch, options = {}) => transport.request(AudiencePath(id), {
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(AudiencePath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    empty: (id, options = {}) => transport.request(AudienceChildPath(id, SEGMENTS.EMPTY), {
+    empty: (id, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE_EMPTY, { id }), {
         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), {
+    listContacts: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.AUDIENCE_CONTACTS, { id }), CURSOR_STYLES.CURSOR, options, MemberQuery(options)),
+    listAllContacts: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.AUDIENCE_CONTACTS, { id }), CURSOR_STYLES.CURSOR, options, MemberQuery(options)),
+    iterateContacts: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.AUDIENCE_CONTACTS, { id }), CURSOR_STYLES.CURSOR, options, MemberQuery(options)),
+    addContact: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE_CONTACTS, { id }), {
         method: HTTP_METHODS.POST,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    removeContact: (id, email, options = {}) => transport.request(AudienceContactPath(id, email), {
+    removeContact: (id, email, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE_CONTACT, { id, email }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    addContacts: (id, body, options = {}) => transport.request(AudienceContactsChildPath(id, SEGMENTS.BATCH), {
+    addContacts: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE_CONTACTS_BATCH, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removeContacts: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE_CONTACTS_BATCH_REMOVE, { id }), {
         method: HTTP_METHODS.POST,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    removeContacts: (id, body, options = {}) => transport.request(AudienceContactsChildPath(id, SEGMENTS.BATCH_REMOVE), {
+    importContacts: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.AUDIENCE_IMPORT, { id }), {
         method: HTTP_METHODS.POST,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
+    })
+});
+
+const Billing = (transport) => ({
+    get: (options = {}) => transport.request(API_PATHS.BILLING, { signal: options.signal, apiKey: options.apiKey }),
+    listPlans: (options = {}) => transport.request(API_PATHS.BILLING_PLANS, { signal: options.signal, apiKey: options.apiKey }),
+    getUsage: (options = {}) => transport.request(API_PATHS.BILLING_USAGE, {
+        query: { [QUERY_KEYS.DAYS]: options.days },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listAlerts: (options = {}) => transport.request(API_PATHS.BILLING_ALERTS, { signal: options.signal, apiKey: options.apiKey }),
+    listCountries: (options = {}) => transport.request(API_PATHS.BILLING_COUNTRIES, { signal: options.signal, apiKey: options.apiKey }),
+    getPayAsYouGo: (options = {}) => transport.request(API_PATHS.BILLING_PAY_AS_YOU_GO, { signal: options.signal, apiKey: options.apiKey }),
+    setPayAsYouGo: (body, options = {}) => transport.request(API_PATHS.BILLING_PAY_AS_YOU_GO, {
+        method: HTTP_METHODS.PATCH,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setPayAsYouGoLimit: (body, options = {}) => transport.request(API_PATHS.BILLING_PAY_AS_YOU_GO_LIMIT, {
+        method: HTTP_METHODS.PUT,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    confirmPayAsYouGo: (options = {}) => transport.request(API_PATHS.BILLING_PAY_AS_YOU_GO_CONFIRM, {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    startCheckout: (body, options = {}) => transport.request(API_PATHS.BILLING_CHECKOUT, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
     }),
-    importContacts: (id, body, options = {}) => transport.request(AudienceChildPath(id, SEGMENTS.IMPORT), {
+    openPortal: (body = {}, options = {}) => transport.request(API_PATHS.BILLING_PORTAL, {
         method: HTTP_METHODS.POST,
         body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listInvoices: (options = {}) => transport.request(API_PATHS.BILLING_INVOICES, {
+        query: {
+            [QUERY_KEYS.PAGE]: options.page,
+            [QUERY_KEYS.LIMIT]: options.limit,
+            [QUERY_KEYS.SORT]: options.sort,
+            [QUERY_KEYS.SEARCH]: options.search
+        },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    getInvoice: (orderId, options = {}) => transport.request(RequestPath(API_PATHS.BILLING_INVOICE, { orderId }), {
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    saveInvoiceDetails: (orderId, body, options = {}) => transport.request(RequestPath(API_PATHS.BILLING_INVOICE_DETAILS, { orderId }), {
+        method: HTTP_METHODS.PUT,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const ImageType = (data, options) => {
+    if (options.contentType)
+        return options.contentType;
+    return typeof Blob !== 'undefined' && data instanceof Blob && data.type ? data.type : undefined;
+};
+const Branding = (transport) => ({
+    get: (options = {}) => transport.request(API_PATHS.BRANDING, { signal: options.signal, apiKey: options.apiKey }),
+    update: (body, options = {}) => transport.request(API_PATHS.BRANDING, {
+        method: HTTP_METHODS.PATCH,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    uploadImage: (variant, data, options = {}) => transport.request(RequestPath(API_PATHS.BRANDING_IMAGE, { variant }), {
+        method: HTTP_METHODS.PUT,
+        raw: data,
+        contentType: ImageType(data, options),
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removeImage: (variant, options = {}) => transport.request(RequestPath(API_PATHS.BRANDING_IMAGE, { variant }), {
+        method: HTTP_METHODS.DELETE,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
@@ -1683,25 +2647,39 @@ const TemplateSendToWire = (body) => ({
     bcc: Many(body.bcc),
     scheduledAt: Instant(body.scheduledAt)
 });
+const EmailUpdateToWire = (patch) => ({
+    ...patch,
+    to: Many(patch.to),
+    cc: Many(patch.cc),
+    bcc: Many(patch.bcc),
+    scheduledAt: Instant(patch.scheduledAt)
+});
 const ToInstant = Instant;
 
-const ListQuery$a = (options) => ({
+const ListQuery$d = (options) => ({
     [QUERY_KEYS.AUDIENCE_ID]: options.audienceId
 });
 const RecipientQuery = (options) => ({
     [QUERY_KEYS.FILTER]: options.filter,
     [QUERY_KEYS.Q]: options.q
 });
-const RecipientsPath = (id) => BroadcastChildPath(id, SEGMENTS.RECIPIENTS);
+const RecipientsPath = (id) => RequestPath(API_PATHS.BROADCAST_RECIPIENTS, { id });
+const AnalyticsQuery = (options) => ({
+    [QUERY_KEYS.BROADCAST_IDS]: options.broadcastIds?.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 Broadcasts = (transport) => ({
-    preview: (body, options = {}) => transport.request(PATHS.BROADCASTS_PREVIEW, {
+    preview: (body, options = {}) => transport.request(API_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, {
+    send: (body, options = {}) => transport.request(API_PATHS.BROADCASTS, {
         method: HTTP_METHODS.POST,
         body: { ...body, scheduledAt: ToInstant(body.scheduledAt) },
         idempotent: true,
@@ -1710,26 +2688,33 @@ const Broadcasts = (transport) => ({
         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 }),
+    list: (options = {}) => FetchPage(transport, API_PATHS.BROADCASTS, CURSOR_STYLES.CURSOR, options, ListQuery$d(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.BROADCASTS, CURSOR_STYLES.CURSOR, options, ListQuery$d(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.BROADCASTS, CURSOR_STYLES.CURSOR, options, ListQuery$d(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.BROADCAST, { id }), { signal: options.signal, apiKey: options.apiKey }),
     listRecipients: (id, options = {}) => FetchPage(transport, RecipientsPath(id), CURSOR_STYLES.CURSOR, options, RecipientQuery(options)),
     listAllRecipients: (id, options = {}) => CollectAll(transport, RecipientsPath(id), CURSOR_STYLES.CURSOR, options, RecipientQuery(options)),
     iterateRecipients: (id, options = {}) => IteratePages(transport, RecipientsPath(id), CURSOR_STYLES.CURSOR, options, RecipientQuery(options)),
-    getRecipient: (id, emailId, options = {}) => transport.request(BroadcastRecipientPath(id, emailId), {
+    getRecipient: (id, emailId, options = {}) => transport.request(RequestPath(API_PATHS.BROADCAST_RECIPIENT, { id, emailId }), {
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    stats: (id, options = {}) => transport.request(BroadcastChildPath(id, SEGMENTS.STATS), {
+    stats: (id, options = {}) => transport.request(RequestPath(API_PATHS.BROADCAST_STATS, { id }), {
         query: {
             [QUERY_KEYS.GRAIN]: options.grain,
-            [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+            [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes,
+            [QUERY_KEYS.DAYS]: options.days,
+            [QUERY_KEYS.MINUTES]: options.minutes
         },
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    cancel: (id, options = {}) => transport.request(BroadcastChildPath(id, SEGMENTS.CANCEL), {
+    analytics: (options = {}) => transport.request(API_PATHS.BROADCASTS_ANALYTICS, {
+        query: AnalyticsQuery(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    cancel: (id, options = {}) => transport.request(RequestPath(API_PATHS.BROADCAST_CANCEL, { id }), {
         method: HTTP_METHODS.POST,
         repeatable: true,
         signal: options.signal,
@@ -1742,22 +2727,111 @@ const RangeQuery = (options) => ({
     [QUERY_KEYS.TO]: ToInstant(options.to),
     [QUERY_KEYS.TIMEZONE]: options.timezone
 });
+const EventWire = (body) => ({
+    ...body,
+    start: ToInstant(body.start),
+    end: ToInstant(body.end)
+});
+const AnswerWire = (body) => ({
+    ...body,
+    ...(body.proposedStart !== undefined ? { proposedStart: ToInstant(body.proposedStart) } : {}),
+    ...(body.proposedEnd !== undefined ? { proposedEnd: ToInstant(body.proposedEnd) } : {})
+});
 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), {
+    listEvents: (options) => FetchPage(transport, API_PATHS.CALENDAR_EVENTS, CURSOR_STYLES.CURSOR, options, RangeQuery(options)),
+    listAllEvents: (options) => CollectAll(transport, API_PATHS.CALENDAR_EVENTS, CURSOR_STYLES.CURSOR, options, RangeQuery(options)),
+    iterateEvents: (options) => IteratePages(transport, API_PATHS.CALENDAR_EVENTS, CURSOR_STYLES.CURSOR, options, RangeQuery(options)),
+    getEvent: (id, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_EVENT, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    getEventIcs: (id, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_EVENT_ICS, { id }), {
         accept: CONTENT_TYPES.CALENDAR,
         signal: options.signal,
         apiKey: options.apiKey
+    }),
+    createEvent: (body, options = {}) => transport.request(API_PATHS.CALENDAR_EVENTS, {
+        method: HTTP_METHODS.POST,
+        body: EventWire(body),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    updateEvent: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_EVENT, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: EventWire(patch),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteEvent: (id, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_EVENT, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    cancelEvent: (id, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_EVENT_CANCEL, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    respondToEvent: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_EVENT_RESPOND, { id }), {
+        method: HTTP_METHODS.POST,
+        body: AnswerWire(body),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    declineProposal: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_EVENT_DECLINE_PROPOSAL, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listFeeds: (options = {}) => FetchList(transport, API_PATHS.CALENDAR_FEEDS, options),
+    createFeed: (body, options = {}) => transport.request(API_PATHS.CALENDAR_FEEDS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    resetFeed: (id, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_FEED_RESET, { id }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteFeed: (id, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_FEED, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listSubscriptions: (options = {}) => FetchList(transport, API_PATHS.CALENDAR_SUBSCRIPTIONS, options),
+    createSubscription: (body, options = {}) => transport.request(API_PATHS.CALENDAR_SUBSCRIPTIONS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    updateSubscription: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_SUBSCRIPTION, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    refreshSubscription: (id, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_SUBSCRIPTION_REFRESH, { id }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteSubscription: (id, options = {}) => transport.request(RequestPath(API_PATHS.CALENDAR_SUBSCRIPTION, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
     })
 });
 
-const ListQuery$9 = (options) => ({
+const ListQuery$c = (options) => ({
     [QUERY_KEYS.SOURCE]: options.source,
     [QUERY_KEYS.Q]: options.q
 });
+const CardQuery = (options) => ({
+    [QUERY_KEYS.EMAIL]: options.email,
+    [QUERY_KEYS.WITHOUT_EMAIL]: options.withoutEmail === undefined ? undefined : String(options.withoutEmail)
+});
 const PeopleQuery = (options) => ({
     [QUERY_KEYS.Q]: options.q,
     [QUERY_KEYS.EMAIL]: options.email,
@@ -1773,35 +2847,35 @@ const ActivityQuery = (options) => ({
     [QUERY_KEYS.GRAIN]: options.grain,
     [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
 });
-const PhotoType = (data, options) => {
+const PhotoType$2 = (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 = {}) => 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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.CONTACTS, CURSOR_STYLES.CURSOR, options, ListQuery$c(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.CONTACTS, CURSOR_STYLES.CURSOR, options, ListQuery$c(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.CONTACTS, CURSOR_STYLES.CURSOR, options, ListQuery$c(options)),
+    get: (email, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT, { email }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.CONTACTS, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (email, patch, options = {}) => transport.request(ContactPath(email), {
+    update: (email, patch, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT, { email }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (email, options = {}) => transport.request(ContactPath(email), {
+    delete: (email, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT, { email }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    setAudiences: (email, body, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.AUDIENCES), {
+    setAudiences: (email, body, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_AUDIENCES, { email }), {
         method: HTTP_METHODS.PUT,
         body,
         repeatable: true,
@@ -1809,7 +2883,7 @@ const Contacts = (transport) => ({
         apiKey: options.apiKey
     }),
     listPeople: async (options = {}) => {
-        const payload = await transport.request(PATHS.CONTACTS_PEOPLE, {
+        const payload = await transport.request(API_PATHS.CONTACTS_PEOPLE, {
             query: {
                 ...PeopleQuery(options),
                 [QUERY_KEYS.LIMIT]: options.limit,
@@ -1827,144 +2901,301 @@ const Contacts = (transport) => ({
             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), {
+    listAllPeople: (options = {}) => CollectAll(transport, API_PATHS.CONTACTS_PEOPLE, CURSOR_STYLES.CURSOR, options, PeopleQuery(options)),
+    iteratePeople: (options = {}) => IteratePages(transport, API_PATHS.CONTACTS_PEOPLE, CURSOR_STYLES.CURSOR, options, PeopleQuery(options)),
+    save: (email, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT, { email }), {
         method: HTTP_METHODS.PUT,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    deleteMany: (emails, options = {}) => transport.request(PATHS.CONTACTS_BATCH_DELETE, {
+    deleteMany: (emails, options = {}) => transport.request(API_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), {
+    setPhoto: (email, data, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_PHOTO, { email }), {
         method: HTTP_METHODS.PUT,
         raw: data,
-        contentType: PhotoType(data, options),
+        contentType: PhotoType$2(data, options),
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    removePhoto: (email, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.PHOTO), {
+    removePhoto: (email, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_PHOTO, { email }), {
         method: HTTP_METHODS.DELETE,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    block: (email, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.BLOCK), {
+    block: (email, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_BLOCK, { email }), {
         method: HTTP_METHODS.POST,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    unblock: (email, options = {}) => transport.request(ContactChildPath(email, SEGMENTS.BLOCK), {
+    unblock: (email, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_BLOCK, { email }), {
         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), {
+    listThreads: (email, options = {}) => FetchPage(transport, RequestPath(API_PATHS.CONTACT_THREADS, { email }), CURSOR_STYLES.CURSOR, options, ThreadQuery(options)),
+    listAllThreads: (email, options = {}) => CollectAll(transport, RequestPath(API_PATHS.CONTACT_THREADS, { email }), CURSOR_STYLES.CURSOR, options, ThreadQuery(options)),
+    iterateThreads: (email, options = {}) => IteratePages(transport, RequestPath(API_PATHS.CONTACT_THREADS, { email }), CURSOR_STYLES.CURSOR, options, ThreadQuery(options)),
+    activity: (email, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_ACTIVITY, { email }), {
         query: ActivityQuery(options),
         signal: options.signal,
         apiKey: options.apiKey
+    }),
+    listCards: (options = {}) => FetchPage(transport, API_PATHS.CONTACT_CARDS, CURSOR_STYLES.CURSOR, options, CardQuery(options)),
+    listAllCards: (options = {}) => CollectAll(transport, API_PATHS.CONTACT_CARDS, CURSOR_STYLES.CURSOR, options, CardQuery(options)),
+    iterateCards: (options = {}) => IteratePages(transport, API_PATHS.CONTACT_CARDS, CURSOR_STYLES.CURSOR, options, CardQuery(options)),
+    getCard: (id, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_CARD, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    createCard: (body, options = {}) => transport.request(API_PATHS.CONTACT_CARDS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    updateCard: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_CARD, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteCard: (id, options = {}) => transport.request(RequestPath(API_PATHS.CONTACT_CARD, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
     })
 });
 
+const PhotoType$1 = (data, options) => {
+    if (options.contentType)
+        return options.contentType;
+    return typeof Blob !== 'undefined' && data instanceof Blob && data.type ? data.type : undefined;
+};
 const Domains = (transport) => ({
-    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 }),
-    create: (body, options = {}) => transport.request(PATHS.DOMAINS, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.DOMAINS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.DOMAINS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.DOMAINS, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.DOMAINS, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    verify: (id, options = {}) => transport.request(DomainChildPath(id, SEGMENTS.VERIFY), {
+    verify: (id, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_VERIFY, { id }), {
         method: HTTP_METHODS.POST,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, patch, options = {}) => transport.request(DomainPath(id), {
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(DomainPath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    listAddresses: (id, options = {}) => FetchPage(transport, DomainAddressesPath(id), CURSOR_STYLES.CURSOR, options),
-    listAllAddresses: (id, options = {}) => CollectAll(transport, DomainAddressesPath(id), CURSOR_STYLES.CURSOR, options),
-    iterateAddresses: (id, options = {}) => IteratePages(transport, DomainAddressesPath(id), CURSOR_STYLES.CURSOR, options),
-    createAddress: (id, body, options = {}) => transport.request(DomainAddressesPath(id), {
-        method: HTTP_METHODS.POST,
+    getLogo: (id, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_LOGO, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    setLogo: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_LOGO, { id }), {
+        method: HTTP_METHODS.PUT,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    getAddress: (id, addressId, options = {}) => transport.request(DomainAddressPath(id, addressId), { signal: options.signal, apiKey: options.apiKey }),
-    updateAddress: (id, addressId, patch, options = {}) => transport.request(DomainAddressPath(id, addressId), {
+    removeLogo: (id, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_LOGO, { id }), {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setLogoCertificate: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_LOGO_CERTIFICATE, { id }), {
+        method: HTTP_METHODS.PUT,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removeLogoCertificate: (id, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_LOGO_CERTIFICATE, { id }), {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listAddresses: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.DOMAIN_ADDRESSES, { id }), CURSOR_STYLES.CURSOR, options),
+    listAllAddresses: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.DOMAIN_ADDRESSES, { id }), CURSOR_STYLES.CURSOR, options),
+    iterateAddresses: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.DOMAIN_ADDRESSES, { id }), CURSOR_STYLES.CURSOR, options),
+    createAddress: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESSES, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    getAddress: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS, { id, addressId }), { signal: options.signal, apiKey: options.apiKey }),
+    updateAddress: (id, addressId, patch, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS, { id, addressId }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setAddressPhoto: (id, addressId, data, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_PHOTO, { id, addressId }), {
+        method: HTTP_METHODS.PUT,
+        raw: data,
+        contentType: PhotoType$1(data, options),
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removeAddressPhoto: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_PHOTO, { id, addressId }), {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteAddress: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS, { id, addressId }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listAddressForwards: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_FORWARDS, { id, addressId }), { signal: options.signal, apiKey: options.apiKey }),
+    addAddressForwards: (id, addressId, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_FORWARDS, { id, addressId }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    updateAddressForward: (id, addressId, forwardId, patch, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_FORWARD, { id, addressId, forwardId }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    deleteAddress: (id, addressId, options = {}) => transport.request(DomainAddressPath(id, addressId), {
+    deleteAddressForward: (id, addressId, forwardId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_FORWARD, { id, addressId, forwardId }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    resendAddressForwardConsent: (id, addressId, forwardId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_FORWARD_RESEND, { id, addressId, forwardId }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listAddressMembers: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_MEMBERS, { id, addressId }), { signal: options.signal, apiKey: options.apiKey }),
+    getAddressLogin: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_LOGIN, { id, addressId }), { signal: options.signal, apiKey: options.apiKey }),
+    setAddressLogin: (id, addressId, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_LOGIN, { id, addressId }), {
+        method: HTTP_METHODS.PUT,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteAddressLogin: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_LOGIN, { id, addressId }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
+    }),
+    getMailAppSettings: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_MAIL_APPS, { id, addressId }), { signal: options.signal, apiKey: options.apiKey }),
+    updateMailAppSettings: (id, addressId, patch, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_MAIL_APPS, { id, addressId }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listAppPasswords: (id, addressId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_APP_PASSWORDS, { id, addressId }), { signal: options.signal, apiKey: options.apiKey }),
+    createAppPassword: (id, addressId, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_APP_PASSWORDS, { id, addressId }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    updateAppPassword: (id, addressId, passwordId, patch, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_APP_PASSWORD, { id, addressId, passwordId }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteAppPassword: (id, addressId, passwordId, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_APP_PASSWORD, { id, addressId, passwordId }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    sendMailAppSetup: (id, addressId, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_ADDRESS_MAIL_APP_SETUP, { id, addressId }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    getDns: (id, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_DNS, { id }), {
+        query: { [QUERY_KEYS.REFRESH]: options.refresh },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setDnsZone: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_DNS, { id }), {
+        method: HTTP_METHODS.PUT,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    syncDns: (id, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.DOMAIN_DNS_SYNC, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
     })
 });
 
-const ListQuery$8 = (options) => ({ [QUERY_KEYS.QUERY]: options.query });
+const ListQuery$b = (options) => ({ [QUERY_KEYS.QUERY]: options.query });
 const Drafts = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$b(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$b(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$b(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.DRAFT, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.DRAFTS, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, body, options = {}) => transport.request(DraftPath(id), {
+    update: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.DRAFT, { id }), {
         method: HTTP_METHODS.PATCH,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(DraftPath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.DRAFT, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     })
 });
 
-const ListQuery$7 = (options) => ({
+const ListQuery$a = (options) => ({
     [QUERY_KEYS.STATUS]: Array.isArray(options.status) ? options.status.join(LIST_SEPARATOR) : options.status,
     [QUERY_KEYS.FROM]: options.from,
-    [QUERY_KEYS.BROADCAST_ID]: options.broadcastId
+    [QUERY_KEYS.BROADCAST_ID]: options.broadcastId,
+    [QUERY_KEYS.SCHEDULED_FROM]: options.scheduledFrom === undefined ? undefined : ToInstant(options.scheduledFrom),
+    [QUERY_KEYS.SCHEDULED_TO]: options.scheduledTo === undefined ? undefined : ToInstant(options.scheduledTo)
 });
 const Emails = (transport) => ({
-    send: (body, options = {}) => transport.request(PATHS.EMAILS, {
+    send: (body, options = {}) => transport.request(API_PATHS.EMAILS, {
         method: HTTP_METHODS.POST,
         body: EmailToWire(body),
         idempotent: true,
@@ -1974,7 +3205,7 @@ const Emails = (transport) => ({
         apiKey: options.apiKey
     }),
     sendBatch: async (emails, options = {}) => {
-        const result = await transport.request(PATHS.EMAILS_BATCH, {
+        const result = await transport.request(API_PATHS.EMAILS_BATCH, {
             method: HTTP_METHODS.POST,
             body: { emails: emails.map(EmailToWire) },
             idempotent: true,
@@ -1985,44 +3216,66 @@ const Emails = (transport) => ({
         });
         return { items: result.data, sent: result.sent, failed: result.failed };
     },
-    translate: (body, options = {}) => transport.request(PATHS.EMAILS_TRANSLATE, {
+    translate: (body, options = {}) => transport.request(API_PATHS.EMAILS_TRANSLATE, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    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 = {}) => 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), {
+    check: (body, options = {}) => transport.request(API_PATHS.EMAILS_CHECK, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    list: (options = {}) => FetchPage(transport, API_PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$a(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$a(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$a(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.EMAIL, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    listEvents: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.EMAIL_EVENTS, { id }), CURSOR_STYLES.CURSOR, options),
+    listAllEvents: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.EMAIL_EVENTS, { id }), CURSOR_STYLES.CURSOR, options),
+    iterateEvents: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.EMAIL_EVENTS, { id }), CURSOR_STYLES.CURSOR, options),
+    getTracking: (id, options = {}) => transport.request(RequestPath(API_PATHS.EMAIL_TRACKING, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    cancel: (id, options = {}) => transport.request(RequestPath(API_PATHS.EMAIL_CANCEL, { id }), {
         method: HTTP_METHODS.POST,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    reschedule: (id, scheduledAt, options = {}) => transport.request(EmailPath(id), {
+    reschedule: (id, scheduledAt, options = {}) => transport.request(RequestPath(API_PATHS.EMAIL, { id }), {
         method: HTTP_METHODS.PATCH,
         body: { scheduledAt: ToInstant(scheduledAt) },
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
+    }),
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.EMAIL, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: EmailUpdateToWire(patch),
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    compose: (body, options = {}) => transport.request(API_PATHS.EMAILS_COMPOSE, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    rewrite: (body, options = {}) => transport.request(API_PATHS.EMAILS_REWRITE, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    suggestSubject: (body, options = {}) => transport.request(API_PATHS.EMAILS_SUBJECT, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
     })
 });
 
-const ListQuery$6 = (options) => ({
-    [QUERY_KEYS.Q]: options.q,
-    [QUERY_KEYS.KIND]: options.kind,
-    [QUERY_KEYS.DIRECTION]: options.direction,
-    [QUERY_KEYS.ADDRESS]: options.address,
-    [QUERY_KEYS.SINCE]: ToInstant(options.since),
-    [QUERY_KEYS.UNTIL]: ToInstant(options.until),
-    [QUERY_KEYS.SORT]: options.sort
-});
 const UploadName = (options) => {
     const filename = typeof options?.filename === 'string' ? options.filename.trim() : '';
     if (!filename)
@@ -2039,33 +3292,49 @@ const UploadTimeout = (transport, options) => {
         return options.timeoutMs;
     return transport.timeoutMs > 0 ? Math.max(transport.timeoutMs, DEFAULTS.UPLOAD_TIMEOUT_MS) : transport.timeoutMs;
 };
+
+const ListQuery$9 = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.KIND]: options.kind,
+    [QUERY_KEYS.DIRECTION]: options.direction,
+    [QUERY_KEYS.ADDRESS]: options.address,
+    [QUERY_KEYS.SINCE]: ToInstant(options.since),
+    [QUERY_KEYS.UNTIL]: ToInstant(options.until),
+    [QUERY_KEYS.SORT]: options.sort
+});
 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), {
+    list: (options = {}) => FetchPage(transport, API_PATHS.FILES, CURSOR_STYLES.CURSOR, options, ListQuery$9(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.FILES, CURSOR_STYLES.CURSOR, options, ListQuery$9(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.FILES, CURSOR_STYLES.CURSOR, options, ListQuery$9(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.FILE, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    stats: (options = {}) => transport.request(API_PATHS.FILES_STATS, { signal: options.signal, apiKey: options.apiKey }),
+    download: (id, options = {}) => transport.request(RequestPath(API_PATHS.FILE_CONTENT, { id }), {
         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),
-    createLink: (id, options = {}) => transport.request(FileChildPath(id, SEGMENTS.LINKS), {
+    listLinks: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.FILE_LINKS, { id }), CURSOR_STYLES.CURSOR, options),
+    listAllLinks: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.FILE_LINKS, { id }), CURSOR_STYLES.CURSOR, options),
+    iterateLinks: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.FILE_LINKS, { id }), CURSOR_STYLES.CURSOR, options),
+    createLink: (id, options = {}) => transport.request(RequestPath(API_PATHS.FILE_LINKS, { id }), {
         method: HTTP_METHODS.POST,
         body: options.domain ? { domain: options.domain } : {},
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    revokeLink: (id, linkId, options = {}) => transport.request(FileLinkPath(id, linkId), {
+    revokeLink: (id, linkId, options = {}) => transport.request(RequestPath(API_PATHS.FILE_LINK, { id, linkId }), {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    revokeAllLinks: (id, options = {}) => transport.request(RequestPath(API_PATHS.FILE_LINKS, { id }), {
         method: HTTP_METHODS.DELETE,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    upload: (data, options) => transport.request(PATHS.FILES, {
+    upload: (data, options) => transport.request(API_PATHS.FILES, {
         method: HTTP_METHODS.POST,
         query: { [QUERY_KEYS.FILENAME]: UploadName(options) },
         raw: data,
@@ -2074,12 +3343,12 @@ const Files = (transport) => ({
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(FilePath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.FILE, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    deleteMany: (ids, options = {}) => transport.request(PATHS.FILES_BATCH_DELETE, {
+    deleteMany: (ids, options = {}) => transport.request(API_PATHS.FILES_BATCH_DELETE, {
         method: HTTP_METHODS.POST,
         body: { ids },
         signal: options.signal,
@@ -2087,7 +3356,116 @@ const Files = (transport) => ({
     })
 });
 
-const ListQuery$5 = (options) => ({ addressId: options.addressId });
+const SubmissionQuery = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.STATUS]: options.status
+});
+const WindowQuery$3 = (options) => ({
+    [QUERY_KEYS.DAYS]: options.days,
+    [QUERY_KEYS.MINUTES]: options.minutes,
+    [QUERY_KEYS.GRAIN]: options.grain,
+    [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+});
+const Forms = (transport) => ({
+    list: (options = {}) => FetchPage(transport, API_PATHS.FORMS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.FORMS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.FORMS, CURSOR_STYLES.CURSOR, options),
+    create: (body, options = {}) => transport.request(API_PATHS.FORMS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    design: (body, options = {}) => transport.request(API_PATHS.FORMS_DESIGN, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    redesign: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.FORM_REDESIGN, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listStarters: (options = {}) => FetchList(transport, API_PATHS.FORM_STARTERS, options),
+    getStarter: (slug, options = {}) => transport.request(RequestPath(API_PATHS.FORM_STARTER, { slug }), { signal: options.signal, apiKey: options.apiKey }),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.FORM, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.FORM, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.FORM, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    publish: (id, options = {}) => transport.request(RequestPath(API_PATHS.FORM_PUBLISH, { id }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    pause: (id, options = {}) => transport.request(RequestPath(API_PATHS.FORM_PAUSE, { id }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    resume: (id, options = {}) => transport.request(RequestPath(API_PATHS.FORM_RESUME, { id }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    duplicate: (id, options = {}) => transport.request(RequestPath(API_PATHS.FORM_DUPLICATE, { id }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    analytics: (id, options = {}) => transport.request(RequestPath(API_PATHS.FORM_ANALYTICS, { id }), {
+        query: WindowQuery$3(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listSubmissions: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.FORM_SUBMISSIONS, { id }), CURSOR_STYLES.CURSOR, options, SubmissionQuery(options)),
+    listAllSubmissions: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.FORM_SUBMISSIONS, { id }), CURSOR_STYLES.CURSOR, options, SubmissionQuery(options)),
+    iterateSubmissions: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.FORM_SUBMISSIONS, { id }), CURSOR_STYLES.CURSOR, options, SubmissionQuery(options)),
+    getSubmission: (id, submissionId, options = {}) => transport.request(RequestPath(API_PATHS.FORM_SUBMISSION, { id, submissionId }), { signal: options.signal, apiKey: options.apiKey }),
+    deleteSubmission: (id, submissionId, options = {}) => transport.request(RequestPath(API_PATHS.FORM_SUBMISSION, { id, submissionId }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteSubmissions: (id, submissionIds, options = {}) => transport.request(RequestPath(API_PATHS.FORM_SUBMISSIONS_BATCH_REMOVE, { id }), {
+        method: HTTP_METHODS.POST,
+        body: { ids: submissionIds },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    approveSubmission: (id, submissionId, options = {}) => transport.request(RequestPath(API_PATHS.FORM_SUBMISSION_APPROVE, { id, submissionId }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    resendConfirmation: (id, submissionId, options = {}) => transport.request(RequestPath(API_PATHS.FORM_SUBMISSION_RESEND, { id, submissionId }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    subscribe: (formId, values, options = {}) => transport.request(RequestPath(API_PATHS.SUBSCRIBE_FORM, { formId }), {
+        method: HTTP_METHODS.POST,
+        body: values,
+        anonymous: true,
+        signal: options.signal
+    })
+});
+
+const ListQuery$8 = (options) => ({ addressId: options.addressId });
 const SizeOf = (data) => data instanceof Blob ? data.size : data.byteLength;
 const SliceOf = (data, start, end) => {
     if (data instanceof Blob)
@@ -2097,48 +3475,48 @@ const SliceOf = (data, start, end) => {
     return new Uint8Array(data, start, end - start);
 };
 const Imports = (transport) => {
-    const create = (body, options = {}) => transport.request(PATHS.IMPORTS, {
+    const create = (body, options = {}) => transport.request(API_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), {
+    const uploadChunk = (id, file, chunk, data, options = {}) => transport.request(RequestPath(API_PATHS.IMPORT_FILE_CHUNK, { 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), {
+    const start = (id, options = {}) => transport.request(RequestPath(API_PATHS.IMPORT_START, { id }), {
         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 }),
+        list: (options = {}) => FetchPage(transport, API_PATHS.IMPORTS, CURSOR_STYLES.CURSOR, options, ListQuery$8(options)),
+        listAll: (options = {}) => CollectAll(transport, API_PATHS.IMPORTS, CURSOR_STYLES.CURSOR, options, ListQuery$8(options)),
+        iterate: (options = {}) => IteratePages(transport, API_PATHS.IMPORTS, CURSOR_STYLES.CURSOR, options, ListQuery$8(options)),
+        get: (id, options = {}) => transport.request(RequestPath(API_PATHS.IMPORT, { id }), { signal: options.signal, apiKey: options.apiKey }),
         create,
-        uploadState: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.UPLOAD), {
+        uploadState: (id, options = {}) => transport.request(RequestPath(API_PATHS.IMPORT_UPLOAD, { id }), {
             signal: options.signal,
             apiKey: options.apiKey
         }),
         uploadChunk,
         start,
-        cancel: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.CANCEL), {
+        cancel: (id, options = {}) => transport.request(RequestPath(API_PATHS.IMPORT_CANCEL, { id }), {
             method: HTTP_METHODS.POST,
             signal: options.signal,
             apiKey: options.apiKey
         }),
-        listFailures: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.FAILURES), {
+        listFailures: (id, options = {}) => transport.request(RequestPath(API_PATHS.IMPORT_FAILURES, { id }), {
             query: { after: options.after, limit: options.limit },
             signal: options.signal,
             apiKey: options.apiKey
         }),
-        deleteUpload: (id, options = {}) => transport.request(ImportChildPath(id, SEGMENTS.UPLOAD), {
+        deleteUpload: (id, options = {}) => transport.request(RequestPath(API_PATHS.IMPORT_UPLOAD, { id }), {
             method: HTTP_METHODS.DELETE,
             signal: options.signal,
             apiKey: options.apiKey
@@ -2185,72 +3563,214 @@ const WorkspaceActivityQuery$1 = (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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.KEYS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.KEYS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.KEYS, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.KEY, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.KEYS, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, patch, options = {}) => transport.request(KeyPath(id), {
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.KEY, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(KeyPath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.KEY, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    rotate: (id, options = {}) => transport.request(KeyChildPath(id, SEGMENTS.ROTATE), {
+    rotate: (id, options = {}) => transport.request(RequestPath(API_PATHS.KEY_ROTATE, { id }), {
         method: HTTP_METHODS.POST,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    revoke: (id, body = {}, options = {}) => transport.request(KeyChildPath(id, SEGMENTS.REVOKE), {
+    revoke: (id, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.KEY_REVOKE, { id }), {
         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))
+    listRequests: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.KEY_REQUESTS, { id }), CURSOR_STYLES.CURSOR, options, RequestQuery(options)),
+    listAllRequests: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.KEY_REQUESTS, { id }), CURSOR_STYLES.CURSOR, options, RequestQuery(options)),
+    iterateRequests: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.KEY_REQUESTS, { id }), CURSOR_STYLES.CURSOR, options, RequestQuery(options)),
+    listActivity: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.KEY_ACTIVITY, { id }), CURSOR_STYLES.CURSOR, options, WindowQuery$2(options)),
+    listAllActivity: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.KEY_ACTIVITY, { id }), CURSOR_STYLES.CURSOR, options, WindowQuery$2(options)),
+    iterateActivity: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.KEY_ACTIVITY, { id }), CURSOR_STYLES.CURSOR, options, WindowQuery$2(options)),
+    listWorkspaceRequests: (options = {}) => FetchPage(transport, API_PATHS.KEYS_REQUESTS, CURSOR_STYLES.CURSOR, options, WorkspaceRequestQuery(options)),
+    listAllWorkspaceRequests: (options = {}) => CollectAll(transport, API_PATHS.KEYS_REQUESTS, CURSOR_STYLES.CURSOR, options, WorkspaceRequestQuery(options)),
+    iterateWorkspaceRequests: (options = {}) => IteratePages(transport, API_PATHS.KEYS_REQUESTS, CURSOR_STYLES.CURSOR, options, WorkspaceRequestQuery(options)),
+    listWorkspaceActivity: (options = {}) => FetchPage(transport, API_PATHS.KEYS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery$1(options)),
+    listAllWorkspaceActivity: (options = {}) => CollectAll(transport, API_PATHS.KEYS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery$1(options)),
+    iterateWorkspaceActivity: (options = {}) => IteratePages(transport, API_PATHS.KEYS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery$1(options)),
+    stats: (options = {}) => transport.request(API_PATHS.KEYS_STATS, {
+        query: {
+            ...WindowQuery$2(options),
+            [QUERY_KEYS.KEY_IDS]: options.keyIds?.join(LIST_SEPARATOR),
+            [QUERY_KEYS.GRAIN]: options.grain,
+            [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+        },
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const ListQuery$7 = (options) => ({
+    [QUERY_KEYS.SCOPE]: options.scope,
+    [QUERY_KEYS.LEVEL]: options.level,
+    [QUERY_KEYS.KIND]: options.kind,
+    [QUERY_KEYS.STATUS]: options.status,
+    [QUERY_KEYS.PINNED]: options.pinned,
+    [QUERY_KEYS.Q]: options.q
+});
+const SuggestionQuery = (options) => ({
+    [QUERY_KEYS.KIND]: options.kind,
+    [QUERY_KEYS.STATUS]: options.status
+});
+const Knowledge = (transport) => ({
+    list: (options = {}) => FetchPage(transport, API_PATHS.KNOWLEDGE, CURSOR_STYLES.CURSOR, options, ListQuery$7(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.KNOWLEDGE, CURSOR_STYLES.CURSOR, options, ListQuery$7(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.KNOWLEDGE, CURSOR_STYLES.CURSOR, options, ListQuery$7(options)),
+    levels: (options = {}) => FetchList(transport, API_PATHS.KNOWLEDGE_LEVELS, options),
+    usage: (options = {}) => transport.request(API_PATHS.KNOWLEDGE_USAGE, { signal: options.signal, apiKey: options.apiKey }),
+    search: (body, options = {}) => transport.request(API_PATHS.KNOWLEDGE_SEARCH, {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    createNote: (body, options = {}) => transport.request(API_PATHS.KNOWLEDGE_NOTES, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    addLink: (body, options = {}) => transport.request(API_PATHS.KNOWLEDGE_LINKS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    uploadFile: (data, options) => transport.request(API_PATHS.KNOWLEDGE_FILES, {
+        method: HTTP_METHODS.POST,
+        query: {
+            [QUERY_KEYS.FILENAME]: UploadName(options),
+            [QUERY_KEYS.SCOPE]: options.scope,
+            [QUERY_KEYS.TITLE]: options.title
+        },
+        raw: data,
+        contentType: UploadType(data, options),
+        timeoutMs: UploadTimeout(transport, options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_ITEM, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_ITEM, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_ITEM, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    refresh: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_ITEM_REFRESH, { id }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    stats: (options = {}) => transport.request(API_PATHS.KNOWLEDGE_STATS, {
+        query: { [QUERY_KEYS.DAYS]: options.days },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listSuggestions: (options = {}) => FetchPage(transport, API_PATHS.KNOWLEDGE_SUGGESTIONS, CURSOR_STYLES.CURSOR, options, SuggestionQuery(options)),
+    listAllSuggestions: (options = {}) => CollectAll(transport, API_PATHS.KNOWLEDGE_SUGGESTIONS, CURSOR_STYLES.CURSOR, options, SuggestionQuery(options)),
+    iterateSuggestions: (options = {}) => IteratePages(transport, API_PATHS.KNOWLEDGE_SUGGESTIONS, CURSOR_STYLES.CURSOR, options, SuggestionQuery(options)),
+    acceptSuggestion: (id, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_SUGGESTION_ACCEPT, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    dismissSuggestion: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_SUGGESTION_DISMISS, { id }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listFlags: (options = {}) => FetchList(transport, API_PATHS.KNOWLEDGE_FLAGS, options, {
+        [QUERY_KEYS.ITEM_ID]: options.itemId,
+        [QUERY_KEYS.LIMIT]: options.limit
+    }),
+    dismissFlag: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_FLAG_DISMISS, { id }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listConnectors: (options = {}) => FetchList(transport, API_PATHS.KNOWLEDGE_CONNECTORS, options),
+    addConnector: (body, options = {}) => transport.request(API_PATHS.KNOWLEDGE_CONNECTORS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    getConnector: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_CONNECTOR, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    updateConnector: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_CONNECTOR, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteConnector: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_CONNECTOR, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    syncConnector: (id, options = {}) => transport.request(RequestPath(API_PATHS.KNOWLEDGE_CONNECTOR_SYNC, { id }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    draftFromThread: (body, options = {}) => transport.request(API_PATHS.KNOWLEDGE_DRAFTS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
 });
 
 const ProviderImports = (transport) => ({
-    inspect: (apiKey, options = {}) => transport.request(PATHS.PROVIDER_IMPORTS_INSPECT, {
+    inspect: (apiKey, options = {}) => transport.request(API_PATHS.PROVIDER_IMPORTS_INSPECT, {
         method: HTTP_METHODS.POST,
-        body: { apiKey },
+        body: options.provider === undefined ? { apiKey } : { apiKey, provider: options.provider },
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    create: (body, options = {}) => transport.request(PATHS.PROVIDER_IMPORTS, {
+    create: (body, options = {}) => transport.request(API_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), {
+    list: (options = {}) => FetchPage(transport, API_PATHS.PROVIDER_IMPORTS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.PROVIDER_IMPORTS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.PROVIDER_IMPORTS, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.PROVIDER_IMPORT, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    cancel: (id, options = {}) => transport.request(RequestPath(API_PATHS.PROVIDER_IMPORT_CANCEL, { id }), {
         method: HTTP_METHODS.POST,
         signal: options.signal,
         apiKey: options.apiKey
@@ -2258,25 +3778,25 @@ const ProviderImports = (transport) => ({
 });
 
 const Labels = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.LABELS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.LABELS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.LABELS, CURSOR_STYLES.CURSOR, options),
+    listColors: (options = {}) => FetchList(transport, API_PATHS.LABEL_COLORS, options),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.LABEL, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.LABELS, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, patch, options = {}) => transport.request(LabelPath(id), {
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.LABEL, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(LabelPath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.LABEL, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
@@ -2284,13 +3804,13 @@ const Labels = (transport) => ({
 });
 
 const Languages = (transport) => ({
-    list: (options = {}) => FetchList(transport, PATHS.LANGUAGES, options)
+    list: (options = {}) => FetchList(transport, API_PATHS.LANGUAGES, options)
 });
 
 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 }),
-    rotate: (options = {}) => transport.request(PATHS.KEYS_SELF_ROTATE, {
+    get: (options = {}) => transport.request(API_PATHS.KEY_SELF, { signal: options.signal, apiKey: options.apiKey }),
+    ping: (options = {}) => transport.request(API_PATHS.PING, { signal: options.signal, apiKey: options.apiKey }),
+    rotate: (options = {}) => transport.request(API_PATHS.KEY_SELF_ROTATE, {
         method: HTTP_METHODS.POST,
         signal: options.signal,
         apiKey: options.apiKey
@@ -2298,49 +3818,61 @@ const Me = (transport) => ({
 });
 
 const Members = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.MEMBERS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.MEMBERS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.MEMBERS, CURSOR_STYLES.CURSOR, options),
+    get: (userId, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER, { userId }), { signal: options.signal, apiKey: options.apiKey }),
+    add: (body, options = {}) => transport.request(API_PATHS.MEMBERS, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (userId, patch, options = {}) => transport.request(MemberPath(userId), {
+    update: (userId, patch, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER, { userId }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    remove: (userId, options = {}) => transport.request(MemberPath(userId), {
+    remove: (userId, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER, { userId }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    grantAddress: (userId, body, options = {}) => transport.request(MemberAddressesPath(userId), {
+    grantAddress: (userId, body, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER_ADDRESSES, { userId }), {
         method: HTTP_METHODS.POST,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    revokeAddress: (userId, addressId, options = {}) => transport.request(MemberAddressPath(userId, addressId), {
+    revokeAddress: (userId, addressId, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER_ADDRESS, { userId, addressId }), {
         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), {
+    grantDomain: (userId, body, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER_DOMAINS, { userId }), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    revokeDomain: (userId, domainId, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER_DOMAIN, { userId, domainId }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listInvitations: (options = {}) => FetchPage(transport, API_PATHS.MEMBER_INVITATIONS, CURSOR_STYLES.CURSOR, options),
+    listAllInvitations: (options = {}) => CollectAll(transport, API_PATHS.MEMBER_INVITATIONS, CURSOR_STYLES.CURSOR, options),
+    iterateInvitations: (options = {}) => IteratePages(transport, API_PATHS.MEMBER_INVITATIONS, CURSOR_STYLES.CURSOR, options),
+    revokeInvitation: (invitationId, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER_INVITATION, { invitationId }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    resendInvitation: (invitationId, options = {}) => transport.request(MemberInvitationResendPath(invitationId), {
+    resendInvitation: (invitationId, options = {}) => transport.request(RequestPath(API_PATHS.MEMBER_INVITATION_RESEND, { invitationId }), {
         method: HTTP_METHODS.POST,
         signal: options.signal,
         apiKey: options.apiKey
@@ -2348,33 +3880,33 @@ const Members = (transport) => ({
 });
 
 const Roles = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.ROLES, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.ROLES, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.ROLES, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.ROLE, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.ROLES, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, patch, options = {}) => transport.request(RolePath(id), {
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.ROLE, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(RolePath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.ROLE, { id }), {
         method: HTTP_METHODS.DELETE,
         query: { [QUERY_KEYS.REASSIGN_TO]: options.reassignTo },
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    listPermissions: (options = {}) => FetchList(transport, PATHS.ROLES_PERMISSIONS, options)
+    listPermissions: (options = {}) => FetchList(transport, API_PATHS.ROLE_PERMISSIONS, options)
 });
 
-const ListQuery$4 = (options) => ({
+const ListQuery$6 = (options) => ({
     [QUERY_KEYS.ENABLED]: options.enabled === undefined ? undefined : String(options.enabled)
 });
 const RunsQuery = (options) => ({
@@ -2382,29 +3914,29 @@ const RunsQuery = (options) => ({
     [QUERY_KEYS.THREAD_ID]: options.threadId
 });
 const Rules = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$6(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$6(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$6(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.RULE, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.RULES, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, patch, options = {}) => transport.request(RulePath(id), {
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.RULE, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(RulePath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.RULE, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
     reorder: async (ruleIds, options = {}) => {
-        const envelope = await transport.request(PATHS.RULES_REORDER, {
+        const envelope = await transport.request(API_PATHS.RULES_REORDER, {
             method: HTTP_METHODS.POST,
             body: { ruleIds },
             repeatable: true,
@@ -2413,27 +3945,27 @@ const Rules = (transport) => ({
         });
         return envelope?.data ?? [];
     },
-    test: (id, body = {}, options = {}) => transport.request(RuleChildPath(id, SEGMENTS.TEST), {
+    test: (id, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.RULE_TEST, { id }), {
         method: HTTP_METHODS.POST,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    listRuns: (options = {}) => FetchPage(transport, PATHS.RULES_RUNS, CURSOR_STYLES.CURSOR, options, RunsQuery(options)),
-    listAllRuns: (options = {}) => CollectAll(transport, PATHS.RULES_RUNS, CURSOR_STYLES.CURSOR, options, RunsQuery(options)),
-    iterateRuns: (options = {}) => IteratePages(transport, PATHS.RULES_RUNS, CURSOR_STYLES.CURSOR, options, RunsQuery(options))
+    listRuns: (options = {}) => FetchPage(transport, API_PATHS.RULE_RUNS, CURSOR_STYLES.CURSOR, options, RunsQuery(options)),
+    listAllRuns: (options = {}) => CollectAll(transport, API_PATHS.RULE_RUNS, CURSOR_STYLES.CURSOR, options, RunsQuery(options)),
+    iterateRuns: (options = {}) => IteratePages(transport, API_PATHS.RULE_RUNS, CURSOR_STYLES.CURSOR, options, RunsQuery(options))
 });
 
 const Security = (transport) => ({
-    stepUpStatus: (options = {}) => transport.request(PATHS.SECURITY_STEP_UP, { signal: options.signal, apiKey: options.apiKey }),
-    beginStepUp: (body = {}, options = {}) => transport.request(PATHS.SECURITY_STEP_UP, {
+    stepUpStatus: (options = {}) => transport.request(API_PATHS.SECURITY_STEP_UP, { signal: options.signal, apiKey: options.apiKey }),
+    beginStepUp: (body = {}, options = {}) => transport.request(API_PATHS.SECURITY_STEP_UP, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    verifyStepUp: (body, options = {}) => transport.request(PATHS.SECURITY_STEP_UP_VERIFY, {
+    verifyStepUp: (body, options = {}) => transport.request(API_PATHS.SECURITY_STEP_UP_VERIFY, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
@@ -2442,12 +3974,12 @@ const Security = (transport) => ({
 });
 
 const Settings = (transport) => ({
-    get: (options = {}) => transport.request(PATHS.SETTINGS, {
+    get: (options = {}) => transport.request(API_PATHS.SETTINGS, {
         query: { [QUERY_KEYS.ADDRESS]: options.address },
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (patch, options = {}) => transport.request(PATHS.SETTINGS, {
+    update: (patch, options = {}) => transport.request(API_PATHS.SETTINGS, {
         method: HTTP_METHODS.PATCH,
         query: { [QUERY_KEYS.ADDRESS]: options.address },
         body: patch,
@@ -2457,23 +3989,23 @@ const Settings = (transport) => ({
     })
 });
 
-const ListQuery$3 = (options) => ({
+const ListQuery$5 = (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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.SUPPRESSIONS, CURSOR_STYLES.CURSOR, options, ListQuery$5(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.SUPPRESSIONS, CURSOR_STYLES.CURSOR, options, ListQuery$5(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.SUPPRESSIONS, CURSOR_STYLES.CURSOR, options, ListQuery$5(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.SUPPRESSION, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    add: (body, options = {}) => transport.request(API_PATHS.SUPPRESSIONS, {
         method: HTTP_METHODS.POST,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    remove: (id, options = {}) => transport.request(SuppressionPath(id), {
+    remove: (id, options = {}) => transport.request(RequestPath(API_PATHS.SUPPRESSION, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
@@ -2481,7 +4013,7 @@ const Suppressions = (transport) => ({
 });
 
 const MessagePage = async (transport, inboxId, options) => {
-    const envelope = await transport.request(TempMessagesPath(inboxId), {
+    const envelope = await transport.request(RequestPath(API_PATHS.TEMP_MAIL_MESSAGES, { id: inboxId }), {
         query: { [QUERY_KEYS.LIMIT]: options.limit, [QUERY_KEYS.CURSOR]: options.cursor },
         inboxToken: options.inboxToken,
         signal: options.signal
@@ -2506,26 +4038,26 @@ const IterateMessages = async function* (transport, inboxId, options) {
     }
 };
 const TempMail = (transport) => ({
-    listDomains: async (options = {}) => (await transport.request(PATHS.TEMP_MAIL_DOMAINS, {
+    listDomains: async (options = {}) => (await transport.request(API_PATHS.TEMP_MAIL_DOMAINS, {
         anonymous: true,
         signal: options.signal
     }))?.data ?? [],
-    create: (body = {}, options = {}) => transport.request(PATHS.TEMP_MAIL_INBOXES, {
+    create: (body = {}, options = {}) => transport.request(API_PATHS.TEMP_MAIL_INBOXES, {
         method: HTTP_METHODS.POST,
         body,
         anonymous: true,
         signal: options.signal
     }),
-    get: (inboxId, options = {}) => transport.request(TempInboxPath(inboxId), {
+    get: (inboxId, options = {}) => transport.request(RequestPath(API_PATHS.TEMP_MAIL_INBOX, { id: inboxId }), {
         inboxToken: options.inboxToken,
         signal: options.signal
     }),
-    extend: (inboxId, options = {}) => transport.request(TempInboxExtendPath(inboxId), {
+    extend: (inboxId, options = {}) => transport.request(RequestPath(API_PATHS.TEMP_MAIL_INBOX_EXTEND, { id: inboxId }), {
         method: HTTP_METHODS.POST,
         inboxToken: options.inboxToken,
         signal: options.signal
     }),
-    delete: (inboxId, options = {}) => transport.request(TempInboxPath(inboxId), {
+    delete: (inboxId, options = {}) => transport.request(RequestPath(API_PATHS.TEMP_MAIL_INBOX, { id: inboxId }), {
         method: HTTP_METHODS.DELETE,
         inboxToken: options.inboxToken,
         signal: options.signal
@@ -2538,22 +4070,22 @@ const TempMail = (transport) => ({
         return all;
     },
     iterateMessages: (inboxId, options = {}) => IterateMessages(transport, inboxId, options),
-    getMessage: (inboxId, messageId, options = {}) => transport.request(TempMessagePath(inboxId, messageId), {
+    getMessage: (inboxId, messageId, options = {}) => transport.request(RequestPath(API_PATHS.TEMP_MAIL_MESSAGE, { id: inboxId, messageId }), {
         inboxToken: options.inboxToken,
         signal: options.signal
     }),
-    deleteMessage: (inboxId, messageId, options = {}) => transport.request(TempMessagePath(inboxId, messageId), {
+    deleteMessage: (inboxId, messageId, options = {}) => transport.request(RequestPath(API_PATHS.TEMP_MAIL_MESSAGE, { id: inboxId, messageId }), {
         method: HTTP_METHODS.DELETE,
         inboxToken: options.inboxToken,
         signal: options.signal
     }),
-    listAttachments: async (inboxId, messageId, options = {}) => (await transport.request(TempMessageAttachmentsPath(inboxId, messageId), {
+    listAttachments: async (inboxId, messageId, options = {}) => (await transport.request(RequestPath(API_PATHS.TEMP_MAIL_MESSAGE_ATTACHMENTS, { id: inboxId, messageId }), {
         inboxToken: options.inboxToken,
         signal: options.signal
     }))?.data ?? []
 });
 
-const ListQuery$2 = (options) => ({
+const ListQuery$4 = (options) => ({
     [QUERY_KEYS.STATUS]: options.status,
     [QUERY_KEYS.SEARCH]: options.search,
     [QUERY_KEYS.SORT]: options.sort
@@ -2566,84 +4098,85 @@ const WindowQuery$1 = (options) => ({
     [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
 });
 const Templates = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$4(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$4(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$4(options)),
+    listStarters: (options = {}) => FetchList(transport, API_PATHS.TEMPLATE_STARTERS, options),
+    listFonts: (options = {}) => FetchList(transport, API_PATHS.TEMPLATE_FONTS, options),
+    getStarter: (slug, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_STARTER, { slug }), { signal: options.signal, apiKey: options.apiKey }),
+    render: (body, options = {}) => transport.request(API_PATHS.TEMPLATE_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, {
+    get: (idOrSlug, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE, { id: idOrSlug }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.TEMPLATES, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (idOrSlug, patch, options = {}) => transport.request(TemplatePath(idOrSlug), {
+    update: (idOrSlug, patch, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE, { id: idOrSlug }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (idOrSlug, options = {}) => transport.request(TemplatePath(idOrSlug), {
+    delete: (idOrSlug, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE, { id: idOrSlug }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    duplicate: (idOrSlug, body = {}, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.DUPLICATE), {
+    duplicate: (idOrSlug, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_DUPLICATE, { id: idOrSlug }), {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    replaceContent: (idOrSlug, body, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.CONTENT), {
+    replaceContent: (idOrSlug, body, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_CONTENT, { id: idOrSlug }), {
         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), {
+    listVersions: (idOrSlug, options = {}) => FetchPage(transport, RequestPath(API_PATHS.TEMPLATE_VERSIONS, { id: idOrSlug }), CURSOR_STYLES.CURSOR, options),
+    listAllVersions: (idOrSlug, options = {}) => CollectAll(transport, RequestPath(API_PATHS.TEMPLATE_VERSIONS, { id: idOrSlug }), CURSOR_STYLES.CURSOR, options),
+    iterateVersions: (idOrSlug, options = {}) => IteratePages(transport, RequestPath(API_PATHS.TEMPLATE_VERSIONS, { id: idOrSlug }), CURSOR_STYLES.CURSOR, options),
+    getVersion: (idOrSlug, version, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_VERSION, { id: idOrSlug, version }), { signal: options.signal, apiKey: options.apiKey }),
+    deleteVersion: (idOrSlug, version, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_VERSION, { id: idOrSlug, version }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    restoreVersion: (idOrSlug, version, body = {}, options = {}) => transport.request(TemplateVersionChildPath(idOrSlug, version, SEGMENTS.RESTORE), {
+    restoreVersion: (idOrSlug, version, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_VERSION_RESTORE, { id: idOrSlug, version }), {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    publish: (idOrSlug, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), {
+    publish: (idOrSlug, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_VERSIONS, { id: idOrSlug }), {
         method: HTTP_METHODS.POST,
+        ...(options.expectedVersion === undefined ? {} : { body: { expectedVersion: options.expectedVersion } }),
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    preview: (idOrSlug, body = {}, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.PREVIEW), {
+    preview: (idOrSlug, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_PREVIEW, { id: idOrSlug }), {
         method: HTTP_METHODS.POST,
         body,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    getAnalytics: (idOrSlug, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.ANALYTICS), {
+    getAnalytics: (idOrSlug, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_ANALYTICS, { id: idOrSlug }), {
         query: WindowQuery$1(options),
         signal: options.signal,
         apiKey: options.apiKey
     }),
     listSends: async (idOrSlug, options = {}) => {
-        const envelope = await transport.request(TemplateChildPath(idOrSlug, SEGMENTS.SENDS), {
+        const envelope = await transport.request(RequestPath(API_PATHS.TEMPLATE_SENDS, { id: idOrSlug }), {
             query: {
                 ...WindowQuery$1(options),
                 [QUERY_KEYS.PAGE]: options.page,
@@ -2665,7 +4198,7 @@ const Templates = (transport) => ({
             pageSize: envelope?.pageSize ?? 0
         };
     },
-    send: (idOrSlug, body, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.SEND), {
+    send: (idOrSlug, body, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_SEND, { id: idOrSlug }), {
         method: HTTP_METHODS.POST,
         body: TemplateSendToWire(body),
         idempotent: true,
@@ -2673,84 +4206,160 @@ const Templates = (transport) => ({
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
+    }),
+    listImages: (options = {}) => FetchPage(transport, API_PATHS.TEMPLATE_IMAGES, CURSOR_STYLES.CURSOR, options),
+    listAllImages: (options = {}) => CollectAll(transport, API_PATHS.TEMPLATE_IMAGES, CURSOR_STYLES.CURSOR, options),
+    iterateImages: (options = {}) => IteratePages(transport, API_PATHS.TEMPLATE_IMAGES, CURSOR_STYLES.CURSOR, options),
+    uploadImage: (data, options = {}) => transport.request(API_PATHS.TEMPLATE_IMAGES, {
+        method: HTTP_METHODS.POST,
+        raw: data,
+        contentType: options.contentType ?? (typeof Blob !== 'undefined' && data instanceof Blob && data.type ? data.type : undefined),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    design: (body, options = {}) => transport.request(API_PATHS.TEMPLATES_DESIGN, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    redesign: (idOrSlug, body, options = {}) => transport.request(RequestPath(API_PATHS.TEMPLATE_REDESIGN, { id: idOrSlug }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
     })
 });
 
-const ListQuery$1 = (options) => ({
+const ListQuery$3 = (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.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)
+    [QUERY_KEYS.FROM_CONTACTS]: options.fromContacts === undefined ? undefined : String(options.fromContacts),
+    [QUERY_KEYS.SEMANTIC]: options.semantic === undefined ? undefined : String(options.semantic),
+    [QUERY_KEYS.ADDRESS]: options.address
 });
 const Threads = (transport) => ({
-    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), {
+    list: (options = {}) => FetchPage(transport, API_PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$3(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$3(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$3(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.THREAD, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    trash: (id, options = {}) => transport.request(ThreadChildPath(id, SEGMENTS.TRASH), {
+    trash: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_TRASH, { id }), {
         method: HTTP_METHODS.POST,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    snooze: (id, wakeAt, options = {}) => transport.request(ThreadChildPath(id, SEGMENTS.SNOOZE), {
+    snooze: (id, wakeAt, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_SNOOZE, { id }), {
         method: HTTP_METHODS.POST,
         body: { wakeAt: ToInstant(wakeAt) },
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    unsnooze: (id, options = {}) => transport.request(ThreadChildPath(id, SEGMENTS.UNSNOOZE), {
+    unsnooze: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_UNSNOOZE, { id }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listAttachments: (id, messageId, options = {}) => FetchList(transport, RequestPath(API_PATHS.THREAD_MESSAGE_ATTACHMENTS, { id, messageId }), options),
+    getEvent: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_EVENT, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    listNotes: (id, options = {}) => FetchList(transport, RequestPath(API_PATHS.THREAD_NOTES, { id }), options),
+    createNote: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_NOTES, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    updateNote: (id, noteId, patch, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_NOTE, { id, noteId }), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    deleteNote: (id, noteId, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_NOTE, { id, noteId }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    reorderNotes: (id, ids, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_NOTES_REORDER, { id }), {
+        method: HTTP_METHODS.POST,
+        body: { ids },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }).then(payload => payload?.data ?? []),
+    counts: (options = {}) => transport.request(API_PATHS.THREADS_COUNTS, {
+        query: { [QUERY_KEYS.ADDRESS]: options.address },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    summary: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_SUMMARY, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    replySuggestions: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_REPLY_SUGGESTIONS, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    restore: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_RESTORE, { id }), {
         method: HTTP_METHODS.POST,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    listAttachments: (id, messageId, options = {}) => FetchList(transport, ThreadMessageAttachmentsPath(id, messageId), options)
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    unsubscribe: (id, options = {}) => transport.request(RequestPath(API_PATHS.THREAD_UNSUBSCRIBE, { id }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
 });
 
 const Flag = (value) => value === undefined ? undefined : String(value);
 const HitQuery = (options) => ({
     [QUERY_KEYS.INCLUDE_MACHINE]: Flag(options.includeMachine)
 });
-const ListQuery = (options) => ({
+const ListQuery$2 = (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.GRAIN]: options.grain,
+    [QUERY_KEYS.ADDRESS]: options.address
 });
 const Tracking = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.TRACKING, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.TRACKING, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.TRACKING, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    getStats: (options = {}) => transport.request(API_PATHS.TRACKING_STATS, {
         query: {
             [QUERY_KEYS.DAYS]: options.days,
             [QUERY_KEYS.MINUTES]: options.minutes,
             [QUERY_KEYS.GRAIN]: options.grain,
-            [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+            [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes,
+            [QUERY_KEYS.ADDRESS]: options.address
         },
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    get: (id, options = {}) => transport.request(TrackingPath(id), { signal: options.signal, apiKey: options.apiKey }),
-    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))
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.TRACKED, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    listOpens: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.TRACKED_OPENS, { id }), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    listAllOpens: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.TRACKED_OPENS, { id }), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    iterateOpens: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.TRACKED_OPENS, { id }), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    listClicks: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.TRACKED_CLICKS, { id }), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    listAllClicks: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.TRACKED_CLICKS, { id }), CURSOR_STYLES.CURSOR, options, HitQuery(options)),
+    iterateClicks: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.TRACKED_CLICKS, { id }), CURSOR_STYLES.CURSOR, options, HitQuery(options))
 });
 
 const WindowQuery = (options) => ({
@@ -2770,56 +4379,350 @@ const WorkspaceActivityQuery = (options) => ({
     [QUERY_KEYS.ENDPOINT_IDS]: options.endpointIds?.join(LIST_SEPARATOR)
 });
 const Webhooks = (transport) => ({
-    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, {
+    list: (options = {}) => FetchPage(transport, API_PATHS.WEBHOOKS, CURSOR_STYLES.CURSOR, options),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.WEBHOOKS, CURSOR_STYLES.CURSOR, options),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.WEBHOOKS, CURSOR_STYLES.CURSOR, options),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.WEBHOOK, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.WEBHOOKS, {
         method: HTTP_METHODS.POST,
         body,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    update: (id, patch, options = {}) => transport.request(WebhookPath(id), {
+    update: (id, patch, options = {}) => transport.request(RequestPath(API_PATHS.WEBHOOK, { id }), {
         method: HTTP_METHODS.PATCH,
         body: patch,
         repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    delete: (id, options = {}) => transport.request(WebhookPath(id), {
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.WEBHOOK, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    rotateSecret: (id, options = {}) => transport.request(RequestPath(API_PATHS.WEBHOOK_ROTATE_SECRET, { id }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    test: (id, options = {}) => transport.request(RequestPath(API_PATHS.WEBHOOK_TEST, { id }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listDeliveries: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.WEBHOOK_DELIVERIES, { id }), CURSOR_STYLES.CURSOR, options, DeliveryQuery(options)),
+    listAllDeliveries: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.WEBHOOK_DELIVERIES, { id }), CURSOR_STYLES.CURSOR, options, DeliveryQuery(options)),
+    iterateDeliveries: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.WEBHOOK_DELIVERIES, { id }), CURSOR_STYLES.CURSOR, options, DeliveryQuery(options)),
+    listWorkspaceDeliveries: (options = {}) => FetchPage(transport, API_PATHS.WEBHOOKS_DELIVERIES, CURSOR_STYLES.CURSOR, options, WorkspaceDeliveryQuery(options)),
+    listAllWorkspaceDeliveries: (options = {}) => CollectAll(transport, API_PATHS.WEBHOOKS_DELIVERIES, CURSOR_STYLES.CURSOR, options, WorkspaceDeliveryQuery(options)),
+    iterateWorkspaceDeliveries: (options = {}) => IteratePages(transport, API_PATHS.WEBHOOKS_DELIVERIES, CURSOR_STYLES.CURSOR, options, WorkspaceDeliveryQuery(options)),
+    listActivity: (id, options = {}) => FetchPage(transport, RequestPath(API_PATHS.WEBHOOK_ACTIVITY, { id }), CURSOR_STYLES.CURSOR, options, WindowQuery(options)),
+    listAllActivity: (id, options = {}) => CollectAll(transport, RequestPath(API_PATHS.WEBHOOK_ACTIVITY, { id }), CURSOR_STYLES.CURSOR, options, WindowQuery(options)),
+    iterateActivity: (id, options = {}) => IteratePages(transport, RequestPath(API_PATHS.WEBHOOK_ACTIVITY, { id }), CURSOR_STYLES.CURSOR, options, WindowQuery(options)),
+    listWorkspaceActivity: (options = {}) => FetchPage(transport, API_PATHS.WEBHOOKS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery(options)),
+    listAllWorkspaceActivity: (options = {}) => CollectAll(transport, API_PATHS.WEBHOOKS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery(options)),
+    iterateWorkspaceActivity: (options = {}) => IteratePages(transport, API_PATHS.WEBHOOKS_ACTIVITY, CURSOR_STYLES.CURSOR, options, WorkspaceActivityQuery(options)),
+    getDelivery: (id, deliveryId, options = {}) => transport.request(RequestPath(API_PATHS.WEBHOOK_DELIVERY, { id, deliveryId }), {
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    replayDelivery: (id, deliveryId, options = {}) => transport.request(RequestPath(API_PATHS.WEBHOOK_DELIVERY_REPLAY, { id, deliveryId }), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listEvents: (options = {}) => transport.request(API_PATHS.WEBHOOKS_EVENTS, {
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    stats: (options = {}) => transport.request(API_PATHS.WEBHOOKS_STATS, {
+        query: {
+            ...WindowQuery(options),
+            [QUERY_KEYS.ENDPOINT_IDS]: options.endpointIds?.join(LIST_SEPARATOR),
+            [QUERY_KEYS.GRAIN]: options.grain,
+            [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes
+        },
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Tools = (transport) => ({
+    checkDmarc: (domain, options = {}) => transport.request(API_PATHS.TOOLS_DMARC, {
+        query: { [QUERY_KEYS.DOMAIN]: domain },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    checkBimi: (domain, options = {}) => transport.request(API_PATHS.TOOLS_BIMI, {
+        query: { [QUERY_KEYS.DOMAIN]: domain },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    checkDeliverability: (domain, options = {}) => transport.request(API_PATHS.TOOLS_DELIVERABILITY, {
+        query: { [QUERY_KEYS.DOMAIN]: domain },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    readVerificationCode: (body, options = {}) => transport.request(API_PATHS.TOOLS_VERIFICATION_CODE, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    estimateCost: (options = {}) => transport.request(API_PATHS.TOOLS_COST, {
+        query: {
+            [QUERY_KEYS.SENDS]: options.sends,
+            [QUERY_KEYS.DOMAINS]: options.domains,
+            [QUERY_KEYS.PEOPLE]: options.people,
+            [QUERY_KEYS.AI_ACTIONS]: options.aiActions,
+            [QUERY_KEYS.INTERVAL]: options.interval
+        },
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Support = (transport) => ({
+    send: (body, options = {}) => transport.request(API_PATHS.SUPPORT, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Encryption = (transport) => ({
+    listKeys: (options = {}) => FetchList(transport, API_PATHS.ENCRYPTION_KEYS, options),
+    publishKey: (body, options = {}) => transport.request(API_PATHS.ENCRYPTION_KEYS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    lookupKeys: (options) => FetchList(transport, API_PATHS.ENCRYPTION_KEYS_LOOKUP, options, {
+        [QUERY_KEYS.ADDRESSES]: options.addresses.join(LIST_SEPARATOR)
+    })
+});
+
+const Senders = (transport) => ({
+    get: (email, options = {}) => transport.request(RequestPath(API_PATHS.SENDER, { email }), { signal: options.signal, apiKey: options.apiKey }),
+    research: (email, options = {}) => transport.request(RequestPath(API_PATHS.SENDER_RESEARCH, { email }), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const ListQuery$1 = (options) => ({
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.SORT]: options.sort
+});
+const Chats = (transport) => ({
+    list: (options = {}) => FetchPage(transport, API_PATHS.CHATS, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
+    listAll: (options = {}) => CollectAll(transport, API_PATHS.CHATS, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
+    iterate: (options = {}) => IteratePages(transport, API_PATHS.CHATS, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.CHAT, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    rename: (id, title, options = {}) => transport.request(RequestPath(API_PATHS.CHAT, { id }), {
+        method: HTTP_METHODS.PATCH,
+        body: { title },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.CHAT, { id }), {
         method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
+    })
+});
+
+const MailboxQuery = (options) => ({
+    [QUERY_KEYS.FROM]: options.from === undefined ? undefined : ToInstant(options.from),
+    [QUERY_KEYS.TO]: options.to === undefined ? undefined : ToInstant(options.to),
+    [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes,
+    [QUERY_KEYS.GRAIN]: options.grain,
+    [QUERY_KEYS.ADDRESS]: options.address
+});
+const SendingQuery = (options) => ({
+    [QUERY_KEYS.DAYS]: options.days,
+    [QUERY_KEYS.MINUTES]: options.minutes,
+    [QUERY_KEYS.OFFSET_MINUTES]: options.offsetMinutes,
+    [QUERY_KEYS.GRAIN]: options.grain,
+    [QUERY_KEYS.ADDRESS]: options.address
+});
+const Analytics = (transport) => ({
+    mailbox: (options = {}) => transport.request(API_PATHS.ANALYTICS_MAILBOX, {
+        query: MailboxQuery(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    sending: (options = {}) => transport.request(API_PATHS.ANALYTICS_SENDING, {
+        query: SendingQuery(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const ListQuery = (options) => ({
+    [QUERY_KEYS.STATUS]: options.status,
+    [QUERY_KEYS.Q]: options.q,
+    [QUERY_KEYS.SORT]: options.sort,
+    [QUERY_KEYS.LIMIT]: options.limit,
+    [QUERY_KEYS.OFFSET]: options.offset,
+    [QUERY_KEYS.ADDRESS]: options.address
+});
+const Subscriptions = (transport) => ({
+    list: (options = {}) => transport.request(API_PATHS.SUBSCRIPTIONS, {
+        query: ListQuery(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listDomains: (options = {}) => transport.request(API_PATHS.SUBSCRIPTION_DOMAINS, {
+        query: ListQuery(options),
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    unsubscribe: (id, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.SUBSCRIPTION_UNSUBSCRIBE, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    unsubscribeDomain: (domain, body = {}, options = {}) => transport.request(RequestPath(API_PATHS.SUBSCRIPTION_DOMAIN_UNSUBSCRIBE, { domain }), {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    move: (id, body, options = {}) => transport.request(RequestPath(API_PATHS.SUBSCRIPTION_MOVE, { id }), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Exports = (transport) => ({
+    preview: (options = {}) => transport.request(API_PATHS.MAILBOX_EXPORTS_PREVIEW, { signal: options.signal, apiKey: options.apiKey }),
+    list: (options = {}) => transport.request(API_PATHS.MAILBOX_EXPORTS, {
+        query: { [QUERY_KEYS.LIMIT]: options.limit, [QUERY_KEYS.OFFSET]: options.offset },
+        signal: options.signal,
+        apiKey: options.apiKey
     }),
-    rotateSecret: (id, options = {}) => transport.request(WebhookChildPath(id, SEGMENTS.ROTATE_SECRET), {
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.MAILBOX_EXPORT, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    start: (options = {}) => transport.request(API_PATHS.MAILBOX_EXPORTS, {
         method: HTTP_METHODS.POST,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    test: (id, options = {}) => transport.request(WebhookChildPath(id, SEGMENTS.TEST), {
+    download: (id, options = {}) => transport.request(RequestPath(API_PATHS.MAILBOX_EXPORT_CONTENT, { id }), {
+        binary: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const DnsConnections = (transport) => ({
+    list: (options = {}) => transport.request(API_PATHS.DNS_CONNECTIONS, { signal: options.signal, apiKey: options.apiKey }),
+    get: (id, options = {}) => transport.request(RequestPath(API_PATHS.DNS_CONNECTION, { id }), { signal: options.signal, apiKey: options.apiKey }),
+    delete: (id, options = {}) => transport.request(RequestPath(API_PATHS.DNS_CONNECTION, { id }), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Workspaces = (transport) => ({
+    list: (options = {}) => transport.request(API_PATHS.WORKSPACES, { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(API_PATHS.WORKSPACES, {
         method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    getActive: (options = {}) => transport.request(API_PATHS.WORKSPACES_ACTIVE, { signal: options.signal, apiKey: options.apiKey }),
+    setActive: (workspaceId, options = {}) => transport.request(API_PATHS.WORKSPACES_ACTIVE, {
+        method: HTTP_METHODS.PUT,
+        body: { workspaceId },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options) => transport.request(RequestPath(API_PATHS.WORKSPACE, { id }), {
+        method: HTTP_METHODS.DELETE,
+        query: { [QUERY_KEYS.CONFIRM]: options.confirm },
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const PhotoType = (data, options) => {
+    if (options.contentType)
+        return options.contentType;
+    return typeof Blob !== 'undefined' && data instanceof Blob && data.type ? data.type : undefined;
+};
+const Account = (transport) => ({
+    getNotifications: (options = {}) => transport.request(API_PATHS.ACCOUNT_NOTIFICATIONS, { signal: options.signal, apiKey: options.apiKey }),
+    setEmailNotification: (category, body, options = {}) => transport.request(RequestPath(API_PATHS.ACCOUNT_NOTIFICATION_EMAIL, { category }), {
+        method: HTTP_METHODS.PUT,
+        body: { enabled: body.enabled },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setPushMuted: (workspaceId, body, options = {}) => transport.request(RequestPath(API_PATHS.ACCOUNT_NOTIFICATION_PUSH, { workspaceId }), {
+        method: HTTP_METHODS.PUT,
+        body: { muted: body.muted },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setPhoto: (data, options = {}) => transport.request(API_PATHS.ACCOUNT_PHOTO, {
+        method: HTTP_METHODS.PUT,
+        raw: data,
+        contentType: PhotoType(data, options),
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    removePhoto: (options = {}) => transport.request(API_PATHS.ACCOUNT_PHOTO, {
+        method: HTTP_METHODS.DELETE,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    getUsername: (options = {}) => transport.request(API_PATHS.ACCOUNT_USERNAME, { signal: options.signal, apiKey: options.apiKey }),
+    checkUsername: (username, options = {}) => transport.request(API_PATHS.ACCOUNT_USERNAME_AVAILABILITY, {
+        query: { [QUERY_KEYS.USERNAME]: username },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    setUsername: (username, options = {}) => transport.request(API_PATHS.ACCOUNT_USERNAME, {
+        method: HTTP_METHODS.PUT,
+        body: { username },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listConnectedApps: (options = {}) => FetchList(transport, API_PATHS.ACCOUNT_CONNECTED_APPS, options),
+    revokeConnectedApp: (clientId, options = {}) => transport.request(RequestPath(API_PATHS.ACCOUNT_CONNECTED_APP, { clientId }), {
+        method: HTTP_METHODS.DELETE,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    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), {
+    listInvitations: (options = {}) => FetchList(transport, API_PATHS.ACCOUNT_INVITATIONS, options),
+    acceptInvitation: (invitationId, options = {}) => transport.request(RequestPath(API_PATHS.ACCOUNT_INVITATION_ACCEPT, { invitationId }), {
+        method: HTTP_METHODS.POST,
+        body: options.activate === undefined ? {} : { activate: options.activate },
+        repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     }),
-    replayDelivery: (id, deliveryId, options = {}) => transport.request(WebhookDeliveryReplayPath(id, deliveryId), {
+    declineInvitation: (invitationId, options = {}) => transport.request(RequestPath(API_PATHS.ACCOUNT_INVITATION_DECLINE, { invitationId }), {
         method: HTTP_METHODS.POST,
+        repeatable: true,
         signal: options.signal,
         apiKey: options.apiKey
     })
@@ -2841,8 +4744,12 @@ class OpenEmail {
     labels;
     contacts;
     audiences;
+    billing;
+    forms;
     broadcasts;
     domains;
+    appHost;
+    branding;
     rules;
     webhooks;
     imports;
@@ -2853,7 +4760,19 @@ class OpenEmail {
     members;
     suppressions;
     files;
+    knowledge;
     tempMail;
+    exports;
+    chats;
+    encryption;
+    support;
+    tools;
+    senders;
+    analytics;
+    subscriptions;
+    dnsConnections;
+    workspaces;
+    account;
     constructor(configuration) {
         const options = typeof configuration === 'string' ? { apiKey: configuration } : configuration;
         AssertCredential(options.apiKey, options.accessToken, true);
@@ -2874,8 +4793,12 @@ class OpenEmail {
         this.labels = Labels(this.transport);
         this.contacts = Contacts(this.transport);
         this.audiences = Audiences(this.transport);
+        this.billing = Billing(this.transport);
+        this.forms = Forms(this.transport);
         this.broadcasts = Broadcasts(this.transport);
         this.domains = Domains(this.transport);
+        this.appHost = AppHost(this.transport);
+        this.branding = Branding(this.transport);
         this.rules = Rules(this.transport);
         this.webhooks = Webhooks(this.transport);
         this.imports = Imports(this.transport);
@@ -2886,7 +4809,19 @@ class OpenEmail {
         this.members = Members(this.transport);
         this.suppressions = Suppressions(this.transport);
         this.files = Files(this.transport);
+        this.knowledge = Knowledge(this.transport);
         this.tempMail = TempMail(this.transport);
+        this.exports = Exports(this.transport);
+        this.chats = Chats(this.transport);
+        this.encryption = Encryption(this.transport);
+        this.support = Support(this.transport);
+        this.tools = Tools(this.transport);
+        this.senders = Senders(this.transport);
+        this.analytics = Analytics(this.transport);
+        this.subscriptions = Subscriptions(this.transport);
+        this.dnsConnections = DnsConnections(this.transport);
+        this.workspaces = Workspaces(this.transport);
+        this.account = Account(this.transport);
     }
     get raw() {
         return this.transport;
@@ -2920,7 +4855,7 @@ const HostnameOf = (authority) => {
 const NormaliseEndpoint = (value) => {
     if (!value)
         return undefined;
-    const trimmed = value.trim().replace(/\/+$/, '');
+    const trimmed = value.trim().replace(TRAILING_SLASHES, '');
     if (trimmed.length === 0)
         return undefined;
     if (ENDPOINT_SCHEME_PATTERN.test(trimmed))
@@ -3007,7 +4942,7 @@ const VerifyWebhookSignature = async (props) => {
         throw new Error(WEBHOOK_MESSAGES.OUT_OF_TOLERANCE.replace('{{drift}}', String(drift)).replace('{{tolerance}}', String(tolerance)));
     }
     const encoder = new TextEncoder();
-    const key = await subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const key = await subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, HMAC_SIGN_USAGES);
     const expected = Hex(await subtle.sign('HMAC', key, encoder.encode(`${parsed.timestamp}.${payload}`)));
     if (!parsed.signatures.some(candidate => Equal(expected, candidate)))
         throw new Error(WEBHOOK_MESSAGES.MISMATCH);
@@ -3038,27 +4973,27 @@ const DefaultClient = new Proxy({}, {
 });
 
 const Key = (value) => value.trim().toLowerCase();
-const BY_CODE = new Map(LANGUAGES.map(language => [Key(language.code), language]));
-const BY_LABEL = new Map(LANGUAGES.map(language => [Key(language.label), language]));
-const BY_NATIVE = new Map(LANGUAGES.map(language => [Key(language.native), language]));
-const ALIASES = new Map(LANGUAGE_ALIASES.map(([alias, code]) => [Key(alias), Key(code)]));
-const LanguageByCode = (code) => code ? BY_CODE.get(Key(code)) : undefined;
+const byCode = new Map(LANGUAGES.map(language => [Key(language.code), language]));
+const byLabel = new Map(LANGUAGES.map(language => [Key(language.label), language]));
+const byNative = new Map(LANGUAGES.map(language => [Key(language.native), language]));
+const aliasCodes = new Map(LANGUAGE_ALIASES.map(([alias, code]) => [Key(alias), Key(code)]));
+const LanguageByCode = (code) => code ? byCode.get(Key(code)) : undefined;
 const ResolveLanguage = (input) => {
     if (!input)
         return undefined;
     const key = Key(input);
     if (!key)
         return undefined;
-    const aliased = ALIASES.get(key);
+    const aliased = aliasCodes.get(key);
     if (aliased)
-        return BY_CODE.get(aliased);
-    const direct = BY_CODE.get(key) ?? BY_LABEL.get(key) ?? BY_NATIVE.get(key);
+        return byCode.get(aliased);
+    const direct = byCode.get(key) ?? byLabel.get(key) ?? byNative.get(key);
     if (direct)
         return direct;
     const base = key.split(LANGUAGE_SUBTAG_PATTERN)[0];
     if (!base || base === key)
         return undefined;
-    return BY_CODE.get(ALIASES.get(base) ?? base);
+    return byCode.get(aliasCodes.get(base) ?? base);
 };
 const IsRtlLanguage = (code) => ResolveLanguage(code)?.rtl === true;
 
@@ -3078,43 +5013,148 @@ const resolveLanguage = ResolveLanguage;
 const languageByCode = LanguageByCode;
 const isRtlLanguage = IsRtlLanguage;
 
+exports.ADDRESS_FORWARD_CONSENT_STATUSES = ADDRESS_FORWARD_CONSENT_STATUSES;
+exports.ADDRESS_FORWARD_STATUSES = ADDRESS_FORWARD_STATUSES;
+exports.ADDRESS_MEMBER_VIAS = ADDRESS_MEMBER_VIAS;
 exports.API_SCOPES = API_SCOPES;
+exports.APP_HOST_STATUSES = APP_HOST_STATUSES;
+exports.APP_PASSWORD_ORIGINS = APP_PASSWORD_ORIGINS;
 exports.AUDIENCE_MEMBER_STATUSES = AUDIENCE_MEMBER_STATUSES;
+exports.BILLING_ALERT_KINDS = BILLING_ALERT_KINDS;
+exports.BILLING_ALERT_SEVERITIES = BILLING_ALERT_SEVERITIES;
+exports.BILLING_ALERT_TARGETS = BILLING_ALERT_TARGETS;
+exports.BILLING_INTERVALS = BILLING_INTERVALS;
+exports.BILLING_INVOICE_SORTS = BILLING_INVOICE_SORTS;
+exports.BILLING_INVOICE_STARTS = BILLING_INVOICE_STARTS;
+exports.BILLING_INVOICE_STATUSES = BILLING_INVOICE_STATUSES;
+exports.BILLING_THEMES = BILLING_THEMES;
+exports.BILLING_USAGE_WINDOWS = BILLING_USAGE_WINDOWS;
+exports.BIMI_STATUSES = BIMI_STATUSES;
+exports.BRAND_FONT_IDS = BRAND_FONT_IDS;
+exports.BRAND_IMAGE_TYPES = BRAND_IMAGE_TYPES;
+exports.BRAND_IMAGE_VARIANTS = BRAND_IMAGE_VARIANTS;
 exports.BROADCAST_RECIPIENT_FILTERS = BROADCAST_RECIPIENT_FILTERS;
 exports.BROADCAST_STATUSES = BROADCAST_STATUSES;
+exports.CALENDAR_COLORS = CALENDAR_COLORS;
+exports.CALENDAR_FEED_MODES = CALENDAR_FEED_MODES;
+exports.CALENDAR_REMINDER_ACTIONS = CALENDAR_REMINDER_ACTIONS;
+exports.CALENDAR_RESPONSES = CALENDAR_RESPONSES;
+exports.CALENDAR_SUBSCRIPTION_ERRORS = CALENDAR_SUBSCRIPTION_ERRORS;
+exports.CALENDAR_SUBSCRIPTION_STATUSES = CALENDAR_SUBSCRIPTION_STATUSES;
+exports.CALENDAR_TRANSPARENCIES = CALENDAR_TRANSPARENCIES;
+exports.CALENDAR_VISIBILITIES = CALENDAR_VISIBILITIES;
+exports.CHAT_SORTS = CHAT_SORTS;
+exports.CONNECTED_APP_KINDS = CONNECTED_APP_KINDS;
+exports.CONNECTED_APP_STATUSES = CONNECTED_APP_STATUSES;
+exports.CONSOLE_PERMISSIONS = CONSOLE_PERMISSIONS;
 exports.CONTACT_BLOCK_LISTS = CONTACT_BLOCK_LISTS;
+exports.CONTACT_CARD_LABELS = CONTACT_CARD_LABELS;
 exports.CONTACT_PHOTO_TYPES = CONTACT_PHOTO_TYPES;
+exports.CONTACT_SOURCES = CONTACT_SOURCES;
 exports.CONTACT_THREAD_SORTS = CONTACT_THREAD_SORTS;
 exports.CREDENTIAL_KINDS = CREDENTIAL_KINDS;
+exports.DELIVERABILITY_CHECK_IDS = DELIVERABILITY_CHECK_IDS;
+exports.DELIVERABILITY_CHECK_STATUSES = DELIVERABILITY_CHECK_STATUSES;
+exports.DELIVERABILITY_GRADES = DELIVERABILITY_GRADES;
+exports.DNS_CONNECTION_STATUSES = DNS_CONNECTION_STATUSES;
+exports.DNS_PROVISION_STATES = DNS_PROVISION_STATES;
+exports.DNS_SYNC_OUTCOMES = DNS_SYNC_OUTCOMES;
+exports.DNS_SYNC_PURPOSES = DNS_SYNC_PURPOSES;
+exports.DNS_ZONE_RESOLUTION_KINDS = DNS_ZONE_RESOLUTION_KINDS;
+exports.DOMAIN_ADDRESS_DESTINATIONS = DOMAIN_ADDRESS_DESTINATIONS;
+exports.DOMAIN_DMARC_POLICIES = DOMAIN_DMARC_POLICIES;
 exports.DOMAIN_DMARC_STAGES = DOMAIN_DMARC_STAGES;
+exports.DOMAIN_LOGO_MARK_KINDS = DOMAIN_LOGO_MARK_KINDS;
+exports.DOMAIN_LOGO_RECORD_OUTCOMES = DOMAIN_LOGO_RECORD_OUTCOMES;
 exports.DOMAIN_RECORD_STATUSES = DOMAIN_RECORD_STATUSES;
+exports.EMAIL_NOTIFICATION_CATEGORIES = EMAIL_NOTIFICATION_CATEGORIES;
 exports.ERROR_TYPES = ERROR_TYPES;
+exports.EXPORT_PHASES = EXPORT_PHASES;
+exports.EXPORT_REFUSALS = EXPORT_REFUSALS;
+exports.EXPORT_STATUSES = EXPORT_STATUSES;
 exports.FILE_DIRECTIONS = FILE_DIRECTIONS;
 exports.FILE_KINDS = FILE_KINDS;
 exports.FILE_SORTS = FILE_SORTS;
 exports.FILE_USAGES = FILE_USAGES;
 exports.FILE_VISIBILITIES = FILE_VISIBILITIES;
+exports.FORM_ALIGNS = FORM_ALIGNS;
+exports.FORM_CONFIRM_SOURCES = FORM_CONFIRM_SOURCES;
+exports.FORM_CONTACT_FIELDS = FORM_CONTACT_FIELDS;
+exports.FORM_FIELD_ERRORS = FORM_FIELD_ERRORS;
+exports.FORM_FIELD_TYPES = FORM_FIELD_TYPES;
+exports.FORM_FIELD_WIDTHS = FORM_FIELD_WIDTHS;
+exports.FORM_FONTS = FORM_FONTS;
+exports.FORM_LAYOUTS = FORM_LAYOUTS;
+exports.FORM_RADII = FORM_RADII;
+exports.FORM_SENDER_ISSUES = FORM_SENDER_ISSUES;
+exports.FORM_STARTER_SLUGS = FORM_STARTER_SLUGS;
+exports.FORM_STATUSES = FORM_STATUSES;
+exports.FORM_SUBMISSION_STATUSES = FORM_SUBMISSION_STATUSES;
+exports.FORM_SUBSCRIBE_OUTCOMES = FORM_SUBSCRIBE_OUTCOMES;
+exports.FORM_SUCCESS_ACTIONS = FORM_SUCCESS_ACTIONS;
+exports.FORM_WIDTHS = FORM_WIDTHS;
+exports.IMPORT_FORMATS = IMPORT_FORMATS;
+exports.KNOWLEDGE_CONNECTOR_KINDS = KNOWLEDGE_CONNECTOR_KINDS;
+exports.KNOWLEDGE_CONNECTOR_STATUSES = KNOWLEDGE_CONNECTOR_STATUSES;
+exports.KNOWLEDGE_FAILURES = KNOWLEDGE_FAILURES;
+exports.KNOWLEDGE_FLAG_KINDS = KNOWLEDGE_FLAG_KINDS;
+exports.KNOWLEDGE_FLAG_STATUSES = KNOWLEDGE_FLAG_STATUSES;
+exports.KNOWLEDGE_KINDS = KNOWLEDGE_KINDS;
+exports.KNOWLEDGE_LEVELS = KNOWLEDGE_LEVELS;
+exports.KNOWLEDGE_ORIGINS = KNOWLEDGE_ORIGINS;
+exports.KNOWLEDGE_REFRESH_DAY_CHOICES = KNOWLEDGE_REFRESH_DAY_CHOICES;
+exports.KNOWLEDGE_STATUSES = KNOWLEDGE_STATUSES;
+exports.KNOWLEDGE_SUGGESTION_KINDS = KNOWLEDGE_SUGGESTION_KINDS;
+exports.KNOWLEDGE_SUGGESTION_STATUSES = KNOWLEDGE_SUGGESTION_STATUSES;
 exports.LANGUAGES = LANGUAGES;
+exports.LOGIN_BACKGROUND_KINDS = LOGIN_BACKGROUND_KINDS;
+exports.LOGIN_BACKGROUND_PRESETS = LOGIN_BACKGROUND_PRESETS;
+exports.LOGIN_LOGOS = LOGIN_LOGOS;
+exports.MAIL_APP_PROTOCOLS = MAIL_APP_PROTOCOLS;
+exports.MAIL_APP_SECURITIES = MAIL_APP_SECURITIES;
+exports.MAIL_SERVICES = MAIL_SERVICES;
 exports.MESSAGE_ENCRYPTION_FORMATS = MESSAGE_ENCRYPTION_FORMATS;
 exports.OpenEmail = OpenEmail;
 exports.OpenEmailApiError = OpenEmailApiError;
 exports.OpenEmailNetworkError = OpenEmailNetworkError;
 exports.PAGE_LIMITS = PAGE_LIMITS;
+exports.PAID_PLAN_IDS = PAID_PLAN_IDS;
+exports.PAY_AS_YOU_GO_LIMITS_CENTS = PAY_AS_YOU_GO_LIMITS_CENTS;
 exports.PEOPLE_SORTS = PEOPLE_SORTS;
+exports.PLAN_BLOCKERS = PLAN_BLOCKERS;
+exports.PLAN_IDS = PLAN_IDS;
 exports.PROVIDER_IMPORT_DOMAIN_STATES = PROVIDER_IMPORT_DOMAIN_STATES;
+exports.PROVIDER_IMPORT_PROVIDERS = PROVIDER_IMPORT_PROVIDERS;
 exports.PROVIDER_IMPORT_RESOURCES = PROVIDER_IMPORT_RESOURCES;
 exports.PROVIDER_IMPORT_STATUSES = PROVIDER_IMPORT_STATUSES;
+exports.REPLY_SUGGESTION_STATES = REPLY_SUGGESTION_STATES;
+exports.REWRITE_ACTIONS = REWRITE_ACTIONS;
+exports.REWRITE_TARGETS = REWRITE_TARGETS;
 exports.RULE_ACTIONS = RULE_ACTIONS;
 exports.RULE_FIELDS = RULE_FIELDS;
 exports.RULE_OPERATORS = RULE_OPERATORS;
+exports.SETTINGS_COLOR_THEMES = SETTINGS_COLOR_THEMES;
+exports.SETTINGS_DATE_FORMATS = SETTINGS_DATE_FORMATS;
+exports.SETTINGS_IMAGE_COMPRESSIONS = SETTINGS_IMAGE_COMPRESSIONS;
+exports.SETTINGS_TIME_FORMATS = SETTINGS_TIME_FORMATS;
+exports.SETTINGS_WEEK_STARTS = SETTINGS_WEEK_STARTS;
 exports.STEP_UP_ERROR_CODES = STEP_UP_ERROR_CODES;
 exports.STEP_UP_METHODS = STEP_UP_METHODS;
+exports.SUBSCRIPTION_DESTINATIONS = SUBSCRIPTION_DESTINATIONS;
+exports.SUBSCRIPTION_SORTS = SUBSCRIPTION_SORTS;
+exports.SUBSCRIPTION_STATUSES = SUBSCRIPTION_STATUSES;
 exports.SUPPRESSION_REASONS = SUPPRESSION_REASONS;
+exports.TEMPLATE_IMAGE_TYPES = TEMPLATE_IMAGE_TYPES;
+exports.THREAD_NOTE_COLORS = THREAD_NOTE_COLORS;
 exports.THREAD_SORTS = THREAD_SORTS;
+exports.THREAD_SUMMARY_STATES = THREAD_SUMMARY_STATES;
+exports.UNSUBSCRIBE_METHODS = UNSUBSCRIBE_METHODS;
+exports.USERNAME_STATUSES = USERNAME_STATUSES;
 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.WORKSPACE_KINDS = WORKSPACE_KINDS;
 exports.createClient = createClient;
 exports.createOpenEmail = createOpenEmail;
 exports.createTempMail = createTempMail;