@openemail/sdk 0.0.1

package/index.js

@@ -0,0 +1,1744 @@
+var version = "0.0.1";
+
+const BUILD_BASE_URL = 'https://api.openemail.uk';
+
+const DEFAULTS = {
+    BASE_URL: BUILD_BASE_URL,
+    MAX_RETRIES: 2,
+    TIMEOUT_MS: 30_000,
+    USER_AGENT: `openemail-sdk/${version}`
+};
+const BROWSER_REFUSAL = [
+    'OpenEmail refused to start in a browser.',
+    '',
+    '  This client carries a workspace API key that can send mail and read the mailbox. Anything',
+    '  you ship to a browser is readable by anyone who opens devtools.',
+    '',
+    '  Call it from a server, a serverless function or a script instead. Disposable inboxes are',
+    '  the exception: createTempMail() needs no API key and is safe to use in a browser.',
+    '',
+    '  If you are certain this environment is not a real browser, for example a test harness that',
+    '  defines window and document, pass { dangerouslyAllowBrowser: true }.'
+].join('\n');
+const ENV_VARS = {
+    API_KEY: 'OPENEMAIL_API_KEY',
+    BASE_URL: 'OPENEMAIL_BASE_URL'
+};
+const API_KEY_PREFIXES = {
+    LIVE: 'oe_live_',
+    TEST: 'oe_test_'
+};
+const API_KEY_MODES = {
+    LIVE: 'live',
+    TEST: 'test'
+};
+const CLIENT_MESSAGES = {
+    API_KEY_REQUIRED: `An OpenEmail API key is required. Pass { apiKey } or set ${ENV_VARS.API_KEY}. Create one in OpenEmail under Settings, API keys.`,
+    API_KEY_SHAPE: 'is not an OpenEmail API key. The API accepts only keys beginning "oe_live_" or "oe_test_", so a session cookie, a session token or a key for another service is refused.',
+    BASE_URL_SHAPE: 'is not a usable base URL. Pass an origin such as "https://api.openemail.uk", or the http origin of a server you run yourself.',
+    NO_FETCH: 'No global fetch is available. Pass one as { fetch }, or run on Node 20+, Bun, Deno, Cloudflare Workers or a browser.',
+    EMPTY_SEGMENT: 'An id must not be empty.',
+    DOT_SEGMENT: 'is not a usable id: a path segment made only of dots is removed by URL parsers, so the request would reach a different endpoint.'
+};
+
+const MESSAGE_ENCRYPTION_FORMATS = [
+    'pgp-mime',
+    'pgp-signed',
+    'pgp-inline',
+    'smime-encrypted',
+    'smime-signed'
+];
+const SEALED_ENCRYPTION_FORMATS = ['pgp-mime', 'pgp-inline', 'smime-encrypted'];
+const BASE64_CHUNK_SIZE = 0x8000;
+
+const ERROR_TYPES = [
+    'invalid_request_error',
+    'authentication_error',
+    'permission_error',
+    'not_found_error',
+    'conflict_error',
+    'validation_error',
+    'rate_limit_error',
+    'api_error'
+];
+const ERROR_TYPE = {
+    INVALID_REQUEST: 'invalid_request_error',
+    AUTHENTICATION: 'authentication_error',
+    PERMISSION: 'permission_error',
+    NOT_FOUND: 'not_found_error',
+    CONFLICT: 'conflict_error',
+    VALIDATION: 'validation_error',
+    RATE_LIMIT: 'rate_limit_error',
+    API: 'api_error'
+};
+const ERROR_TYPE_BY_STATUS = {
+    401: ERROR_TYPE.AUTHENTICATION,
+    403: ERROR_TYPE.PERMISSION,
+    404: ERROR_TYPE.NOT_FOUND,
+    409: ERROR_TYPE.CONFLICT,
+    422: ERROR_TYPE.VALIDATION,
+    429: ERROR_TYPE.RATE_LIMIT
+};
+const ERROR_CODES = {
+    INSUFFICIENT_SCOPE: 'insufficient_scope',
+    UNRECOGNISED_RESPONSE: 'unrecognised_response'
+};
+const ERROR_NAMES = {
+    API: 'OpenEmailApiError',
+    NETWORK: 'OpenEmailNetworkError',
+    TIMEOUT: 'TimeoutError'};
+
+const HTTP_METHODS = {
+    GET: 'GET',
+    POST: 'POST',
+    PATCH: 'PATCH',
+    DELETE: 'DELETE'
+};
+const HEADER_KEYS = {
+    AUTHORIZATION: 'Authorization',
+    ACCEPT: 'Accept',
+    CONTENT_TYPE: 'Content-Type',
+    USER_AGENT: 'User-Agent',
+    IDEMPOTENCY_KEY: 'Idempotency-Key',
+    RETRY_AFTER: 'retry-after',
+    REQUEST_ID: 'x-request-id'
+};
+const CONTENT_TYPES = {
+    JSON: 'application/json',
+    CALENDAR: 'text/calendar'
+};
+const RETRY = {
+    STATUSES: [408, 429, 500, 502, 503, 504],
+    METHODS: ['GET'],
+    BASE_BACKOFF_MS: 500,
+    MAX_BACKOFF_MS: 8_000,
+    MAX_HONOURED_RETRY_AFTER_MS: 60_000,
+    RATE_LIMIT_STATUS: 429
+};
+const IDEMPOTENCY_KEY_PREFIX = 'oe-';
+
+const LANGUAGES = [
+    { code: 'en', label: 'English', native: 'English', flag: '🇬🇧', rtl: false },
+    { code: 'es', label: 'Spanish', native: 'Español', flag: '🇪🇸', rtl: false },
+    { code: 'zh-Hans', label: 'Simplified Chinese', native: '简体中文', flag: '🇨🇳', rtl: false },
+    { code: 'zh-Hant', label: 'Traditional Chinese', native: '繁體中文', flag: '🇹🇼', rtl: false },
+    { code: 'hi', label: 'Hindi', native: 'हिन्दी', flag: '🇮🇳', rtl: false },
+    { code: 'ar', label: 'Arabic', native: 'العربية', flag: '🇸🇦', rtl: true },
+    { code: 'pt-BR', label: 'Brazilian Portuguese', native: 'Português (Brasil)', flag: '🇧🇷', rtl: false },
+    { code: 'pt', label: 'Portuguese', native: 'Português', flag: '🇵🇹', rtl: false },
+    { code: 'fr', label: 'French', native: 'Français', flag: '🇫🇷', rtl: false },
+    { code: 'de', label: 'German', native: 'Deutsch', flag: '🇩🇪', rtl: false },
+    { code: 'ru', label: 'Russian', native: 'Русский', flag: '🇷🇺', rtl: false },
+    { code: 'ja', label: 'Japanese', native: '日本語', flag: '🇯🇵', rtl: false },
+    { code: 'ko', label: 'Korean', native: '한국어', flag: '🇰🇷', rtl: false },
+    { code: 'it', label: 'Italian', native: 'Italiano', flag: '🇮🇹', rtl: false },
+    { code: 'nl', label: 'Dutch', native: 'Nederlands', flag: '🇳🇱', rtl: false },
+    { code: 'tr', label: 'Turkish', native: 'Türkçe', flag: '🇹🇷', rtl: false },
+    { code: 'pl', label: 'Polish', native: 'Polski', flag: '🇵🇱', rtl: false },
+    { code: 'uk', label: 'Ukrainian', native: 'Українська', flag: '🇺🇦', rtl: false },
+    { code: 'vi', label: 'Vietnamese', native: 'Tiếng Việt', flag: '🇻🇳', rtl: false },
+    { code: 'id', label: 'Indonesian', native: 'Bahasa Indonesia', flag: '🇮🇩', rtl: false },
+    { code: 'th', label: 'Thai', native: 'ไทย', flag: '🇹🇭', rtl: false },
+    { code: 'sv', label: 'Swedish', native: 'Svenska', flag: '🇸🇪', rtl: false },
+    { code: 'da', label: 'Danish', native: 'Dansk', flag: '🇩🇰', rtl: false },
+    { code: 'no', label: 'Norwegian', native: 'Norsk', flag: '🇳🇴', rtl: false },
+    { code: 'fi', label: 'Finnish', native: 'Suomi', flag: '🇫🇮', rtl: false },
+    { code: 'cs', label: 'Czech', native: 'Čeština', flag: '🇨🇿', rtl: false },
+    { code: 'el', label: 'Greek', native: 'Ελληνικά', flag: '🇬🇷', rtl: false },
+    { code: 'he', label: 'Hebrew', native: 'עברית', flag: '🇮🇱', rtl: true },
+    { code: 'ro', label: 'Romanian', native: 'Română', flag: '🇷🇴', rtl: false },
+    { code: 'hu', label: 'Hungarian', native: 'Magyar', flag: '🇭🇺', rtl: false },
+    { code: 'bn', label: 'Bengali', native: 'বাংলা', flag: '🇧🇩', rtl: false },
+    { code: 'ur', label: 'Urdu', native: 'اردو', flag: '🇵🇰', rtl: true },
+    { code: 'fa', label: 'Persian', native: 'فارسی', flag: '🇮🇷', rtl: true },
+    { code: 'ms', label: 'Malay', native: 'Bahasa Melayu', flag: '🇲🇾', rtl: false },
+    { code: 'ta', label: 'Tamil', native: 'தமிழ்', flag: '🇮🇳', rtl: false },
+    { code: 'ca', label: 'Catalan', native: 'Català', flag: '🇦🇩', rtl: false },
+    { code: 'en-GB', label: 'British English', native: 'English (United Kingdom)', flag: '🇬🇧', rtl: false },
+    { code: 'en-US', label: 'American English', native: 'English (United States)', flag: '🇺🇸', rtl: false },
+    { code: 'es-419', label: 'Latin American Spanish', native: 'Español (Latinoamérica)', flag: '🇲🇽', rtl: false },
+    { code: 'fr-CA', label: 'Canadian French', native: 'Français (Canada)', flag: '🇨🇦', rtl: false },
+    { code: 'de-AT', label: 'Austrian German', native: 'Deutsch (Österreich)', flag: '🇦🇹', rtl: false },
+    { code: 'de-CH', label: 'Swiss Standard German', native: 'Deutsch (Schweiz)', flag: '🇨🇭', rtl: false },
+    { code: 'nl-BE', label: 'Flemish', native: 'Vlaams', flag: '🇧🇪', rtl: false },
+    { code: 'zh-HK', label: 'Hong Kong Chinese', native: '繁體中文（香港）', flag: '🇭🇰', rtl: false },
+    { code: 'yue', label: 'Cantonese', native: '粵語', flag: '🇭🇰', rtl: false },
+    { code: 'nb', label: 'Norwegian Bokmål', native: 'Norsk bokmål', flag: '🇳🇴', rtl: false },
+    { code: 'nn', label: 'Norwegian Nynorsk', native: 'Norsk nynorsk', flag: '🇳🇴', rtl: false },
+    { code: 'sr', label: 'Serbian', native: 'Српски', flag: '🇷🇸', rtl: false },
+    { code: 'sr-Latn', label: 'Serbian (Latin)', native: 'Srpski (latinica)', flag: '🇷🇸', rtl: false },
+    { code: 'ar-EG', label: 'Egyptian Arabic', native: 'العربية (مصر)', flag: '🇪🇬', rtl: true },
+    { code: 'ar-MA', label: 'Moroccan Arabic', native: 'الدارجة المغربية', flag: '🇲🇦', rtl: true },
+    { code: 'sk', label: 'Slovak', native: 'Slovenčina', flag: '🇸🇰', rtl: false },
+    { code: 'sl', label: 'Slovenian', native: 'Slovenščina', flag: '🇸🇮', rtl: false },
+    { code: 'hr', label: 'Croatian', native: 'Hrvatski', flag: '🇭🇷', rtl: false },
+    { code: 'bs', label: 'Bosnian', native: 'Bosanski', flag: '🇧🇦', rtl: false },
+    { code: 'cnr', label: 'Montenegrin', native: 'Crnogorski', flag: '🇲🇪', rtl: false },
+    { code: 'mk', label: 'Macedonian', native: 'Македонски', flag: '🇲🇰', rtl: false },
+    { code: 'bg', label: 'Bulgarian', native: 'Български', flag: '🇧🇬', rtl: false },
+    { code: 'be', label: 'Belarusian', native: 'Беларуская', flag: '🇧🇾', rtl: false },
+    { code: 'hsb', label: 'Upper Sorbian', native: 'Hornjoserbšćina', flag: '🇩🇪', rtl: false },
+    { code: 'rue', label: 'Rusyn', native: 'Русиньскый', flag: '🇸🇰', rtl: false },
+    { code: 'lt', label: 'Lithuanian', native: 'Lietuvių', flag: '🇱🇹', rtl: false },
+    { code: 'lv', label: 'Latvian', native: 'Latviešu', flag: '🇱🇻', rtl: false },
+    { code: 'et', label: 'Estonian', native: 'Eesti', flag: '🇪🇪', rtl: false },
+    { code: 'se', label: 'Northern Sami', native: 'Davvisámegiella', flag: '🇳🇴', rtl: false },
+    { code: 'is', label: 'Icelandic', native: 'Íslenska', flag: '🇮🇸', rtl: false },
+    { code: 'fo', label: 'Faroese', native: 'Føroyskt', flag: '🇫🇴', rtl: false },
+    { code: 'kl', label: 'Greenlandic', native: 'Kalaallisut', flag: '🇬🇱', rtl: false },
+    { code: 'ga', label: 'Irish', native: 'Gaeilge', flag: '🇮🇪', rtl: false },
+    { code: 'gd', label: 'Scottish Gaelic', native: 'Gàidhlig', flag: '🇬🇧', rtl: false },
+    { code: 'cy', label: 'Welsh', native: 'Cymraeg', flag: '🇬🇧', rtl: false },
+    { code: 'kw', label: 'Cornish', native: 'Kernewek', flag: '🇬🇧', rtl: false },
+    { code: 'gv', label: 'Manx', native: 'Gaelg', flag: '🇮🇲', rtl: false },
+    { code: 'br', label: 'Breton', native: 'Brezhoneg', flag: '🇫🇷', rtl: false },
+    { code: 'eu', label: 'Basque', native: 'Euskara', flag: '🇪🇸', rtl: false },
+    { code: 'gl', label: 'Galician', native: 'Galego', flag: '🇪🇸', rtl: false },
+    { code: 'ast', label: 'Asturian', native: 'Asturianu', flag: '🇪🇸', rtl: false },
+    { code: 'an', label: 'Aragonese', native: 'Aragonés', flag: '🇪🇸', rtl: false },
+    { code: 'oc', label: 'Occitan', native: 'Occitan', flag: '🇫🇷', rtl: false },
+    { code: 'co', label: 'Corsican', native: 'Corsu', flag: '🇫🇷', rtl: false },
+    { code: 'sc', label: 'Sardinian', native: 'Sardu', flag: '🇮🇹', rtl: false },
+    { code: 'fur', label: 'Friulian', native: 'Furlan', flag: '🇮🇹', rtl: false },
+    { code: 'rm', label: 'Romansh', native: 'Rumantsch', flag: '🇨🇭', rtl: false },
+    { code: 'gsw', label: 'Alemannic German', native: 'Schwiizerdütsch', flag: '🇨🇭', rtl: false },
+    { code: 'lb', label: 'Luxembourgish', native: 'Lëtzebuergesch', flag: '🇱🇺', rtl: false },
+    { code: 'nds', label: 'Low German', native: 'Plattdüütsch', flag: '🇩🇪', rtl: false },
+    { code: 'bar', label: 'Bavarian', native: 'Boarisch', flag: '🇩🇪', rtl: false },
+    { code: 'fy', label: 'Western Frisian', native: 'Frysk', flag: '🇳🇱', rtl: false },
+    { code: 'li', label: 'Limburgish', native: 'Limburgs', flag: '🇳🇱', rtl: false },
+    { code: 'wa', label: 'Walloon', native: 'Walon', flag: '🇧🇪', rtl: false },
+    { code: 'mt', label: 'Maltese', native: 'Malti', flag: '🇲🇹', rtl: false },
+    { code: 'sq', label: 'Albanian', native: 'Shqip', flag: '🇦🇱', rtl: false },
+    { code: 'la', label: 'Latin', native: 'Latina', flag: '🇻🇦', rtl: false },
+    { code: 'eo', label: 'Esperanto', native: 'Esperanto', flag: '🇪🇺', rtl: false },
+    { code: 'yi', label: 'Yiddish', native: 'ייִדיש', flag: '🇮🇱', rtl: true },
+    { code: 'hy', label: 'Armenian', native: 'Հայերեն', flag: '🇦🇲', rtl: false },
+    { code: 'ka', label: 'Georgian', native: 'ქართული', flag: '🇬🇪', rtl: false },
+    { code: 'os', label: 'Ossetian', native: 'Ирон æвзаг', flag: '🇬🇪', rtl: false },
+    { code: 'ab', label: 'Abkhaz', native: 'Аԥсшәа', flag: '🇬🇪', rtl: false },
+    { code: 'ce', label: 'Chechen', native: 'Нохчийн мотт', flag: '🇷🇺', rtl: false },
+    { code: 'az', label: 'Azerbaijani', native: 'Azərbaycan dili', flag: '🇦🇿', rtl: false },
+    { code: 'kk', label: 'Kazakh', native: 'Қазақ тілі', flag: '🇰🇿', rtl: false },
+    { code: 'ky', label: 'Kyrgyz', native: 'Кыргызча', flag: '🇰🇬', rtl: false },
+    { code: 'uz', label: 'Uzbek', native: 'Oʻzbekcha', flag: '🇺🇿', rtl: false },
+    { code: 'tk', label: 'Turkmen', native: 'Türkmençe', flag: '🇹🇲', rtl: false },
+    { code: 'tt', label: 'Tatar', native: 'Татар теле', flag: '🇷🇺', rtl: false },
+    { code: 'ba', label: 'Bashkir', native: 'Башҡортса', flag: '🇷🇺', rtl: false },
+    { code: 'cv', label: 'Chuvash', native: 'Чӑвашла', flag: '🇷🇺', rtl: false },
+    { code: 'sah', label: 'Yakut', native: 'Саха тыла', flag: '🇷🇺', rtl: false },
+    { code: 'ug', label: 'Uyghur', native: 'ئۇيغۇرچە', flag: '🇨🇳', rtl: true },
+    { code: 'mn', label: 'Mongolian', native: 'Монгол хэл', flag: '🇲🇳', rtl: false },
+    { code: 'bo', label: 'Tibetan', native: 'བོད་སྐད་', flag: '🇨🇳', rtl: false },
+    { code: 'dz', label: 'Dzongkha', native: 'རྫོང་ཁ', flag: '🇧🇹', rtl: false },
+    { code: 'fa-AF', label: 'Dari', native: 'دری', flag: '🇦🇫', rtl: true },
+    { code: 'ps', label: 'Pashto', native: 'پښتو', flag: '🇦🇫', rtl: true },
+    { code: 'ku', label: 'Kurmanji Kurdish', native: 'Kurmancî', flag: '🇹🇷', rtl: false },
+    { code: 'ckb', label: 'Sorani Kurdish', native: 'کوردیی ناوەندی', flag: '🇮🇶', rtl: true },
+    { code: 'syr', label: 'Syriac', native: 'ܣܘܪܝܝܐ', flag: '🇮🇶', rtl: true },
+    { code: 'te', label: 'Telugu', native: 'తెలుగు', flag: '🇮🇳', rtl: false },
+    { code: 'mr', label: 'Marathi', native: 'मराठी', flag: '🇮🇳', rtl: false },
+    { code: 'gu', label: 'Gujarati', native: 'ગુજરાતી', flag: '🇮🇳', rtl: false },
+    { code: 'kn', label: 'Kannada', native: 'ಕನ್ನಡ', flag: '🇮🇳', rtl: false },
+    { code: 'ml', label: 'Malayalam', native: 'മലയാളം', flag: '🇮🇳', rtl: false },
+    { code: 'or', label: 'Odia', native: 'ଓଡ଼ିଆ', flag: '🇮🇳', rtl: false },
+    { code: 'pa', label: 'Punjabi', native: 'ਪੰਜਾਬੀ', flag: '🇮🇳', rtl: false },
+    { code: 'pa-Arab', label: 'Western Punjabi', native: 'پنجابی', flag: '🇵🇰', rtl: true },
+    { code: 'as', label: 'Assamese', native: 'অসমীয়া', flag: '🇮🇳', rtl: false },
+    { code: 'mai', label: 'Maithili', native: 'मैथिली', flag: '🇮🇳', rtl: false },
+    { code: 'bho', label: 'Bhojpuri', native: 'भोजपुरी', flag: '🇮🇳', rtl: false },
+    { code: 'sat', label: 'Santali', native: 'ᱥᱟᱱᱛᱟᱲᱤ', flag: '🇮🇳', rtl: false },
+    { code: 'ks', label: 'Kashmiri', native: 'کٲشُر', flag: '🇮🇳', rtl: true },
+    { code: 'sa', label: 'Sanskrit', native: 'संस्कृतम्', flag: '🇮🇳', rtl: false },
+    { code: 'ne', label: 'Nepali', native: 'नेपाली', flag: '🇳🇵', rtl: false },
+    { code: 'si', label: 'Sinhala', native: 'සිංහල', flag: '🇱🇰', rtl: false },
+    { code: 'sd', label: 'Sindhi', native: 'سنڌي', flag: '🇵🇰', rtl: true },
+    { code: 'dv', label: 'Divehi', native: 'ދިވެހި', flag: '🇲🇻', rtl: true },
+    { code: 'km', label: 'Khmer', native: 'ភាសាខ្មែរ', flag: '🇰🇭', rtl: false },
+    { code: 'lo', label: 'Lao', native: 'ລາວ', flag: '🇱🇦', rtl: false },
+    { code: 'my', label: 'Burmese', native: 'မြန်မာဘာသာ', flag: '🇲🇲', rtl: false },
+    { code: 'jv', label: 'Javanese', native: 'Basa Jawa', flag: '🇮🇩', rtl: false },
+    { code: 'su', label: 'Sundanese', native: 'Basa Sunda', flag: '🇮🇩', rtl: false },
+    { code: 'fil', label: 'Filipino', native: 'Filipino', flag: '🇵🇭', rtl: false },
+    { code: 'tl', label: 'Tagalog', native: 'Tagalog', flag: '🇵🇭', rtl: false },
+    { code: 'ceb', label: 'Cebuano', native: 'Binisaya', flag: '🇵🇭', rtl: false },
+    { code: 'ilo', label: 'Ilocano', native: 'Ilokano', flag: '🇵🇭', rtl: false },
+    { code: 'war', label: 'Waray', native: 'Winaray', flag: '🇵🇭', rtl: false },
+    { code: 'sw', label: 'Swahili', native: 'Kiswahili', flag: '🇰🇪', rtl: false },
+    { code: 'am', label: 'Amharic', native: 'አማርኛ', flag: '🇪🇹', rtl: false },
+    { code: 'ti', label: 'Tigrinya', native: 'ትግርኛ', flag: '🇪🇷', rtl: false },
+    { code: 'om', label: 'Oromo', native: 'Afaan Oromoo', flag: '🇪🇹', rtl: false },
+    { code: 'so', label: 'Somali', native: 'Soomaali', flag: '🇸🇴', rtl: false },
+    { code: 'ha', label: 'Hausa', native: 'Hausa', flag: '🇳🇬', rtl: false },
+    { code: 'yo', label: 'Yoruba', native: 'Yorùbá', flag: '🇳🇬', rtl: false },
+    { code: 'ig', label: 'Igbo', native: 'Igbo', flag: '🇳🇬', rtl: false },
+    { code: 'af', label: 'Afrikaans', native: 'Afrikaans', flag: '🇿🇦', rtl: false },
+    { code: 'zu', label: 'Zulu', native: 'isiZulu', flag: '🇿🇦', rtl: false },
+    { code: 'xh', label: 'Xhosa', native: 'isiXhosa', flag: '🇿🇦', rtl: false },
+    { code: 'st', label: 'Sesotho', native: 'Sesotho', flag: '🇱🇸', rtl: false },
+    { code: 'nso', label: 'Sepedi', native: 'Sepedi', flag: '🇿🇦', rtl: false },
+    { code: 'tn', label: 'Setswana', native: 'Setswana', flag: '🇧🇼', rtl: false },
+    { code: 'ts', label: 'Xitsonga', native: 'Xitsonga', flag: '🇿🇦', rtl: false },
+    { code: 've', label: 'Tshivenda', native: 'Tshivenḓa', flag: '🇿🇦', rtl: false },
+    { code: 'ss', label: 'Swati', native: 'siSwati', flag: '🇸🇿', rtl: false },
+    { code: 'nr', label: 'Southern Ndebele', native: 'isiNdebele', flag: '🇿🇦', rtl: false },
+    { code: 'sn', label: 'Shona', native: 'chiShona', flag: '🇿🇼', rtl: false },
+    { code: 'ny', label: 'Chichewa', native: 'Chichewa', flag: '🇲🇼', rtl: false },
+    { code: 'rw', label: 'Kinyarwanda', native: 'Ikinyarwanda', flag: '🇷🇼', rtl: false },
+    { code: 'rn', label: 'Kirundi', native: 'Ikirundi', flag: '🇧🇮', rtl: false },
+    { code: 'lg', label: 'Luganda', native: 'Luganda', flag: '🇺🇬', rtl: false },
+    { code: 'ln', label: 'Lingala', native: 'Lingála', flag: '🇨🇩', rtl: false },
+    { code: 'kg', label: 'Kikongo', native: 'Kikongo', flag: '🇨🇩', rtl: false },
+    { code: 'wo', label: 'Wolof', native: 'Wolof', flag: '🇸🇳', rtl: false },
+    { code: 'ff', label: 'Fula', native: 'Pulaar', flag: '🇸🇳', rtl: false },
+    { code: 'bm', label: 'Bambara', native: 'Bamanankan', flag: '🇲🇱', rtl: false },
+    { code: 'ak', label: 'Akan', native: 'Akan', flag: '🇬🇭', rtl: false },
+    { code: 'tw', label: 'Twi', native: 'Twi', flag: '🇬🇭', rtl: false },
+    { code: 'ee', label: 'Ewe', native: 'Eʋegbe', flag: '🇬🇭', rtl: false },
+    { code: 'mg', label: 'Malagasy', native: 'Malagasy', flag: '🇲🇬', rtl: false },
+    { code: 'kab', label: 'Kabyle', native: 'Taqbaylit', flag: '🇩🇿', rtl: false },
+    { code: 'tzm', label: 'Tamazight', native: 'ⵜⴰⵎⴰⵣⵉⵖⵜ', flag: '🇲🇦', rtl: false },
+    { code: 'sg', label: 'Sango', native: 'Sängö', flag: '🇨🇫', rtl: false },
+    { code: 'ht', label: 'Haitian Creole', native: 'Kreyòl ayisyen', flag: '🇭🇹', rtl: false },
+    { code: 'pap', label: 'Papiamento', native: 'Papiamentu', flag: '🇦🇼', rtl: false },
+    { code: 'srn', label: 'Sranan Tongo', native: 'Sranantongo', flag: '🇸🇷', rtl: false },
+    { code: 'qu', label: 'Quechua', native: 'Runa Simi', flag: '🇵🇪', rtl: false },
+    { code: 'gn', label: 'Guarani', native: 'Avañe\'ẽ', flag: '🇵🇾', rtl: false },
+    { code: 'ay', label: 'Aymara', native: 'Aymar aru', flag: '🇧🇴', rtl: false },
+    { code: 'nah', label: 'Nahuatl', native: 'Nāhuatl', flag: '🇲🇽', rtl: false },
+    { code: 'chr', label: 'Cherokee', native: 'ᏣᎳᎩ', flag: '🇺🇸', rtl: false },
+    { code: 'nv', label: 'Navajo', native: 'Diné bizaad', flag: '🇺🇸', rtl: false },
+    { code: 'iu', label: 'Inuktitut', native: 'ᐃᓄᒃᑎᑐᑦ', flag: '🇨🇦', rtl: false },
+    { code: 'mi', label: 'Maori', native: 'Te reo Māori', flag: '🇳🇿', rtl: false },
+    { code: 'sm', label: 'Samoan', native: 'Gagana Sāmoa', flag: '🇼🇸', rtl: false },
+    { code: 'to', label: 'Tongan', native: 'Lea faka-Tonga', flag: '🇹🇴', rtl: false },
+    { code: 'fj', label: 'Fijian', native: 'Na Vosa Vakaviti', flag: '🇫🇯', rtl: false },
+    { code: 'haw', label: 'Hawaiian', native: 'ʻŌlelo Hawaiʻi', flag: '🇺🇸', rtl: false },
+    { code: 'ty', label: 'Tahitian', native: 'Reo Tahiti', flag: '🇵🇫', rtl: false },
+    { code: 'ch', label: 'Chamorro', native: 'Chamoru', flag: '🇬🇺', rtl: false },
+    { code: 'mh', label: 'Marshallese', native: 'Kajin M̧ajeļ', flag: '🇲🇭', rtl: false },
+    { code: 'tpi', label: 'Tok Pisin', native: 'Tok Pisin', flag: '🇵🇬', rtl: false }
+];
+const LANGUAGE_ALIASES = [
+    ['zh', 'zh-Hans'],
+    ['zh-cn', 'zh-Hans'],
+    ['zh-sg', 'zh-Hans'],
+    ['cmn', 'zh-Hans'],
+    ['zh-tw', 'zh-Hant'],
+    ['zh-mo', 'zh-HK'],
+    ['iw', 'he'],
+    ['in', 'id'],
+    ['ji', 'yi'],
+    ['mo', 'ro'],
+    ['sh', 'sr-Latn'],
+    ['sr-latn-rs', 'sr-Latn'],
+    ['prs', 'fa-AF'],
+    ['fa-af', 'fa-AF'],
+    ['kmr', 'ku'],
+    ['pt-pt', 'pt'],
+    ['es-mx', 'es-419'],
+    ['es-ar', 'es-419'],
+    ['es-co', 'es-419'],
+    ['es-cl', 'es-419']
+];
+const LANGUAGE_SUBTAG_PATTERN = /[-_]/;
+
+const PAGINATION = {
+    MAX_LIMIT: 100,
+    DEFAULT_LIMIT: 25
+};
+const CURSOR_STYLES = {
+    CURSOR: { PARAM: 'cursor', FIELD: 'nextCursor' },
+    PAGE_TOKEN: { PARAM: 'pageToken', FIELD: 'nextPageToken' }
+};
+const QUERY_KEYS = {
+    LIMIT: 'limit',
+    STATUS: 'status',
+    FROM: 'from',
+    TO: 'to',
+    TIMEZONE: 'timezone',
+    ENABLED: 'enabled',
+    RULE_ID: 'ruleId',
+    THREAD_ID: 'threadId',
+    FOLDER: 'folder',
+    QUERY: 'query',
+    LABEL_IDS: 'labelIds',
+    OPENED: 'opened',
+    CLICKED: 'clicked',
+    DAYS: 'days',
+    MINUTES: 'minutes',
+    GRAIN: 'grain',
+    OFFSET_MINUTES: 'offsetMinutes',
+    INCLUDE_MACHINE: 'includeMachine',
+    REASSIGN_TO: 'reassignTo'
+};
+const LIST_SEPARATOR = ',';
+
+const PATHS = {
+    PING: '/ping',
+    KEYS_SELF: '/keys/self',
+    ADDRESSES: '/addresses',
+    LANGUAGES: '/languages',
+    EMAILS: '/emails',
+    EMAILS_BATCH: '/emails/batch',
+    EMAILS_TRANSLATE: '/emails/translate',
+    THREADS: '/threads',
+    DRAFTS: '/drafts',
+    LABELS: '/labels',
+    CONTACTS: '/contacts',
+    DOMAINS: '/domains',
+    WEBHOOKS: '/webhooks',
+    TEMPLATES: '/templates',
+    RULES: '/rules',
+    RULES_RUNS: '/rules/runs',
+    RULES_REORDER: '/rules/reorder',
+    TRACKING: '/tracking',
+    TRACKING_STATS: '/tracking/stats',
+    CALENDAR_EVENTS: '/calendar/events',
+    SETTINGS: '/settings',
+    ROLES: '/roles',
+    ROLES_PERMISSIONS: '/roles/permissions',
+    MEMBERS: '/members',
+    TEMP_MAIL_DOMAINS: '/temp-mail/domains',
+    TEMP_MAIL_INBOXES: '/temp-mail/inboxes'
+};
+const SEGMENTS = {
+    ADDRESSES: 'addresses',
+    ATTACHMENTS: 'attachments',
+    CANCEL: 'cancel',
+    CLICKS: 'clicks',
+    DELIVERIES: 'deliveries',
+    EVENTS: 'events',
+    EXTEND: 'extend',
+    ICS: 'ics',
+    MESSAGES: 'messages',
+    OPENS: 'opens',
+    PREVIEW: 'preview',
+    ROTATE_SECRET: 'rotate-secret',
+    SEND: 'send',
+    SNOOZE: 'snooze',
+    TEST: 'test',
+    TRACKING: 'tracking',
+    TRASH: 'trash',
+    UNSNOOZE: 'unsnooze',
+    VERSIONS: 'versions'
+};
+
+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://www.npmjs.com/package/@openemail/sdk?activeTab=versions',
+    ICON: 'ℹ'
+};
+
+const RULE_FIELDS = [
+    'from',
+    'from_domain',
+    'envelope_from',
+    'to',
+    'cc',
+    'bcc',
+    'recipient',
+    'reply_to',
+    'delivered_to',
+    'subject',
+    'body',
+    'header',
+    'list_id',
+    'attachment_name',
+    'attachment_type',
+    'has_attachment',
+    'attachment_size',
+    'message_size',
+    'spam',
+    'hour',
+    'weekday'
+];
+const RULE_OPERATORS = ['matches', 'contains', 'equals', 'starts_with', 'ends_with', 'gt', 'lt'];
+const RULE_ACTIONS = [
+    'label',
+    'remove_label',
+    'archive',
+    'mark_read',
+    'star',
+    'spam',
+    'trash',
+    'forward',
+    'reply',
+    'block_sender',
+    'reject'
+];
+
+const API_SCOPES = [
+    'emails:send',
+    'emails:read',
+    'drafts:read',
+    'drafts:write',
+    'threads:read',
+    'threads:write',
+    'labels:read',
+    'labels:write',
+    'contacts:read',
+    'calendar:read',
+    'calendar:write',
+    'templates:read',
+    'templates:write',
+    'domains:read',
+    'domains:write',
+    'webhooks:read',
+    'webhooks:write',
+    'rules:read',
+    'rules:write',
+    'connections:read',
+    'members:read',
+    'members:write',
+    'roles:read',
+    'roles:write',
+    'settings:read',
+    'settings:write'
+];
+
+const WEBHOOK_EVENTS = [
+    'email.received',
+    'email.sent',
+    'email.failed',
+    'email.cancelled',
+    'email.scheduled',
+    'email.queued',
+    'email.bounced',
+    'email.complained',
+    'email.opened',
+    'email.clicked'
+];
+const WEBHOOK_HEADERS = {
+    SIGNATURE: 'X-OpenEmail-Signature',
+    EVENT: 'X-OpenEmail-Event',
+    DELIVERY: 'X-OpenEmail-Delivery'
+};
+const WEBHOOK_SIGNATURE = {
+    VERSION: 'v1',
+    TIMESTAMP: 't',
+    PAIR_SEPARATOR: ',',
+    VALUE_SEPARATOR: '=',
+    TOLERANCE_SECONDS: 300
+};
+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>.',
+    OUT_OF_TOLERANCE: 'Webhook timestamp is {{drift}}s out of tolerance ({{tolerance}}s).',
+    MISMATCH: 'Webhook signature does not match the payload.',
+    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 PAGE_LIMITS = PAGINATION;
+const WEBHOOK_SIGNATURE_HEADERS = WEBHOOK_HEADERS;
+
+const CLIENT_REGISTRY_KEY = Symbol.for('openemail.sdk.client.v1');
+const CLIENT_REGISTRY = globalThis;
+
+const LOCAL_HOSTS = ['localhost', '127.0.0.1', '0.0.0.0', '::1'];
+const ENDPOINT_SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+const RETRYABLE_STATUSES = new Set(RETRY.STATUSES);
+const RETRYABLE_METHODS = new Set(RETRY.METHODS);
+
+const IsApiKey = (value) => typeof value === 'string' && (value.startsWith(API_KEY_PREFIXES.LIVE) || value.startsWith(API_KEY_PREFIXES.TEST));
+const ModeOf = (apiKey) => apiKey.startsWith(API_KEY_PREFIXES.TEST) ? API_KEY_MODES.TEST : API_KEY_MODES.LIVE;
+const AssertApiKey = (apiKey, where) => {
+    if (!apiKey)
+        throw new Error(CLIENT_MESSAGES.API_KEY_REQUIRED);
+    if (!IsApiKey(apiKey))
+        throw new Error(`${where} ${CLIENT_MESSAGES.API_KEY_SHAPE}`);
+};
+
+const IsBrowser = () => {
+    const scope = globalThis;
+    if (scope.Deno !== undefined)
+        return false;
+    return typeof scope.window !== 'undefined' && typeof scope.document !== 'undefined';
+};
+
+class OpenEmailApiError extends Error {
+    status;
+    type;
+    code;
+    param;
+    docUrl;
+    requestId;
+    retryAfterSeconds;
+    constructor(props) {
+        const { message, status, type, code, param, docUrl, requestId, retryAfterSeconds } = props;
+        super(message);
+        this.name = ERROR_NAMES.API;
+        this.status = status;
+        this.type = type;
+        this.code = code;
+        this.param = param;
+        this.docUrl = docUrl;
+        this.requestId = requestId;
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+    get isAuth() {
+        return this.type === ERROR_TYPE.AUTHENTICATION;
+    }
+    get isPermission() {
+        return this.type === ERROR_TYPE.PERMISSION;
+    }
+    get isScopeMissing() {
+        return this.code === ERROR_CODES.INSUFFICIENT_SCOPE;
+    }
+    get isInvalidRequest() {
+        return this.type === ERROR_TYPE.INVALID_REQUEST;
+    }
+    get isValidation() {
+        return this.type === ERROR_TYPE.VALIDATION;
+    }
+    get isNotFound() {
+        return this.type === ERROR_TYPE.NOT_FOUND;
+    }
+    get isConflict() {
+        return this.type === ERROR_TYPE.CONFLICT;
+    }
+    get isRateLimited() {
+        return this.type === ERROR_TYPE.RATE_LIMIT;
+    }
+    get isServerError() {
+        return this.status !== null && this.status >= 500;
+    }
+    get isRetryable() {
+        return this.status !== null && RETRY.STATUSES.includes(this.status);
+    }
+}
+class OpenEmailNetworkError extends Error {
+    cause;
+    isTimeout;
+    constructor(message, cause, isTimeout = false) {
+        super(message);
+        this.name = ERROR_NAMES.NETWORK;
+        this.cause = cause;
+        this.isTimeout = isTimeout;
+    }
+}
+
+let checked = false;
+const Parts = (value) => value
+    .trim()
+    .replace(/^v/, '')
+    .split('.')
+    .map(part => Number.parseInt(part, 10));
+const IsNewer = (candidate, current) => {
+    const left = Parts(candidate);
+    const right = Parts(current);
+    if (left.length !== 3 || right.length !== 3)
+        return false;
+    if (left.some(Number.isNaN) || right.some(Number.isNaN))
+        return false;
+    for (let index = 0; index < 3; index++) {
+        if (left[index] > right[index])
+            return true;
+        if (left[index] < right[index])
+            return false;
+    }
+    return false;
+};
+const Disabled = () => {
+    if (typeof process === 'undefined')
+        return true;
+    const value = process.env?.[UPDATE_NOTICE.ENV_DISABLE];
+    if (value && value.length > 0)
+        return true;
+    return process.stdout?.isTTY !== true;
+};
+const LatestVersion = async (fetchImpl = globalThis.fetch) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), UPDATE_NOTICE.TIMEOUT_MS);
+    timer.unref?.();
+    try {
+        const response = await fetchImpl(NPM_REGISTRY_URL, { signal: controller.signal });
+        if (!response.ok)
+            return null;
+        const payload = await response.json();
+        const latest = payload?.['dist-tags']?.latest;
+        return typeof latest === 'string' ? latest : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+const UpdateNotice = (fetchImpl) => {
+    if (checked || Disabled())
+        return;
+    checked = true;
+    void LatestVersion(fetchImpl)
+        .then(latest => {
+        if (!latest || !IsNewer(latest, VERSION))
+            return;
+        console.warn(`${UPDATE_NOTICE.ICON} ${UPDATE_NOTICE.PACKAGE} ${latest} is available, you are on ${VERSION}. ${UPDATE_NOTICE.CHANGELOG_URL}.`);
+    })
+        .catch(() => undefined);
+};
+
+const Backoff = (attempt) => {
+    const ceiling = Math.min(RETRY.MAX_BACKOFF_MS, RETRY.BASE_BACKOFF_MS * 2 ** attempt);
+    return Math.round(ceiling * (0.5 + Math.random() * 0.5));
+};
+
+const BuildUrl = (baseUrl, path, query) => {
+    const url = `${baseUrl.replace(/\/+$/, '')}${path}`;
+    if (!query)
+        return url;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        params.append(key, String(value));
+    }
+    const serialized = params.toString();
+    return serialized ? `${url}?${serialized}` : url;
+};
+
+const Deadline = (timeoutMs, signal) => {
+    const controller = new AbortController();
+    let expired = false;
+    const timer = timeoutMs > 0
+        ? setTimeout(() => {
+            const reason = new Error(`Request timed out after ${timeoutMs}ms.`);
+            reason.name = ERROR_NAMES.TIMEOUT;
+            expired = true;
+            controller.abort(reason);
+        }, timeoutMs)
+        : undefined;
+    const OnAbort = () => controller.abort(signal?.reason);
+    if (signal?.aborted)
+        controller.abort(signal.reason);
+    else
+        signal?.addEventListener('abort', OnAbort, { once: true });
+    return {
+        signal: controller.signal,
+        timedOut: () => expired,
+        release: () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            signal?.removeEventListener('abort', OnAbort);
+        }
+    };
+};
+
+const IdempotencyKey = () => {
+    const source = globalThis.crypto;
+    if (typeof source?.randomUUID === 'function')
+        return `${IDEMPOTENCY_KEY_PREFIX}${source.randomUUID()}`;
+    if (typeof source?.getRandomValues === 'function') {
+        const bytes = source.getRandomValues(new Uint8Array(16));
+        return `${IDEMPOTENCY_KEY_PREFIX}${Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('')}`;
+    }
+    return `${IDEMPOTENCY_KEY_PREFIX}${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 14)}`;
+};
+
+const RetryAfter = (value) => {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds;
+    const at = Date.parse(value);
+    if (!Number.isNaN(at))
+        return Math.max(0, Math.ceil((at - Date.now()) / 1000));
+    return undefined;
+};
+
+const Sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(new OpenEmailNetworkError('Request aborted by the caller.', signal.reason));
+        return;
+    }
+    const onAbort = () => {
+        clearTimeout(timer);
+        reject(new OpenEmailNetworkError('Request aborted by the caller.', signal?.reason));
+    };
+    const timer = setTimeout(() => {
+        signal?.removeEventListener('abort', onAbort);
+        resolve();
+    }, ms);
+    signal?.addEventListener('abort', onAbort, { once: true });
+});
+
+const IsErrorType = (value) => typeof value === 'string' && ERROR_TYPES.includes(value);
+const TypeForStatus = (status) => {
+    if (status >= 500)
+        return ERROR_TYPE.API;
+    const mapped = ERROR_TYPE_BY_STATUS[status];
+    return IsErrorType(mapped) ? mapped : ERROR_TYPE.INVALID_REQUEST;
+};
+const ReadPayload = (body) => {
+    if (typeof body !== 'object' || body === null || !('error' in body))
+        return {};
+    const error = body.error;
+    return typeof error === 'object' && error !== null ? error : {};
+};
+const Text = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
+const ToErrorProps = (response, body, rawText, retryAfterSeconds) => {
+    const payload = ReadPayload(body);
+    return {
+        message: Text(payload.message)
+            ?? (rawText ? rawText.slice(0, 300) : `The API responded ${response.status} with a body this client did not recognise.`),
+        status: response.status,
+        type: IsErrorType(payload.type) ? payload.type : TypeForStatus(response.status),
+        code: Text(payload.code) ?? ERROR_CODES.UNRECOGNISED_RESPONSE,
+        param: Text(payload.param),
+        docUrl: Text(payload.docUrl),
+        requestId: Text(payload.requestId) ?? response.headers.get(HEADER_KEYS.REQUEST_ID) ?? undefined,
+        retryAfterSeconds
+    };
+};
+
+const Describe = (error) => error instanceof Error ? error.message : String(error);
+const ParseJson = (text) => {
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+const ValidBaseUrl = (value) => {
+    const trimmed = value.trim().replace(/\/+$/, '');
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol === 'https:' || parsed.protocol === 'http:')
+            return trimmed;
+    }
+    catch { }
+    throw new Error(`${JSON.stringify(value)} ${CLIENT_MESSAGES.BASE_URL_SHAPE}`);
+};
+class Transport {
+    #apiKey;
+    #inboxToken;
+    baseUrl;
+    fetchImpl;
+    maxRetries;
+    timeoutMs;
+    userAgent;
+    headers;
+    constructor(options) {
+        if (options.apiKey !== undefined)
+            AssertApiKey(options.apiKey, '{ apiKey }');
+        const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+        if (!fetchImpl)
+            throw new Error(CLIENT_MESSAGES.NO_FETCH);
+        this.#apiKey = options.apiKey;
+        this.#inboxToken = options.inboxToken;
+        this.baseUrl = ValidBaseUrl(options.baseUrl ?? DEFAULTS.BASE_URL);
+        this.fetchImpl = fetchImpl;
+        this.maxRetries = Math.max(0, options.maxRetries ?? DEFAULTS.MAX_RETRIES);
+        this.timeoutMs = options.timeoutMs ?? DEFAULTS.TIMEOUT_MS;
+        this.userAgent = options.userAgent ?? DEFAULTS.USER_AGENT;
+        this.headers = { ...options.headers };
+        if (options.disableUpdateNotice !== true)
+            UpdateNotice(this.fetchImpl);
+    }
+    async request(path, options = {}) {
+        const method = (options.method ?? HTTP_METHODS.GET).toUpperCase();
+        const url = BuildUrl(this.baseUrl, path, options.query);
+        const headers = this.headersFor(options);
+        const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+        const repeatable = options.repeatable ?? RETRYABLE_METHODS.has(method);
+        let attempt = 0;
+        for (;;) {
+            const outcome = await this.attempt(url, method, headers, body, options.signal);
+            if (outcome instanceof OpenEmailNetworkError) {
+                if (options.signal?.aborted || !repeatable || attempt >= this.maxRetries)
+                    throw outcome;
+                await Sleep(Backoff(attempt), options.signal);
+                attempt += 1;
+                continue;
+            }
+            const { response, text } = outcome;
+            if (response.ok)
+                return this.parse(response, text, options.accept);
+            const retryAfter = RetryAfter(response.headers.get(HEADER_KEYS.RETRY_AFTER));
+            const honoured = retryAfter === undefined
+                ? response.status !== RETRY.RATE_LIMIT_STATUS
+                : retryAfter * 1000 <= RETRY.MAX_HONOURED_RETRY_AFTER_MS;
+            if (repeatable && honoured && attempt < this.maxRetries && RETRYABLE_STATUSES.has(response.status)) {
+                await Sleep(retryAfter === undefined ? Backoff(attempt) : retryAfter * 1000, options.signal);
+                attempt += 1;
+                continue;
+            }
+            throw new OpenEmailApiError(ToErrorProps(response, ParseJson(text), text, retryAfter));
+        }
+    }
+    headersFor(options) {
+        const headers = {
+            ...this.headers,
+            [HEADER_KEYS.ACCEPT]: options.accept ?? CONTENT_TYPES.JSON
+        };
+        if (!IsBrowser())
+            headers[HEADER_KEYS.USER_AGENT] = this.userAgent;
+        if (options.body !== undefined)
+            headers[HEADER_KEYS.CONTENT_TYPE] = CONTENT_TYPES.JSON;
+        if (options.anonymous !== true) {
+            if (options.apiKey !== undefined)
+                AssertApiKey(options.apiKey, '{ apiKey } on this call');
+            const credential = options.inboxToken ?? options.apiKey ?? this.#inboxToken ?? this.#apiKey;
+            if (credential)
+                headers[HEADER_KEYS.AUTHORIZATION] = `Bearer ${credential}`;
+        }
+        if (options.idempotent === true)
+            headers[HEADER_KEYS.IDEMPOTENCY_KEY] = options.idempotencyKey ?? IdempotencyKey();
+        return headers;
+    }
+    async attempt(url, method, headers, body, signal) {
+        const deadline = Deadline(this.timeoutMs, signal);
+        const Failure = (error, fallback) => {
+            if (signal?.aborted)
+                return new OpenEmailNetworkError('Request aborted by the caller.', error);
+            if (deadline.timedOut())
+                return new OpenEmailNetworkError(`Request timed out after ${this.timeoutMs}ms.`, error, true);
+            return new OpenEmailNetworkError(`${fallback}: ${Describe(error)}`, error);
+        };
+        try {
+            let response;
+            try {
+                response = await this.fetchImpl(url, { method, headers, body, signal: deadline.signal });
+            }
+            catch (error) {
+                return Failure(error, `Could not reach ${this.baseUrl}`);
+            }
+            try {
+                return { response, text: await response.text() };
+            }
+            catch (error) {
+                if (response.ok || signal?.aborted || deadline.timedOut())
+                    return Failure(error, 'The response body could not be read');
+                return { response, text: '' };
+            }
+        }
+        finally {
+            deadline.release();
+        }
+    }
+    parse(response, text, accept) {
+        if (accept && accept !== CONTENT_TYPES.JSON)
+            return text;
+        if (!text)
+            return undefined;
+        const parsed = ParseJson(text);
+        if (parsed !== undefined)
+            return parsed;
+        throw new OpenEmailApiError({
+            message: `The API answered ${response.status} with a body that is not JSON.`,
+            status: response.status,
+            type: ERROR_TYPE.API,
+            code: ERROR_CODES.UNRECOGNISED_RESPONSE,
+            requestId: response.headers.get(HEADER_KEYS.REQUEST_ID) ?? undefined
+        });
+    }
+}
+
+const Addresses = (transport) => ({
+    list: async (options = {}) => {
+        const envelope = await transport.request(PATHS.ADDRESSES, { signal: options.signal, apiKey: options.apiKey });
+        return {
+            unrestricted: envelope.unrestricted,
+            addresses: envelope.data ?? [],
+            domains: envelope.domains ?? []
+        };
+    }
+});
+
+const FetchPage = async (transport, path, style, options = {}, query = {}) => {
+    const payload = await transport.request(path, {
+        query: { ...query, [QUERY_KEYS.LIMIT]: options.limit, [style.PARAM]: options.cursor },
+        signal: options.signal,
+        apiKey: options.apiKey
+    });
+    const next = payload?.[style.FIELD];
+    const nextCursor = typeof next === 'string' && next.length > 0 ? next : null;
+    return {
+        items: (payload?.data ?? []),
+        hasMore: typeof payload?.hasMore === 'boolean' ? payload.hasMore : nextCursor !== null,
+        nextCursor
+    };
+};
+const IteratePages = async function* (transport, path, style, options = {}, query = {}) {
+    let cursor = options.cursor;
+    for (;;) {
+        const page = await FetchPage(transport, path, style, { ...options, cursor }, query);
+        for (const item of page.items)
+            yield item;
+        if (!page.hasMore || !page.nextCursor || page.nextCursor === cursor)
+            return;
+        cursor = page.nextCursor;
+    }
+};
+const CollectAll = async (transport, path, style, options = {}, query = {}) => {
+    const all = [];
+    for await (const item of IteratePages(transport, path, style, options, query))
+        all.push(item);
+    return all;
+};
+const FetchList = async (transport, path, options = {}, query) => {
+    const payload = await transport.request(path, {
+        query,
+        signal: options.signal,
+        apiKey: options.apiKey
+    });
+    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 DomainPath = (id) => `${PATHS.DOMAINS}/${Segment(id)}`;
+const WebhookPath = (id) => `${PATHS.WEBHOOKS}/${Segment(id)}`;
+const WebhookChildPath = (id, segment) => `${WebhookPath(id)}/${segment}`;
+const TemplatePath = (idOrSlug) => `${PATHS.TEMPLATES}/${Segment(idOrSlug)}`;
+const TemplateChildPath = (idOrSlug, segment) => `${TemplatePath(idOrSlug)}/${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 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 ToBase64 = (bytes) => {
+    const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    let binary = '';
+    for (let offset = 0; offset < view.length; offset += BASE64_CHUNK_SIZE) {
+        binary += String.fromCharCode(...view.subarray(offset, offset + BASE64_CHUNK_SIZE));
+    }
+    return btoa(binary);
+};
+
+const Many = (value) => {
+    if (value === undefined)
+        return undefined;
+    return Array.isArray(value) ? value : [value];
+};
+const Instant = (value) => value instanceof Date ? value.toISOString() : value;
+const Attachment = (attachment) => ({
+    filename: attachment.filename,
+    content: typeof attachment.content === 'string' ? attachment.content : ToBase64(attachment.content),
+    ...(attachment.contentType === undefined ? {} : { contentType: attachment.contentType })
+});
+const EmailToWire = (body) => ({
+    ...body,
+    to: Many(body.to),
+    cc: Many(body.cc),
+    bcc: Many(body.bcc),
+    attachments: body.attachments?.map(Attachment),
+    scheduledAt: Instant(body.scheduledAt)
+});
+const TemplateSendToWire = (body) => ({
+    ...body,
+    to: Many(body.to),
+    cc: Many(body.cc),
+    bcc: Many(body.bcc),
+    scheduledAt: Instant(body.scheduledAt)
+});
+const ToInstant = Instant;
+
+const Calendar = (transport) => ({
+    listEvents: (options) => FetchList(transport, PATHS.CALENDAR_EVENTS, options, {
+        [QUERY_KEYS.FROM]: ToInstant(options.from),
+        [QUERY_KEYS.TO]: ToInstant(options.to),
+        [QUERY_KEYS.TIMEZONE]: options.timezone
+    }),
+    getEvent: (id, options = {}) => transport.request(CalendarEventPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    getEventIcs: (id, options = {}) => transport.request(CalendarEventIcsPath(id), {
+        accept: CONTENT_TYPES.CALENDAR,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Contacts = (transport) => ({
+    list: (options = {}) => FetchList(transport, PATHS.CONTACTS, options, { [QUERY_KEYS.LIMIT]: options.limit }),
+    get: (email, options = {}) => transport.request(ContactPath(email), { signal: options.signal, apiKey: options.apiKey })
+});
+
+const Domains = (transport) => ({
+    list: (options = {}) => FetchList(transport, PATHS.DOMAINS, options),
+    get: (id, options = {}) => transport.request(DomainPath(id), { signal: options.signal, apiKey: options.apiKey })
+});
+
+const ListQuery$4 = (options) => ({ [QUERY_KEYS.QUERY]: options.query });
+const Drafts = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$4(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$4(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.DRAFTS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery$4(options)),
+    get: (id, options = {}) => transport.request(DraftPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.DRAFTS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (id, body, options = {}) => transport.request(DraftPath(id), {
+        method: HTTP_METHODS.PATCH,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(DraftPath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const ListQuery$3 = (options) => ({
+    [QUERY_KEYS.STATUS]: Array.isArray(options.status) ? options.status.join(LIST_SEPARATOR) : options.status,
+    [QUERY_KEYS.FROM]: options.from
+});
+const Emails = (transport) => ({
+    send: (body, options = {}) => transport.request(PATHS.EMAILS, {
+        method: HTTP_METHODS.POST,
+        body: EmailToWire(body),
+        idempotent: true,
+        idempotencyKey: options.idempotencyKey,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    sendBatch: async (emails, options = {}) => {
+        const result = await transport.request(PATHS.EMAILS_BATCH, {
+            method: HTTP_METHODS.POST,
+            body: { emails: emails.map(EmailToWire) },
+            idempotent: true,
+            idempotencyKey: options.idempotencyKey,
+            repeatable: true,
+            signal: options.signal,
+            apiKey: options.apiKey
+        });
+        return { items: result.data, sent: result.sent, failed: result.failed };
+    },
+    translate: (body, options = {}) => transport.request(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$3(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.EMAILS, CURSOR_STYLES.CURSOR, options, ListQuery$3(options)),
+    get: (id, options = {}) => transport.request(EmailPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    listEvents: (id, options = {}) => FetchList(transport, EmailChildPath(id, SEGMENTS.EVENTS), options),
+    getTracking: (id, options = {}) => transport.request(EmailChildPath(id, SEGMENTS.TRACKING), { signal: options.signal, apiKey: options.apiKey }),
+    cancel: (id, options = {}) => transport.request(EmailChildPath(id, SEGMENTS.CANCEL), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    reschedule: (id, scheduledAt, options = {}) => transport.request(EmailPath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: { scheduledAt: ToInstant(scheduledAt) },
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Labels = (transport) => ({
+    list: (options = {}) => FetchList(transport, PATHS.LABELS, options),
+    get: (id, options = {}) => transport.request(LabelPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.LABELS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (id, body, options = {}) => transport.request(LabelPath(id), {
+        method: HTTP_METHODS.PATCH,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(LabelPath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Languages = (transport) => ({
+    list: (options = {}) => FetchList(transport, 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 })
+});
+
+const Members = (transport) => ({
+    list: (options = {}) => FetchList(transport, PATHS.MEMBERS, options),
+    get: (userId, options = {}) => transport.request(MemberPath(userId), { signal: options.signal, apiKey: options.apiKey }),
+    add: (body, options = {}) => transport.request(PATHS.MEMBERS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (userId, patch, options = {}) => transport.request(MemberPath(userId), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    remove: (userId, options = {}) => transport.request(MemberPath(userId), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    grantAddress: (userId, body, options = {}) => transport.request(MemberAddressesPath(userId), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    revokeAddress: (userId, addressId, options = {}) => transport.request(MemberAddressPath(userId, addressId), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const Roles = (transport) => ({
+    list: (options = {}) => FetchList(transport, PATHS.ROLES, options),
+    get: (id, options = {}) => transport.request(RolePath(id), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.ROLES, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (id, patch, options = {}) => transport.request(RolePath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(RolePath(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)
+});
+
+const ListQuery$2 = (options) => ({
+    [QUERY_KEYS.ENABLED]: options.enabled === undefined ? undefined : String(options.enabled)
+});
+const RunsQuery = (options) => ({
+    [QUERY_KEYS.RULE_ID]: options.ruleId,
+    [QUERY_KEYS.THREAD_ID]: options.threadId
+});
+const Rules = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.RULES, CURSOR_STYLES.CURSOR, options, ListQuery$2(options)),
+    get: (id, options = {}) => transport.request(RulePath(id), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.RULES, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (id, patch, options = {}) => transport.request(RulePath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(RulePath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    reorder: async (ruleIds, options = {}) => {
+        const envelope = await transport.request(PATHS.RULES_REORDER, {
+            method: HTTP_METHODS.POST,
+            body: { ruleIds },
+            repeatable: true,
+            signal: options.signal,
+            apiKey: options.apiKey
+        });
+        return envelope?.data ?? [];
+    },
+    test: (id, body = {}, options = {}) => transport.request(RuleChildPath(id, SEGMENTS.TEST), {
+        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))
+});
+
+const Settings = (transport) => ({
+    get: (options = {}) => transport.request(PATHS.SETTINGS, { signal: options.signal, apiKey: options.apiKey }),
+    update: (patch, options = {}) => transport.request(PATHS.SETTINGS, {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const TempMail = (transport) => ({
+    listDomains: async (options = {}) => (await transport.request(PATHS.TEMP_MAIL_DOMAINS, {
+        anonymous: true,
+        signal: options.signal
+    }))?.data ?? [],
+    create: (body = {}, options = {}) => transport.request(PATHS.TEMP_MAIL_INBOXES, {
+        method: HTTP_METHODS.POST,
+        body,
+        anonymous: true,
+        signal: options.signal
+    }),
+    get: (inboxId, options = {}) => transport.request(TempInboxPath(inboxId), {
+        inboxToken: options.inboxToken,
+        signal: options.signal
+    }),
+    extend: (inboxId, options = {}) => transport.request(TempInboxExtendPath(inboxId), {
+        method: HTTP_METHODS.POST,
+        inboxToken: options.inboxToken,
+        signal: options.signal
+    }),
+    delete: (inboxId, options = {}) => transport.request(TempInboxPath(inboxId), {
+        method: HTTP_METHODS.DELETE,
+        inboxToken: options.inboxToken,
+        signal: options.signal
+    }),
+    listMessages: async (inboxId, options = {}) => {
+        const envelope = await transport.request(TempMessagesPath(inboxId), {
+            query: { [QUERY_KEYS.LIMIT]: options.limit },
+            inboxToken: options.inboxToken,
+            signal: options.signal
+        });
+        return { items: envelope?.data ?? [], expiresAt: envelope?.expiresAt };
+    },
+    getMessage: (inboxId, messageId, options = {}) => transport.request(TempMessagePath(inboxId, messageId), {
+        inboxToken: options.inboxToken,
+        signal: options.signal
+    }),
+    deleteMessage: (inboxId, messageId, options = {}) => transport.request(TempMessagePath(inboxId, messageId), {
+        method: HTTP_METHODS.DELETE,
+        inboxToken: options.inboxToken,
+        signal: options.signal
+    }),
+    listAttachments: async (inboxId, messageId, options = {}) => (await transport.request(TempMessageAttachmentsPath(inboxId, messageId), {
+        inboxToken: options.inboxToken,
+        signal: options.signal
+    }))?.data ?? []
+});
+
+const ListQuery$1 = (options) => ({ [QUERY_KEYS.STATUS]: options.status });
+const Templates = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.TEMPLATES, CURSOR_STYLES.CURSOR, options, ListQuery$1(options)),
+    get: (idOrSlug, options = {}) => transport.request(TemplatePath(idOrSlug), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.TEMPLATES, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (idOrSlug, patch, options = {}) => transport.request(TemplatePath(idOrSlug), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (idOrSlug, options = {}) => transport.request(TemplatePath(idOrSlug), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listVersions: (idOrSlug, options = {}) => FetchList(transport, TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), options),
+    publish: (idOrSlug, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.VERSIONS), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    preview: (idOrSlug, body = {}, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.PREVIEW), {
+        method: HTTP_METHODS.POST,
+        body,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    send: (idOrSlug, body, options = {}) => transport.request(TemplateChildPath(idOrSlug, SEGMENTS.SEND), {
+        method: HTTP_METHODS.POST,
+        body: TemplateSendToWire(body),
+        idempotent: true,
+        idempotencyKey: options.idempotencyKey,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    })
+});
+
+const ListQuery = (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
+});
+const Threads = (transport) => ({
+    list: (options = {}) => FetchPage(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery(options)),
+    listAll: (options = {}) => CollectAll(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery(options)),
+    iterate: (options = {}) => IteratePages(transport, PATHS.THREADS, CURSOR_STYLES.PAGE_TOKEN, options, ListQuery(options)),
+    get: (id, options = {}) => transport.request(ThreadPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    update: (id, patch, options = {}) => transport.request(ThreadPath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    trash: (id, options = {}) => transport.request(ThreadChildPath(id, SEGMENTS.TRASH), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    snooze: (id, wakeAt, options = {}) => transport.request(ThreadChildPath(id, SEGMENTS.SNOOZE), {
+        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), {
+        method: HTTP_METHODS.POST,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listAttachments: (id, messageId, options = {}) => FetchList(transport, ThreadMessageAttachmentsPath(id, messageId), options)
+});
+
+const Flag = (value) => value === undefined ? undefined : String(value);
+const HitQuery = (options) => ({
+    [QUERY_KEYS.INCLUDE_MACHINE]: Flag(options.includeMachine),
+    [QUERY_KEYS.LIMIT]: options.limit
+});
+const Tracking = (transport) => ({
+    list: (options = {}) => FetchList(transport, PATHS.TRACKING, options, {
+        [QUERY_KEYS.OPENED]: Flag(options.opened),
+        [QUERY_KEYS.CLICKED]: Flag(options.clicked),
+        [QUERY_KEYS.DAYS]: options.days,
+        [QUERY_KEYS.MINUTES]: options.minutes,
+        [QUERY_KEYS.GRAIN]: options.grain,
+        [QUERY_KEYS.LIMIT]: options.limit
+    }),
+    getStats: (options = {}) => transport.request(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
+        },
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    get: (id, options = {}) => transport.request(TrackingPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    listOpens: (id, options = {}) => FetchList(transport, TrackingChildPath(id, SEGMENTS.OPENS), options, HitQuery(options)),
+    listClicks: (id, options = {}) => FetchList(transport, TrackingChildPath(id, SEGMENTS.CLICKS), options, HitQuery(options))
+});
+
+const Webhooks = (transport) => ({
+    list: (options = {}) => FetchList(transport, PATHS.WEBHOOKS, options),
+    get: (id, options = {}) => transport.request(WebhookPath(id), { signal: options.signal, apiKey: options.apiKey }),
+    create: (body, options = {}) => transport.request(PATHS.WEBHOOKS, {
+        method: HTTP_METHODS.POST,
+        body,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    update: (id, patch, options = {}) => transport.request(WebhookPath(id), {
+        method: HTTP_METHODS.PATCH,
+        body: patch,
+        repeatable: true,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    delete: (id, options = {}) => transport.request(WebhookPath(id), {
+        method: HTTP_METHODS.DELETE,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    rotateSecret: (id, options = {}) => transport.request(WebhookChildPath(id, SEGMENTS.ROTATE_SECRET), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    test: (id, options = {}) => transport.request(WebhookChildPath(id, SEGMENTS.TEST), {
+        method: HTTP_METHODS.POST,
+        signal: options.signal,
+        apiKey: options.apiKey
+    }),
+    listDeliveries: (id, options = {}) => FetchList(transport, WebhookChildPath(id, SEGMENTS.DELIVERIES), options)
+});
+
+class OpenEmail {
+    transport;
+    mode;
+    me;
+    addresses;
+    languages;
+    emails;
+    templates;
+    tracking;
+    threads;
+    drafts;
+    labels;
+    contacts;
+    domains;
+    rules;
+    webhooks;
+    calendar;
+    settings;
+    roles;
+    members;
+    tempMail;
+    constructor(configuration) {
+        const options = typeof configuration === 'string' ? { apiKey: configuration } : configuration;
+        AssertApiKey(options.apiKey, '{ apiKey }');
+        if (IsBrowser() && options.dangerouslyAllowBrowser !== true)
+            throw new Error(BROWSER_REFUSAL);
+        this.transport = new Transport(options);
+        this.mode = ModeOf(options.apiKey);
+        this.me = Me(this.transport);
+        this.addresses = Addresses(this.transport);
+        this.languages = Languages(this.transport);
+        this.emails = Emails(this.transport);
+        this.templates = Templates(this.transport);
+        this.tracking = Tracking(this.transport);
+        this.threads = Threads(this.transport);
+        this.drafts = Drafts(this.transport);
+        this.labels = Labels(this.transport);
+        this.contacts = Contacts(this.transport);
+        this.domains = Domains(this.transport);
+        this.rules = Rules(this.transport);
+        this.webhooks = Webhooks(this.transport);
+        this.calendar = Calendar(this.transport);
+        this.settings = Settings(this.transport);
+        this.roles = Roles(this.transport);
+        this.members = Members(this.transport);
+        this.tempMail = TempMail(this.transport);
+    }
+    get raw() {
+        return this.transport;
+    }
+}
+
+const FromEnvironment = (name) => {
+    const scope = globalThis;
+    try {
+        const value = scope.process?.env?.[name] ?? scope.Deno?.env?.get(name);
+        return value && value.length > 0 ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+
+const NormaliseEndpoint = (value) => {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim().replace(/\/+$/, '');
+    if (trimmed.length === 0)
+        return undefined;
+    if (ENDPOINT_SCHEME_PATTERN.test(trimmed))
+        return trimmed;
+    const host = trimmed.split(':')[0];
+    return `${LOCAL_HOSTS.includes(host) ? 'http' : 'https'}://${trimmed}`;
+};
+
+const CreateClient = (configuration = {}) => {
+    const options = typeof configuration === 'string' ? { apiKey: configuration } : configuration;
+    return new OpenEmail({
+        ...options,
+        apiKey: options.apiKey ?? FromEnvironment(ENV_VARS.API_KEY),
+        baseUrl: NormaliseEndpoint(options.baseUrl ?? FromEnvironment(ENV_VARS.BASE_URL))
+    });
+};
+
+const CreateTempMail = (options = {}) => TempMail(new Transport({
+    ...options,
+    apiKey: undefined,
+    baseUrl: NormaliseEndpoint(options.baseUrl ?? FromEnvironment(ENV_VARS.BASE_URL))
+}));
+
+const IsSealed = (message) => !!message.encryption && SEALED_ENCRYPTION_FORMATS.includes(message.encryption.format);
+
+const ReadHeader = (headers, name) => {
+    if (typeof headers.get === 'function')
+        return headers.get(name) ?? '';
+    const wanted = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== wanted)
+            continue;
+        if (Array.isArray(value))
+            return value[0] ?? '';
+        return value ?? '';
+    }
+    return '';
+};
+const ParseSignature = (header) => {
+    let timestamp = Number.NaN;
+    const signatures = [];
+    for (const pair of header.split(WEBHOOK_SIGNATURE.PAIR_SEPARATOR)) {
+        const at = pair.indexOf(WEBHOOK_SIGNATURE.VALUE_SEPARATOR);
+        if (at < 1)
+            continue;
+        const key = pair.slice(0, at).trim();
+        const value = pair.slice(at + 1).trim();
+        if (key === WEBHOOK_SIGNATURE.TIMESTAMP)
+            timestamp = Number(value);
+        if (key === WEBHOOK_SIGNATURE.VERSION && value)
+            signatures.push(value);
+    }
+    if (!Number.isFinite(timestamp) || signatures.length === 0)
+        return null;
+    return { timestamp, signatures };
+};
+const Equal = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    let mismatch = 0;
+    for (let i = 0; i < a.length; i++)
+        mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    return mismatch === 0;
+};
+const Hex = (bytes) => Array.from(new Uint8Array(bytes), byte => byte.toString(16).padStart(2, '0')).join('');
+const VerifyWebhookSignature = async (props) => {
+    const { payload, headers, secret, toleranceSeconds } = props;
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle)
+        throw new Error(WEBHOOK_MESSAGES.NO_WEBCRYPTO);
+    const header = ReadHeader(headers, WEBHOOK_HEADERS.SIGNATURE);
+    if (!header)
+        throw new Error(WEBHOOK_MESSAGES.MISSING_HEADER);
+    const parsed = ParseSignature(header);
+    if (!parsed)
+        throw new Error(WEBHOOK_MESSAGES.MALFORMED_HEADER);
+    const tolerance = toleranceSeconds ?? WEBHOOK_SIGNATURE.TOLERANCE_SECONDS;
+    const drift = Math.abs(Math.floor(Date.now() / 1000) - parsed.timestamp);
+    if (tolerance > 0 && drift > tolerance) {
+        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 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);
+    return JSON.parse(payload);
+};
+
+const Init = (configuration = {}) => {
+    const client = CreateClient(configuration);
+    CLIENT_REGISTRY[CLIENT_REGISTRY_KEY] = client;
+    return client;
+};
+const GetClient = () => {
+    const existing = CLIENT_REGISTRY[CLIENT_REGISTRY_KEY];
+    if (existing)
+        return existing;
+    return Init();
+};
+const ResetClient = () => {
+    CLIENT_REGISTRY[CLIENT_REGISTRY_KEY] = null;
+};
+const DefaultClient = new Proxy({}, {
+    get: (_target, property) => {
+        if (typeof property === 'symbol' || property === 'then')
+            return undefined;
+        return Reflect.get(GetClient(), property);
+    },
+    has: (_target, property) => Reflect.has(GetClient(), property)
+});
+
+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 ResolveLanguage = (input) => {
+    if (!input)
+        return undefined;
+    const key = Key(input);
+    if (!key)
+        return undefined;
+    const aliased = ALIASES.get(key);
+    if (aliased)
+        return BY_CODE.get(aliased);
+    const direct = BY_CODE.get(key) ?? BY_LABEL.get(key) ?? BY_NATIVE.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);
+};
+const IsRtlLanguage = (code) => ResolveLanguage(code)?.rtl === true;
+
+const init = Init;
+const openemail = DefaultClient;
+const getClient = GetClient;
+const resetClient = ResetClient;
+const createOpenEmail = CreateClient;
+const createClient = CreateClient;
+const createTempMail = CreateTempMail;
+const verifyWebhookSignature = VerifyWebhookSignature;
+const toBase64 = ToBase64;
+const isApiKey = IsApiKey;
+const isSealed = IsSealed;
+const resolveLanguage = ResolveLanguage;
+const languageByCode = LanguageByCode;
+const isRtlLanguage = IsRtlLanguage;
+
+export { API_SCOPES, ERROR_TYPES, LANGUAGES, MESSAGE_ENCRYPTION_FORMATS, OpenEmail, OpenEmailApiError, OpenEmailNetworkError, PAGE_LIMITS, RULE_ACTIONS, RULE_FIELDS, RULE_OPERATORS, VERSION, WEBHOOK_EVENTS, WEBHOOK_SIGNATURE_HEADERS, createClient, createOpenEmail, createTempMail, OpenEmail as default, getClient, init, isApiKey, isRtlLanguage, isSealed, languageByCode, openemail, resetClient, resolveLanguage, toBase64, verifyWebhookSignature };