@bentonow/bento-node-sdk 0.2.1 → 1.0.5

package/dist/index.js

@@ -1,8 +1,1309 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
-'use strict'
+// node_modules/cross-fetch/dist/browser-ponyfill.js
+var require_browser_ponyfill = __commonJS((exports, module) => {
+  var __global__ = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || typeof global !== "undefined" && global;
+  var __globalThis__ = function() {
+    function F() {
+      this.fetch = false;
+      this.DOMException = __global__.DOMException;
+    }
+    F.prototype = __global__;
+    return new F;
+  }();
+  (function(globalThis2) {
+    var irrelevant = function(exports2) {
+      var g = typeof globalThis2 !== "undefined" && globalThis2 || typeof self !== "undefined" && self || typeof global !== "undefined" && global || {};
+      var support = {
+        searchParams: "URLSearchParams" in g,
+        iterable: "Symbol" in g && "iterator" in Symbol,
+        blob: "FileReader" in g && "Blob" in g && function() {
+          try {
+            new Blob;
+            return true;
+          } catch (e) {
+            return false;
+          }
+        }(),
+        formData: "FormData" in g,
+        arrayBuffer: "ArrayBuffer" in g
+      };
+      function isDataView(obj) {
+        return obj && DataView.prototype.isPrototypeOf(obj);
+      }
+      if (support.arrayBuffer) {
+        var viewClasses = [
+          "[object Int8Array]",
+          "[object Uint8Array]",
+          "[object Uint8ClampedArray]",
+          "[object Int16Array]",
+          "[object Uint16Array]",
+          "[object Int32Array]",
+          "[object Uint32Array]",
+          "[object Float32Array]",
+          "[object Float64Array]"
+        ];
+        var isArrayBufferView = ArrayBuffer.isView || function(obj) {
+          return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+        };
+      }
+      function normalizeName(name) {
+        if (typeof name !== "string") {
+          name = String(name);
+        }
+        if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") {
+          throw new TypeError('Invalid character in header field name: "' + name + '"');
+        }
+        return name.toLowerCase();
+      }
+      function normalizeValue(value) {
+        if (typeof value !== "string") {
+          value = String(value);
+        }
+        return value;
+      }
+      function iteratorFor(items) {
+        var iterator = {
+          next: function() {
+            var value = items.shift();
+            return { done: value === undefined, value };
+          }
+        };
+        if (support.iterable) {
+          iterator[Symbol.iterator] = function() {
+            return iterator;
+          };
+        }
+        return iterator;
+      }
+      function Headers(headers) {
+        this.map = {};
+        if (headers instanceof Headers) {
+          headers.forEach(function(value, name) {
+            this.append(name, value);
+          }, this);
+        } else if (Array.isArray(headers)) {
+          headers.forEach(function(header) {
+            if (header.length != 2) {
+              throw new TypeError("Headers constructor: expected name/value pair to be length 2, found" + header.length);
+            }
+            this.append(header[0], header[1]);
+          }, this);
+        } else if (headers) {
+          Object.getOwnPropertyNames(headers).forEach(function(name) {
+            this.append(name, headers[name]);
+          }, this);
+        }
+      }
+      Headers.prototype.append = function(name, value) {
+        name = normalizeName(name);
+        value = normalizeValue(value);
+        var oldValue = this.map[name];
+        this.map[name] = oldValue ? oldValue + ", " + value : value;
+      };
+      Headers.prototype["delete"] = function(name) {
+        delete this.map[normalizeName(name)];
+      };
+      Headers.prototype.get = function(name) {
+        name = normalizeName(name);
+        return this.has(name) ? this.map[name] : null;
+      };
+      Headers.prototype.has = function(name) {
+        return this.map.hasOwnProperty(normalizeName(name));
+      };
+      Headers.prototype.set = function(name, value) {
+        this.map[normalizeName(name)] = normalizeValue(value);
+      };
+      Headers.prototype.forEach = function(callback, thisArg) {
+        for (var name in this.map) {
+          if (this.map.hasOwnProperty(name)) {
+            callback.call(thisArg, this.map[name], name, this);
+          }
+        }
+      };
+      Headers.prototype.keys = function() {
+        var items = [];
+        this.forEach(function(value, name) {
+          items.push(name);
+        });
+        return iteratorFor(items);
+      };
+      Headers.prototype.values = function() {
+        var items = [];
+        this.forEach(function(value) {
+          items.push(value);
+        });
+        return iteratorFor(items);
+      };
+      Headers.prototype.entries = function() {
+        var items = [];
+        this.forEach(function(value, name) {
+          items.push([name, value]);
+        });
+        return iteratorFor(items);
+      };
+      if (support.iterable) {
+        Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+      }
+      function consumed(body) {
+        if (body._noBody)
+          return;
+        if (body.bodyUsed) {
+          return Promise.reject(new TypeError("Already read"));
+        }
+        body.bodyUsed = true;
+      }
+      function fileReaderReady(reader) {
+        return new Promise(function(resolve, reject) {
+          reader.onload = function() {
+            resolve(reader.result);
+          };
+          reader.onerror = function() {
+            reject(reader.error);
+          };
+        });
+      }
+      function readBlobAsArrayBuffer(blob) {
+        var reader = new FileReader;
+        var promise = fileReaderReady(reader);
+        reader.readAsArrayBuffer(blob);
+        return promise;
+      }
+      function readBlobAsText(blob) {
+        var reader = new FileReader;
+        var promise = fileReaderReady(reader);
+        var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+        var encoding = match ? match[1] : "utf-8";
+        reader.readAsText(blob, encoding);
+        return promise;
+      }
+      function readArrayBufferAsText(buf) {
+        var view = new Uint8Array(buf);
+        var chars = new Array(view.length);
+        for (var i = 0;i < view.length; i++) {
+          chars[i] = String.fromCharCode(view[i]);
+        }
+        return chars.join("");
+      }
+      function bufferClone(buf) {
+        if (buf.slice) {
+          return buf.slice(0);
+        } else {
+          var view = new Uint8Array(buf.byteLength);
+          view.set(new Uint8Array(buf));
+          return view.buffer;
+        }
+      }
+      function Body() {
+        this.bodyUsed = false;
+        this._initBody = function(body) {
+          this.bodyUsed = this.bodyUsed;
+          this._bodyInit = body;
+          if (!body) {
+            this._noBody = true;
+            this._bodyText = "";
+          } else if (typeof body === "string") {
+            this._bodyText = body;
+          } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+            this._bodyBlob = body;
+          } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+            this._bodyFormData = body;
+          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+            this._bodyText = body.toString();
+          } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+            this._bodyArrayBuffer = bufferClone(body.buffer);
+            this._bodyInit = new Blob([this._bodyArrayBuffer]);
+          } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+            this._bodyArrayBuffer = bufferClone(body);
+          } else {
+            this._bodyText = body = Object.prototype.toString.call(body);
+          }
+          if (!this.headers.get("content-type")) {
+            if (typeof body === "string") {
+              this.headers.set("content-type", "text/plain;charset=UTF-8");
+            } else if (this._bodyBlob && this._bodyBlob.type) {
+              this.headers.set("content-type", this._bodyBlob.type);
+            } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+              this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+            }
+          }
+        };
+        if (support.blob) {
+          this.blob = function() {
+            var rejected = consumed(this);
+            if (rejected) {
+              return rejected;
+            }
+            if (this._bodyBlob) {
+              return Promise.resolve(this._bodyBlob);
+            } else if (this._bodyArrayBuffer) {
+              return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+            } else if (this._bodyFormData) {
+              throw new Error("could not read FormData body as blob");
+            } else {
+              return Promise.resolve(new Blob([this._bodyText]));
+            }
+          };
+        }
+        this.arrayBuffer = function() {
+          if (this._bodyArrayBuffer) {
+            var isConsumed = consumed(this);
+            if (isConsumed) {
+              return isConsumed;
+            } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+              return Promise.resolve(this._bodyArrayBuffer.buffer.slice(this._bodyArrayBuffer.byteOffset, this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength));
+            } else {
+              return Promise.resolve(this._bodyArrayBuffer);
+            }
+          } else if (support.blob) {
+            return this.blob().then(readBlobAsArrayBuffer);
+          } else {
+            throw new Error("could not read as ArrayBuffer");
+          }
+        };
+        this.text = function() {
+          var rejected = consumed(this);
+          if (rejected) {
+            return rejected;
+          }
+          if (this._bodyBlob) {
+            return readBlobAsText(this._bodyBlob);
+          } else if (this._bodyArrayBuffer) {
+            return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
+          } else if (this._bodyFormData) {
+            throw new Error("could not read FormData body as text");
+          } else {
+            return Promise.resolve(this._bodyText);
+          }
+        };
+        if (support.formData) {
+          this.formData = function() {
+            return this.text().then(decode);
+          };
+        }
+        this.json = function() {
+          return this.text().then(JSON.parse);
+        };
+        return this;
+      }
+      var methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+      function normalizeMethod(method) {
+        var upcased = method.toUpperCase();
+        return methods.indexOf(upcased) > -1 ? upcased : method;
+      }
+      function Request(input, options) {
+        if (!(this instanceof Request)) {
+          throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+        }
+        options = options || {};
+        var body = options.body;
+        if (input instanceof Request) {
+          if (input.bodyUsed) {
+            throw new TypeError("Already read");
+          }
+          this.url = input.url;
+          this.credentials = input.credentials;
+          if (!options.headers) {
+            this.headers = new Headers(input.headers);
+          }
+          this.method = input.method;
+          this.mode = input.mode;
+          this.signal = input.signal;
+          if (!body && input._bodyInit != null) {
+            body = input._bodyInit;
+            input.bodyUsed = true;
+          }
+        } else {
+          this.url = String(input);
+        }
+        this.credentials = options.credentials || this.credentials || "same-origin";
+        if (options.headers || !this.headers) {
+          this.headers = new Headers(options.headers);
+        }
+        this.method = normalizeMethod(options.method || this.method || "GET");
+        this.mode = options.mode || this.mode || null;
+        this.signal = options.signal || this.signal || function() {
+          if ("AbortController" in g) {
+            var ctrl = new AbortController;
+            return ctrl.signal;
+          }
+        }();
+        this.referrer = null;
+        if ((this.method === "GET" || this.method === "HEAD") && body) {
+          throw new TypeError("Body not allowed for GET or HEAD requests");
+        }
+        this._initBody(body);
+        if (this.method === "GET" || this.method === "HEAD") {
+          if (options.cache === "no-store" || options.cache === "no-cache") {
+            var reParamSearch = /([?&])_=[^&]*/;
+            if (reParamSearch.test(this.url)) {
+              this.url = this.url.replace(reParamSearch, "$1_=" + new Date().getTime());
+            } else {
+              var reQueryString = /\?/;
+              this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + new Date().getTime();
+            }
+          }
+        }
+      }
+      Request.prototype.clone = function() {
+        return new Request(this, { body: this._bodyInit });
+      };
+      function decode(body) {
+        var form = new FormData;
+        body.trim().split("&").forEach(function(bytes) {
+          if (bytes) {
+            var split = bytes.split("=");
+            var name = split.shift().replace(/\+/g, " ");
+            var value = split.join("=").replace(/\+/g, " ");
+            form.append(decodeURIComponent(name), decodeURIComponent(value));
+          }
+        });
+        return form;
+      }
+      function parseHeaders(rawHeaders) {
+        var headers = new Headers;
+        var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+        preProcessedHeaders.split("\r").map(function(header) {
+          return header.indexOf(`
+`) === 0 ? header.substr(1, header.length) : header;
+        }).forEach(function(line) {
+          var parts = line.split(":");
+          var key = parts.shift().trim();
+          if (key) {
+            var value = parts.join(":").trim();
+            try {
+              headers.append(key, value);
+            } catch (error) {
+              console.warn("Response " + error.message);
+            }
+          }
+        });
+        return headers;
+      }
+      Body.call(Request.prototype);
+      function Response(bodyInit, options) {
+        if (!(this instanceof Response)) {
+          throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+        }
+        if (!options) {
+          options = {};
+        }
+        this.type = "default";
+        this.status = options.status === undefined ? 200 : options.status;
+        if (this.status < 200 || this.status > 599) {
+          throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].");
+        }
+        this.ok = this.status >= 200 && this.status < 300;
+        this.statusText = options.statusText === undefined ? "" : "" + options.statusText;
+        this.headers = new Headers(options.headers);
+        this.url = options.url || "";
+        this._initBody(bodyInit);
+      }
+      Body.call(Response.prototype);
+      Response.prototype.clone = function() {
+        return new Response(this._bodyInit, {
+          status: this.status,
+          statusText: this.statusText,
+          headers: new Headers(this.headers),
+          url: this.url
+        });
+      };
+      Response.error = function() {
+        var response = new Response(null, { status: 200, statusText: "" });
+        response.ok = false;
+        response.status = 0;
+        response.type = "error";
+        return response;
+      };
+      var redirectStatuses = [301, 302, 303, 307, 308];
+      Response.redirect = function(url, status) {
+        if (redirectStatuses.indexOf(status) === -1) {
+          throw new RangeError("Invalid status code");
+        }
+        return new Response(null, { status, headers: { location: url } });
+      };
+      exports2.DOMException = g.DOMException;
+      try {
+        new exports2.DOMException;
+      } catch (err) {
+        exports2.DOMException = function(message, name) {
+          this.message = message;
+          this.name = name;
+          var error = Error(message);
+          this.stack = error.stack;
+        };
+        exports2.DOMException.prototype = Object.create(Error.prototype);
+        exports2.DOMException.prototype.constructor = exports2.DOMException;
+      }
+      function fetch(input, init) {
+        return new Promise(function(resolve, reject) {
+          var request = new Request(input, init);
+          if (request.signal && request.signal.aborted) {
+            return reject(new exports2.DOMException("Aborted", "AbortError"));
+          }
+          var xhr = new XMLHttpRequest;
+          function abortXhr() {
+            xhr.abort();
+          }
+          xhr.onload = function() {
+            var options = {
+              statusText: xhr.statusText,
+              headers: parseHeaders(xhr.getAllResponseHeaders() || "")
+            };
+            if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
+              options.status = 200;
+            } else {
+              options.status = xhr.status;
+            }
+            options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL");
+            var body = "response" in xhr ? xhr.response : xhr.responseText;
+            setTimeout(function() {
+              resolve(new Response(body, options));
+            }, 0);
+          };
+          xhr.onerror = function() {
+            setTimeout(function() {
+              reject(new TypeError("Network request failed"));
+            }, 0);
+          };
+          xhr.ontimeout = function() {
+            setTimeout(function() {
+              reject(new TypeError("Network request timed out"));
+            }, 0);
+          };
+          xhr.onabort = function() {
+            setTimeout(function() {
+              reject(new exports2.DOMException("Aborted", "AbortError"));
+            }, 0);
+          };
+          function fixUrl(url) {
+            try {
+              return url === "" && g.location.href ? g.location.href : url;
+            } catch (e) {
+              return url;
+            }
+          }
+          xhr.open(request.method, fixUrl(request.url), true);
+          if (request.credentials === "include") {
+            xhr.withCredentials = true;
+          } else if (request.credentials === "omit") {
+            xhr.withCredentials = false;
+          }
+          if ("responseType" in xhr) {
+            if (support.blob) {
+              xhr.responseType = "blob";
+            } else if (support.arrayBuffer) {
+              xhr.responseType = "arraybuffer";
+            }
+          }
+          if (init && typeof init.headers === "object" && !(init.headers instanceof Headers || g.Headers && init.headers instanceof g.Headers)) {
+            var names = [];
+            Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+              names.push(normalizeName(name));
+              xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+            });
+            request.headers.forEach(function(value, name) {
+              if (names.indexOf(name) === -1) {
+                xhr.setRequestHeader(name, value);
+              }
+            });
+          } else {
+            request.headers.forEach(function(value, name) {
+              xhr.setRequestHeader(name, value);
+            });
+          }
+          if (request.signal) {
+            request.signal.addEventListener("abort", abortXhr);
+            xhr.onreadystatechange = function() {
+              if (xhr.readyState === 4) {
+                request.signal.removeEventListener("abort", abortXhr);
+              }
+            };
+          }
+          xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit);
+        });
+      }
+      fetch.polyfill = true;
+      if (!g.fetch) {
+        g.fetch = fetch;
+        g.Headers = Headers;
+        g.Request = Request;
+        g.Response = Response;
+      }
+      exports2.Headers = Headers;
+      exports2.Request = Request;
+      exports2.Response = Response;
+      exports2.fetch = fetch;
+      return exports2;
+    }({});
+  })(__globalThis__);
+  __globalThis__.fetch.ponyfill = true;
+  delete __globalThis__.fetch.polyfill;
+  var ctx = __global__.fetch ? __global__ : __globalThis__;
+  exports = ctx.fetch;
+  exports.default = ctx.fetch;
+  exports.fetch = ctx.fetch;
+  exports.Headers = ctx.Headers;
+  exports.Request = ctx.Request;
+  exports.Response = ctx.Response;
+  module.exports = exports;
+});
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./bento-node-sdk.cjs.production.min.js')
-} else {
-  module.exports = require('./bento-node-sdk.cjs.development.js')
+// src/sdk/batch/errors.ts
+class TooFewSubscribersError extends Error {
+  constructor(message = "Too few subscribers") {
+    super(message);
+    this.name = "TooFewSubscribersError";
+  }
 }
+
+class TooManySubscribersError extends Error {
+  constructor(message = "Too many subscribers") {
+    super(message);
+    this.name = "TooManySubscribersError";
+  }
+}
+
+class TooFewEventsError extends Error {
+  constructor(message = "Too few events") {
+    super(message);
+    this.name = "TooFewEventsError";
+  }
+}
+
+class TooManyEventsError extends Error {
+  constructor(message = "Too many events") {
+    super(message);
+    this.name = "TooManyEventsError";
+  }
+}
+
+class TooFewEmailsError extends Error {
+  constructor(message = "Too few emails") {
+    super(message);
+    this.name = "TooFewEmailsError";
+  }
+}
+
+class TooManyEmailsError extends Error {
+  constructor(message = "Too many emails") {
+    super(message);
+    this.name = "TooManyEmailsError";
+  }
+}
+
+// src/sdk/batch/index.ts
+class BentoBatch {
+  _client;
+  _maxEmailBatchSize = 100;
+  _maxBatchSize = 1000;
+  _url = "/batch";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async importSubscribers(parameters) {
+    if (parameters.subscribers.length === 0) {
+      throw new TooFewSubscribersError(`You must send between 1 and 1,000 subscribers.`);
+    }
+    if (parameters.subscribers.length > this._maxBatchSize) {
+      throw new TooManySubscribersError(`You must send between 1 and 1,000 subscribers.`);
+    }
+    const result = await this._client.post(`${this._url}/subscribers`, {
+      subscribers: parameters.subscribers
+    }, { timeout: null });
+    return result.results;
+  }
+  async importEvents(parameters) {
+    if (parameters.events.length === 0) {
+      throw new TooFewEventsError(`You must send between 1 and 1,000 events.`);
+    }
+    if (parameters.events.length > this._maxBatchSize) {
+      throw new TooManyEventsError(`You must send between 1 and 1,000 events.`);
+    }
+    const result = await this._client.post(`${this._url}/events`, {
+      events: parameters.events
+    }, { timeout: null });
+    return result.results;
+  }
+  async sendTransactionalEmails(parameters) {
+    if (parameters.emails.length === 0) {
+      throw new TooFewEmailsError(`You must send between 1 and 100 emails.`);
+    }
+    if (parameters.emails.length > this._maxEmailBatchSize) {
+      throw new TooManyEmailsError(`You must send between 1 and 100 emails.`);
+    }
+    const result = await this._client.post(`${this._url}/emails`, {
+      emails: parameters.emails
+    });
+    return result.results;
+  }
+}
+// src/sdk/client/index.ts
+var import_cross_fetch = __toESM(require_browser_ponyfill(), 1);
+
+// src/sdk/client/errors.ts
+class NotAuthorizedError extends Error {
+  constructor(message = "Not authorized") {
+    super(message);
+    this.name = "NotAuthorizedError";
+  }
+}
+
+class RateLimitedError extends Error {
+  constructor(message = "You are being rate limited") {
+    super(message);
+    this.name = "RateLimitedError";
+  }
+}
+
+class AuthorNotAuthorizedError extends Error {
+  constructor(message = "Author not authorized to send on this account") {
+    super(message);
+    this.name = "AuthorNotAuthorizedError";
+  }
+}
+
+class RequestTimeoutError extends Error {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "RequestTimeoutError";
+  }
+}
+
+// src/sdk/client/index.ts
+function encodeBase64(str) {
+  if (typeof btoa === "function") {
+    return btoa(str);
+  } else if (typeof Buffer !== "undefined") {
+    return Buffer.from(str).toString("base64");
+  } else {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    let output = "";
+    for (let block = 0, charCode, i = 0, map = chars;str.charAt(i | 0) || (map = "=", i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {
+      charCode = str.charCodeAt(i += 3 / 4);
+      if (charCode > 255) {
+        throw new Error("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
+      }
+      block = block << 8 | charCode;
+    }
+    return output;
+  }
+}
+
+class BentoClient {
+  _headers = {};
+  _baseUrl = "https://app.bentonow.com/api/v1";
+  _siteUuid = "";
+  _logErrors = false;
+  _timeout = 30000;
+  constructor(options) {
+    this._baseUrl = options.clientOptions?.baseUrl || this._baseUrl;
+    this._siteUuid = options.siteUuid;
+    this._headers = this._extractHeaders(options.authentication, options.siteUuid);
+    this._logErrors = options.logErrors || false;
+    this._timeout = options.clientOptions?.timeout ?? this._timeout;
+  }
+  async get(endpoint, payload = {}, requestOptions = {}) {
+    const queryParameters = this._getQueryParameters(payload);
+    const url = `${this._baseUrl}${endpoint}?${queryParameters}`;
+    const timeoutMs = requestOptions.timeout === undefined ? this._timeout : requestOptions.timeout;
+    const response = await this._fetchWithTimeout(url, {
+      method: "GET",
+      headers: this._headers
+    }, timeoutMs);
+    return this._handleResponse(response);
+  }
+  async post(endpoint, payload = {}, requestOptions = {}) {
+    const body = this._getBody(payload);
+    const url = `${this._baseUrl}${endpoint}`;
+    const timeoutMs = requestOptions.timeout === undefined ? this._timeout : requestOptions.timeout;
+    const response = await this._fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        ...this._headers,
+        "Content-Type": "application/json"
+      },
+      body
+    }, timeoutMs);
+    return this._handleResponse(response);
+  }
+  async patch(endpoint, payload = {}, requestOptions = {}) {
+    const body = this._getBody(payload);
+    const url = `${this._baseUrl}${endpoint}`;
+    const timeoutMs = requestOptions.timeout === undefined ? this._timeout : requestOptions.timeout;
+    const response = await this._fetchWithTimeout(url, {
+      method: "PATCH",
+      headers: {
+        ...this._headers,
+        "Content-Type": "application/json"
+      },
+      body
+    }, timeoutMs);
+    return this._handleResponse(response);
+  }
+  async _fetchWithTimeout(url, options, timeout) {
+    if (timeout === null) {
+      return import_cross_fetch.default(url, options);
+    }
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await import_cross_fetch.default(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new RequestTimeoutError(`Request timed out after ${timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async _handleResponse(response) {
+    if (this._isSuccessfulStatus(response.status)) {
+      try {
+        const data = await response.json();
+        return data;
+      } catch {
+        throw new Error(`[${response.status}] - Invalid JSON response from server`);
+      }
+    }
+    throw await this._getErrorForResponse(response);
+  }
+  _extractHeaders(authentication, siteUuid) {
+    const authenticationKey = encodeBase64(`${authentication.publishableKey}:${authentication.secretKey}`);
+    return {
+      Authorization: `Basic ${authenticationKey}`,
+      "User-Agent": `bento-node-${siteUuid}`
+    };
+  }
+  _getBody(payload) {
+    return JSON.stringify({
+      ...payload,
+      site_uuid: this._siteUuid
+    });
+  }
+  _getQueryParameters(payload) {
+    const body = {
+      ...payload,
+      site_uuid: this._siteUuid
+    };
+    const queryParameters = new URLSearchParams;
+    for (const [key, value] of Object.entries(body)) {
+      queryParameters.append(key, String(value));
+    }
+    return queryParameters.toString();
+  }
+  _isSuccessfulStatus(statusCode) {
+    const validStatusCodes = [200, 201];
+    return validStatusCodes.includes(statusCode);
+  }
+  async _getErrorForResponse(response) {
+    if (this._logErrors) {
+      console.error(response);
+    }
+    if (response.status === 401)
+      return new NotAuthorizedError;
+    if (response.status === 429)
+      return new RateLimitedError;
+    const contentType = response.headers.get("Content-Type");
+    let responseMessage = "";
+    let json = null;
+    try {
+      if (contentType?.toLowerCase().includes("application/json")) {
+        try {
+          json = await response.json();
+        } catch {
+          responseMessage = "Unable to parse JSON response";
+        }
+      } else if (contentType?.toLowerCase().includes("text/plain")) {
+        try {
+          responseMessage = await response.text();
+        } catch {
+          responseMessage = "Unable to read text response";
+        }
+      } else {
+        responseMessage = "Unknown response from the Bento API.";
+      }
+    } catch {
+      responseMessage = "Unable to read response body";
+    }
+    if (json && json.error === "Author not authorized to send on this account") {
+      return new AuthorNotAuthorizedError(json.error);
+    }
+    if (json) {
+      responseMessage = JSON.stringify(json);
+    }
+    if (!responseMessage) {
+      responseMessage = "Unknown response from the Bento API.";
+    }
+    return new Error(`[${response.status}] - ${responseMessage}`);
+  }
+}
+// src/sdk/commands/index.ts
+class BentoCommands {
+  _client;
+  _url = "/fetch/commands";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async addTag(parameters) {
+    const result = await this._client.post(this._url, {
+      command: {
+        command: "add_tag" /* ADD_TAG */,
+        email: parameters.email,
+        query: parameters.tagName
+      }
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async removeTag(parameters) {
+    const result = await this._client.post(this._url, {
+      command: {
+        command: "remove_tag" /* REMOVE_TAG */,
+        email: parameters.email,
+        query: parameters.tagName
+      }
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async addField(parameters) {
+    const result = await this._client.post(this._url, {
+      command: {
+        command: "add_field" /* ADD_FIELD */,
+        email: parameters.email,
+        query: parameters.field
+      }
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async removeField(parameters) {
+    const result = await this._client.post(this._url, {
+      command: {
+        command: "remove_field" /* REMOVE_FIELD */,
+        email: parameters.email,
+        query: parameters.fieldName
+      }
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async subscribe(parameters) {
+    const result = await this._client.post(this._url, {
+      command: {
+        command: "subscribe" /* SUBSCRIBE */,
+        email: parameters.email
+      }
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async unsubscribe(parameters) {
+    const result = await this._client.post(this._url, {
+      command: {
+        command: "unsubscribe" /* UNSUBSCRIBE */,
+        email: parameters.email
+      }
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async changeEmail(parameters) {
+    const result = await this._client.post(this._url, {
+      command: {
+        command: "change_email" /* CHANGE_EMAIL */,
+        email: parameters.oldEmail,
+        query: parameters.newEmail
+      }
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+}
+// src/sdk/email-templates/index.ts
+class BentoEmailTemplates {
+  _client;
+  _url = "/fetch/emails/templates";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getEmailTemplate(parameters) {
+    const result = await this._client.get(`${this._url}/${parameters.id}`);
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async updateEmailTemplate(parameters) {
+    const { id, ...updateFields } = parameters;
+    const result = await this._client.patch(`${this._url}/${id}`, {
+      email_template: updateFields
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+}
+// src/sdk/experimental/index.ts
+class BentoExperimental {
+  _client;
+  _url = "/experimental";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async validateEmail(parameters) {
+    const result = await this._client.post(`${this._url}/validation`, {
+      email: parameters.email,
+      ip: parameters.ip,
+      name: parameters.name,
+      user_agent: parameters.userAgent
+    });
+    return result.valid;
+  }
+  async guessGender(parameters) {
+    const result = await this._client.post(`${this._url}/gender`, parameters);
+    return result;
+  }
+  async geolocate(parameters) {
+    const result = await this._client.get(`${this._url}/geolocation`, parameters);
+    if (Object.keys(result).length === 0)
+      return null;
+    return result;
+  }
+  async checkBlacklist(parameters) {
+    const result = await this._client.get(`${this._url}/blacklist.json`, parameters);
+    return result;
+  }
+  async getBlacklistStatus(input) {
+    return this._client.get(`${this._url}/blacklist`, input);
+  }
+  async getContentModeration(content) {
+    return this._client.post(`${this._url}/moderation`, {
+      content
+    });
+  }
+  async geoLocateIP(ipAddress) {
+    return this._client.get(`${this._url}/geolocation`, {
+      ip: ipAddress
+    });
+  }
+}
+// src/sdk/fields/index.ts
+class BentoFields {
+  _client;
+  _url = "/fetch/fields";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getFields() {
+    const result = await this._client.get(this._url);
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async createField(parameters) {
+    const result = await this._client.post(this._url, {
+      field: parameters
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+}
+// src/sdk/forms/index.ts
+class BentoForms {
+  _client;
+  _url = "/fetch/responses";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getResponses(formIdentifier) {
+    const result = await this._client.get(this._url, {
+      id: formIdentifier
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+}
+// src/sdk/sequences/index.ts
+class BentoSequences {
+  _client;
+  _url = "/fetch/sequences";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getSequences() {
+    const result = await this._client.get(this._url);
+    if (!result || Object.keys(result).length === 0)
+      return [];
+    return result.data ?? [];
+  }
+}
+// src/sdk/subscribers/index.ts
+class BentoSubscribers {
+  _client;
+  _url = "/fetch/subscribers";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getSubscribers(parameters) {
+    const result = await this._client.get(this._url, parameters);
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async createSubscriber(parameters) {
+    const result = await this._client.post(this._url, {
+      subscriber: parameters
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+}
+// src/sdk/tags/index.ts
+class BentoTags {
+  _client;
+  _url = "/fetch/tags";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getTags() {
+    const result = await this._client.get(this._url);
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+  async createTag(parameters) {
+    const result = await this._client.post(this._url, {
+      tag: parameters
+    });
+    if (Object.keys(result).length === 0 || !result.data)
+      return null;
+    return result.data;
+  }
+}
+// src/sdk/workflows/index.ts
+class BentoWorkflows {
+  _client;
+  _url = "/fetch/workflows";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getWorkflows() {
+    const result = await this._client.get(this._url);
+    if (!result || Object.keys(result).length === 0)
+      return [];
+    return result.data ?? [];
+  }
+}
+// src/sdk/broadcasts/index.ts
+class BentoBroadcasts {
+  _client;
+  _fetchUrl = "/fetch/broadcasts";
+  _batchUrl = "/batch/broadcasts";
+  _emailsUrl = "/batch/emails";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async createEmails(emails) {
+    const result = await this._client.post(this._emailsUrl, {
+      emails
+    });
+    return result.results;
+  }
+  async getBroadcasts() {
+    const result = await this._client.get(this._fetchUrl);
+    return result.data ?? [];
+  }
+  async createBroadcast(broadcasts) {
+    const result = await this._client.post(this._batchUrl, {
+      broadcasts
+    });
+    return result.data ?? [];
+  }
+}
+
+// src/sdk/stats/index.ts
+class BentoStats {
+  _client;
+  _url = "/stats";
+  constructor(_client) {
+    this._client = _client;
+  }
+  async getSiteStats() {
+    const result = await this._client.get(`${this._url}/site`);
+    return result;
+  }
+  async getSegmentStats(segmentId) {
+    const result = await this._client.get(`${this._url}/segments/${segmentId}`);
+    return result;
+  }
+  async getReportStats(reportId) {
+    const result = await this._client.get(`${this._url}/reports/${reportId}`);
+    return result;
+  }
+}
+
+// src/versions/v1/index.ts
+class BentoAPIV1 {
+  _client;
+  Broadcasts;
+  EmailTemplates;
+  Stats;
+  Batch;
+  Commands;
+  Experimental;
+  Fields;
+  Forms;
+  Sequences;
+  Subscribers;
+  Tags;
+  Workflows;
+  constructor(options) {
+    this._client = new BentoClient(options);
+    this.Broadcasts = new BentoBroadcasts(this._client);
+    this.EmailTemplates = new BentoEmailTemplates(this._client);
+    this.Stats = new BentoStats(this._client);
+    this.Batch = new BentoBatch(this._client);
+    this.Commands = new BentoCommands(this._client);
+    this.Experimental = new BentoExperimental(this._client);
+    this.Fields = new BentoFields(this._client);
+    this.Forms = new BentoForms(this._client);
+    this.Sequences = new BentoSequences(this._client);
+    this.Subscribers = new BentoSubscribers(this._client);
+    this.Tags = new BentoTags(this._client);
+    this.Workflows = new BentoWorkflows(this._client);
+  }
+  async tagSubscriber(parameters) {
+    const result = await this.Batch.importEvents({
+      events: [
+        {
+          date: parameters.date,
+          details: {
+            tag: parameters.tagName
+          },
+          email: parameters.email,
+          type: "$tag" /* TAG */
+        }
+      ]
+    });
+    return result === 1;
+  }
+  async addSubscriber(parameters) {
+    const result = await this.Batch.importEvents({
+      events: [
+        {
+          date: parameters.date,
+          email: parameters.email,
+          type: "$subscribe" /* SUBSCRIBE */,
+          fields: parameters.fields || {}
+        }
+      ]
+    });
+    return result === 1;
+  }
+  async removeSubscriber(parameters) {
+    const result = await this.Batch.importEvents({
+      events: [
+        {
+          date: parameters.date,
+          email: parameters.email,
+          type: "$unsubscribe" /* UNSUBSCRIBE */
+        }
+      ]
+    });
+    return result === 1;
+  }
+  async updateFields(parameters) {
+    const result = await this.Batch.importEvents({
+      events: [
+        {
+          date: parameters.date,
+          email: parameters.email,
+          type: "$update_fields" /* UPDATE_FIELDS */,
+          fields: parameters.fields
+        }
+      ]
+    });
+    return result === 1;
+  }
+  async trackPurchase(parameters) {
+    const result = await this.Batch.importEvents({
+      events: [
+        {
+          date: parameters.date,
+          email: parameters.email,
+          type: "$purchase" /* PURCHASE */,
+          details: parameters.purchaseDetails
+        }
+      ]
+    });
+    return result === 1;
+  }
+  async track(parameters) {
+    const result = await this.Batch.importEvents({
+      events: [parameters]
+    });
+    return result === 1;
+  }
+  async upsertSubscriber(parameters) {
+    await this.Batch.importSubscribers({
+      subscribers: [
+        {
+          email: parameters.email,
+          ...parameters.fields,
+          ...parameters.tags && { tags: parameters.tags },
+          ...parameters.remove_tags && { remove_tags: parameters.remove_tags }
+        }
+      ]
+    });
+    return this.Subscribers.getSubscribers({
+      email: parameters.email
+    });
+  }
+}
+
+// src/index.ts
+class Analytics {
+  V1;
+  constructor(options) {
+    this.V1 = new BentoAPIV1(options);
+  }
+}
+export {
+  RequestTimeoutError,
+  RateLimitedError,
+  NotAuthorizedError,
+  AuthorNotAuthorizedError,
+  Analytics
+};