@messagebird/sdk 0.2.2 → 0.4.1

package/dist/index.js

@@ -1,1699 +0,0 @@
-import { Webhook } from 'standardwebhooks';
-
-// src/generated/core/bodySerializer.gen.ts
-var jsonBodySerializer = {
-  bodySerializer: (body) => JSON.stringify(
-    body,
-    (_key, value) => typeof value === "bigint" ? value.toString() : value
-  )
-};
-
-// src/generated/core/serverSentEvents.gen.ts
-function createSseClient({
-  onRequest,
-  onSseError,
-  onSseEvent,
-  responseTransformer,
-  responseValidator,
-  sseDefaultRetryDelay,
-  sseMaxRetryAttempts,
-  sseMaxRetryDelay,
-  sseSleepFn,
-  url,
-  ...options
-}) {
-  let lastEventId;
-  const sleep2 = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const createStream = async function* () {
-    let retryDelay2 = sseDefaultRetryDelay ?? 3e3;
-    let attempt = 0;
-    const signal = options.signal ?? new AbortController().signal;
-    while (true) {
-      if (signal.aborted) break;
-      attempt++;
-      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
-      if (lastEventId !== void 0) {
-        headers.set("Last-Event-ID", lastEventId);
-      }
-      try {
-        const requestInit = {
-          redirect: "follow",
-          ...options,
-          body: options.serializedBody,
-          headers,
-          signal
-        };
-        let request = new Request(url, requestInit);
-        if (onRequest) {
-          request = await onRequest(url, requestInit);
-        }
-        const _fetch = options.fetch ?? globalThis.fetch;
-        const response = await _fetch(request);
-        if (!response.ok)
-          throw new Error(
-            `SSE failed: ${response.status} ${response.statusText}`
-          );
-        if (!response.body) throw new Error("No body in SSE response");
-        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-        let buffer = "";
-        const abortHandler = () => {
-          try {
-            reader.cancel();
-          } catch {
-          }
-        };
-        signal.addEventListener("abort", abortHandler);
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            buffer += value;
-            buffer = buffer.replace(/\r\n?/g, "\n");
-            const chunks = buffer.split("\n\n");
-            buffer = chunks.pop() ?? "";
-            for (const chunk of chunks) {
-              const lines = chunk.split("\n");
-              const dataLines = [];
-              let eventName;
-              for (const line of lines) {
-                if (line.startsWith("data:")) {
-                  dataLines.push(line.replace(/^data:\s*/, ""));
-                } else if (line.startsWith("event:")) {
-                  eventName = line.replace(/^event:\s*/, "");
-                } else if (line.startsWith("id:")) {
-                  lastEventId = line.replace(/^id:\s*/, "");
-                } else if (line.startsWith("retry:")) {
-                  const parsed = Number.parseInt(
-                    line.replace(/^retry:\s*/, ""),
-                    10
-                  );
-                  if (!Number.isNaN(parsed)) {
-                    retryDelay2 = parsed;
-                  }
-                }
-              }
-              let data;
-              let parsedJson = false;
-              if (dataLines.length) {
-                const rawData = dataLines.join("\n");
-                try {
-                  data = JSON.parse(rawData);
-                  parsedJson = true;
-                } catch {
-                  data = rawData;
-                }
-              }
-              if (parsedJson) {
-                if (responseValidator) {
-                  await responseValidator(data);
-                }
-                if (responseTransformer) {
-                  data = await responseTransformer(data);
-                }
-              }
-              onSseEvent?.({
-                data,
-                event: eventName,
-                id: lastEventId,
-                retry: retryDelay2
-              });
-              if (dataLines.length) {
-                yield data;
-              }
-            }
-          }
-        } finally {
-          signal.removeEventListener("abort", abortHandler);
-          reader.releaseLock();
-        }
-        break;
-      } catch (error) {
-        onSseError?.(error);
-        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
-          break;
-        }
-        const backoff = Math.min(
-          retryDelay2 * 2 ** (attempt - 1),
-          sseMaxRetryDelay ?? 3e4
-        );
-        await sleep2(backoff);
-      }
-    }
-  };
-  const stream = createStream();
-  return { stream };
-}
-
-// src/generated/core/pathSerializer.gen.ts
-var separatorArrayExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-var separatorArrayNoExplode = (style) => {
-  switch (style) {
-    case "form":
-      return ",";
-    case "pipeDelimited":
-      return "|";
-    case "spaceDelimited":
-      return "%20";
-    default:
-      return ",";
-  }
-};
-var separatorObjectExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-var serializeArrayParam = ({
-  allowReserved,
-  explode,
-  name,
-  style,
-  value
-}) => {
-  if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
-    switch (style) {
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      case "simple":
-        return joinedValues2;
-      default:
-        return `${name}=${joinedValues2}`;
-    }
-  }
-  const separator = separatorArrayExplode(style);
-  const joinedValues = value.map((v) => {
-    if (style === "label" || style === "simple") {
-      return allowReserved ? v : encodeURIComponent(v);
-    }
-    return serializePrimitiveParam({
-      allowReserved,
-      name,
-      value: v
-    });
-  }).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-var serializePrimitiveParam = ({
-  allowReserved,
-  name,
-  value
-}) => {
-  if (value === void 0 || value === null) {
-    return "";
-  }
-  if (typeof value === "object") {
-    throw new Error(
-      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
-    );
-  }
-  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
-};
-var serializeObjectParam = ({
-  allowReserved,
-  explode,
-  name,
-  style,
-  value,
-  valueOnly
-}) => {
-  if (value instanceof Date) {
-    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
-  }
-  if (style !== "deepObject" && !explode) {
-    let values = [];
-    Object.entries(value).forEach(([key, v]) => {
-      values = [
-        ...values,
-        key,
-        allowReserved ? v : encodeURIComponent(v)
-      ];
-    });
-    const joinedValues2 = values.join(",");
-    switch (style) {
-      case "form":
-        return `${name}=${joinedValues2}`;
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      default:
-        return joinedValues2;
-    }
-  }
-  const separator = separatorObjectExplode(style);
-  const joinedValues = Object.entries(value).map(
-    ([key, v]) => serializePrimitiveParam({
-      allowReserved,
-      name: style === "deepObject" ? `${name}[${key}]` : key,
-      value: v
-    })
-  ).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-
-// src/generated/core/utils.gen.ts
-var PATH_PARAM_RE = /\{[^{}]+\}/g;
-var defaultPathSerializer = ({ path, url: _url }) => {
-  let url = _url;
-  const matches = _url.match(PATH_PARAM_RE);
-  if (matches) {
-    for (const match of matches) {
-      let explode = false;
-      let name = match.substring(1, match.length - 1);
-      let style = "simple";
-      if (name.endsWith("*")) {
-        explode = true;
-        name = name.substring(0, name.length - 1);
-      }
-      if (name.startsWith(".")) {
-        name = name.substring(1);
-        style = "label";
-      } else if (name.startsWith(";")) {
-        name = name.substring(1);
-        style = "matrix";
-      }
-      const value = path[name];
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        url = url.replace(
-          match,
-          serializeArrayParam({ explode, name, style, value })
-        );
-        continue;
-      }
-      if (typeof value === "object") {
-        url = url.replace(
-          match,
-          serializeObjectParam({
-            explode,
-            name,
-            style,
-            value,
-            valueOnly: true
-          })
-        );
-        continue;
-      }
-      if (style === "matrix") {
-        url = url.replace(
-          match,
-          `;${serializePrimitiveParam({
-            name,
-            value
-          })}`
-        );
-        continue;
-      }
-      const replaceValue = encodeURIComponent(
-        style === "label" ? `.${value}` : value
-      );
-      url = url.replace(match, replaceValue);
-    }
-  }
-  return url;
-};
-var getUrl = ({
-  baseUrl,
-  path,
-  query,
-  querySerializer,
-  url: _url
-}) => {
-  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
-  let url = (baseUrl ?? "") + pathUrl;
-  if (path) {
-    url = defaultPathSerializer({ path, url });
-  }
-  let search = query ? querySerializer(query) : "";
-  if (search.startsWith("?")) {
-    search = search.substring(1);
-  }
-  if (search) {
-    url += `?${search}`;
-  }
-  return url;
-};
-function getValidRequestBody(options) {
-  const hasBody = options.body !== void 0;
-  const isSerializedBody = hasBody && options.bodySerializer;
-  if (isSerializedBody) {
-    if ("serializedBody" in options) {
-      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
-      return hasSerializedBody ? options.serializedBody : null;
-    }
-    return options.body !== "" ? options.body : null;
-  }
-  if (hasBody) {
-    return options.body;
-  }
-  return void 0;
-}
-
-// src/generated/core/auth.gen.ts
-var getAuthToken = async (auth, callback) => {
-  const token = typeof callback === "function" ? await callback(auth) : callback;
-  if (!token) {
-    return;
-  }
-  if (auth.scheme === "bearer") {
-    return `Bearer ${token}`;
-  }
-  if (auth.scheme === "basic") {
-    return `Basic ${btoa(token)}`;
-  }
-  return token;
-};
-
-// src/generated/client/utils.gen.ts
-var createQuerySerializer = ({
-  parameters = {},
-  ...args
-} = {}) => {
-  const querySerializer = (queryParams) => {
-    const search = [];
-    if (queryParams && typeof queryParams === "object") {
-      for (const name in queryParams) {
-        const value = queryParams[name];
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        const options = parameters[name] || args;
-        if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
-            allowReserved: options.allowReserved,
-            explode: true,
-            name,
-            style: "form",
-            value,
-            ...options.array
-          });
-          if (serializedArray) search.push(serializedArray);
-        } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
-            allowReserved: options.allowReserved,
-            explode: true,
-            name,
-            style: "deepObject",
-            value,
-            ...options.object
-          });
-          if (serializedObject) search.push(serializedObject);
-        } else {
-          const serializedPrimitive = serializePrimitiveParam({
-            allowReserved: options.allowReserved,
-            name,
-            value
-          });
-          if (serializedPrimitive) search.push(serializedPrimitive);
-        }
-      }
-    }
-    return search.join("&");
-  };
-  return querySerializer;
-};
-var getParseAs = (contentType) => {
-  if (!contentType) {
-    return "stream";
-  }
-  const cleanContent = contentType.split(";")[0]?.trim();
-  if (!cleanContent) {
-    return;
-  }
-  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
-    return "json";
-  }
-  if (cleanContent === "multipart/form-data") {
-    return "formData";
-  }
-  if (["application/", "audio/", "image/", "video/"].some(
-    (type) => cleanContent.startsWith(type)
-  )) {
-    return "blob";
-  }
-  if (cleanContent.startsWith("text/")) {
-    return "text";
-  }
-  return;
-};
-var checkForExistence = (options, name) => {
-  if (!name) {
-    return false;
-  }
-  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
-    return true;
-  }
-  return false;
-};
-var setAuthParams = async ({
-  security,
-  ...options
-}) => {
-  for (const auth of security) {
-    if (checkForExistence(options, auth.name)) {
-      continue;
-    }
-    const token = await getAuthToken(auth, options.auth);
-    if (!token) {
-      continue;
-    }
-    const name = auth.name ?? "Authorization";
-    switch (auth.in) {
-      case "query":
-        if (!options.query) {
-          options.query = {};
-        }
-        options.query[name] = token;
-        break;
-      case "cookie":
-        options.headers.append("Cookie", `${name}=${token}`);
-        break;
-      case "header":
-      default:
-        options.headers.set(name, token);
-        break;
-    }
-  }
-};
-var buildUrl = (options) => getUrl({
-  baseUrl: options.baseUrl,
-  path: options.path,
-  query: options.query,
-  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
-  url: options.url
-});
-var mergeConfigs = (a, b) => {
-  const config = { ...a, ...b };
-  if (config.baseUrl?.endsWith("/")) {
-    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
-  }
-  config.headers = mergeHeaders(a.headers, b.headers);
-  return config;
-};
-var headersEntries = (headers) => {
-  const entries = [];
-  headers.forEach((value, key) => {
-    entries.push([key, value]);
-  });
-  return entries;
-};
-var mergeHeaders = (...headers) => {
-  const mergedHeaders = new Headers();
-  for (const header of headers) {
-    if (!header) {
-      continue;
-    }
-    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
-    for (const [key, value] of iterator) {
-      if (value === null) {
-        mergedHeaders.delete(key);
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v);
-        }
-      } else if (value !== void 0) {
-        mergedHeaders.set(
-          key,
-          typeof value === "object" ? JSON.stringify(value) : value
-        );
-      }
-    }
-  }
-  return mergedHeaders;
-};
-var Interceptors = class {
-  fns = [];
-  clear() {
-    this.fns = [];
-  }
-  eject(id) {
-    const index = this.getInterceptorIndex(id);
-    if (this.fns[index]) {
-      this.fns[index] = null;
-    }
-  }
-  exists(id) {
-    const index = this.getInterceptorIndex(id);
-    return Boolean(this.fns[index]);
-  }
-  getInterceptorIndex(id) {
-    if (typeof id === "number") {
-      return this.fns[id] ? id : -1;
-    }
-    return this.fns.indexOf(id);
-  }
-  update(id, fn) {
-    const index = this.getInterceptorIndex(id);
-    if (this.fns[index]) {
-      this.fns[index] = fn;
-      return id;
-    }
-    return false;
-  }
-  use(fn) {
-    this.fns.push(fn);
-    return this.fns.length - 1;
-  }
-};
-var createInterceptors = () => ({
-  error: new Interceptors(),
-  request: new Interceptors(),
-  response: new Interceptors()
-});
-var defaultQuerySerializer = createQuerySerializer({
-  allowReserved: false,
-  array: {
-    explode: true,
-    style: "form"
-  },
-  object: {
-    explode: true,
-    style: "deepObject"
-  }
-});
-var defaultHeaders = {
-  "Content-Type": "application/json"
-};
-var createConfig = (override = {}) => ({
-  ...jsonBodySerializer,
-  headers: defaultHeaders,
-  parseAs: "auto",
-  querySerializer: defaultQuerySerializer,
-  ...override
-});
-
-// src/generated/client/client.gen.ts
-var createClient = (config = {}) => {
-  let _config = mergeConfigs(createConfig(), config);
-  const getConfig = () => ({ ..._config });
-  const setConfig = (config2) => {
-    _config = mergeConfigs(_config, config2);
-    return getConfig();
-  };
-  const interceptors = createInterceptors();
-  const beforeRequest = async (options) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
-      serializedBody: void 0
-    };
-    if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security
-      });
-    }
-    if (opts.requestValidator) {
-      await opts.requestValidator(opts);
-    }
-    if (opts.body !== void 0 && opts.bodySerializer) {
-      opts.serializedBody = opts.bodySerializer(opts.body);
-    }
-    if (opts.body === void 0 || opts.serializedBody === "") {
-      opts.headers.delete("Content-Type");
-    }
-    const resolvedOpts = opts;
-    const url = buildUrl(resolvedOpts);
-    return { opts: resolvedOpts, url };
-  };
-  const request = async (options) => {
-    const throwOnError = options.throwOnError ?? _config.throwOnError;
-    const responseStyle = options.responseStyle ?? _config.responseStyle;
-    let request2;
-    let response;
-    try {
-      const { opts, url } = await beforeRequest(options);
-      const requestInit = {
-        redirect: "follow",
-        ...opts,
-        body: getValidRequestBody(opts)
-      };
-      request2 = new Request(url, requestInit);
-      for (const fn of interceptors.request.fns) {
-        if (fn) {
-          request2 = await fn(request2, opts);
-        }
-      }
-      const _fetch = opts.fetch;
-      response = await _fetch(request2);
-      for (const fn of interceptors.response.fns) {
-        if (fn) {
-          response = await fn(response, request2, opts);
-        }
-      }
-      const result = {
-        request: request2,
-        response
-      };
-      if (response.ok) {
-        const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
-        if (response.status === 204 || response.headers.get("Content-Length") === "0") {
-          let emptyData;
-          switch (parseAs) {
-            case "arrayBuffer":
-            case "blob":
-            case "text":
-              emptyData = await response[parseAs]();
-              break;
-            case "formData":
-              emptyData = new FormData();
-              break;
-            case "stream":
-              emptyData = response.body;
-              break;
-            case "json":
-            default:
-              emptyData = {};
-              break;
-          }
-          return opts.responseStyle === "data" ? emptyData : {
-            data: emptyData,
-            ...result
-          };
-        }
-        let data;
-        switch (parseAs) {
-          case "arrayBuffer":
-          case "blob":
-          case "formData":
-          case "text":
-            data = await response[parseAs]();
-            break;
-          case "json": {
-            const text = await response.text();
-            data = text ? JSON.parse(text) : {};
-            break;
-          }
-          case "stream":
-            return opts.responseStyle === "data" ? response.body : {
-              data: response.body,
-              ...result
-            };
-        }
-        if (parseAs === "json") {
-          if (opts.responseValidator) {
-            await opts.responseValidator(data);
-          }
-          if (opts.responseTransformer) {
-            data = await opts.responseTransformer(data);
-          }
-        }
-        return opts.responseStyle === "data" ? data : {
-          data,
-          ...result
-        };
-      }
-      const textError = await response.text();
-      let jsonError;
-      try {
-        jsonError = JSON.parse(textError);
-      } catch {
-      }
-      throw jsonError ?? textError;
-    } catch (error) {
-      let finalError = error;
-      for (const fn of interceptors.error.fns) {
-        if (fn) {
-          finalError = await fn(
-            finalError,
-            response,
-            request2,
-            options
-          );
-        }
-      }
-      finalError = finalError || {};
-      if (throwOnError) {
-        throw finalError;
-      }
-      return responseStyle === "data" ? void 0 : {
-        error: finalError,
-        request: request2,
-        response
-      };
-    }
-  };
-  const makeMethodFn = (method) => (options) => request({ ...options, method });
-  const makeSseFn = (method) => async (options) => {
-    const { opts, url } = await beforeRequest(options);
-    return createSseClient({
-      ...opts,
-      body: opts.body,
-      method,
-      onRequest: async (url2, init) => {
-        let request2 = new Request(url2, init);
-        for (const fn of interceptors.request.fns) {
-          if (fn) {
-            request2 = await fn(request2, opts);
-          }
-        }
-        return request2;
-      },
-      serializedBody: getValidRequestBody(opts),
-      url
-    });
-  };
-  const _buildUrl = (options) => buildUrl({ ..._config, ...options });
-  return {
-    buildUrl: _buildUrl,
-    connect: makeMethodFn("CONNECT"),
-    delete: makeMethodFn("DELETE"),
-    get: makeMethodFn("GET"),
-    getConfig,
-    head: makeMethodFn("HEAD"),
-    interceptors,
-    options: makeMethodFn("OPTIONS"),
-    patch: makeMethodFn("PATCH"),
-    post: makeMethodFn("POST"),
-    put: makeMethodFn("PUT"),
-    request,
-    setConfig,
-    sse: {
-      connect: makeSseFn("CONNECT"),
-      delete: makeSseFn("DELETE"),
-      get: makeSseFn("GET"),
-      head: makeSseFn("HEAD"),
-      options: makeSseFn("OPTIONS"),
-      patch: makeSseFn("PATCH"),
-      post: makeSseFn("POST"),
-      put: makeSseFn("PUT"),
-      trace: makeSseFn("TRACE")
-    },
-    trace: makeMethodFn("TRACE")
-  };
-};
-
-// src/region.ts
-var REGION_PATTERN = /^[a-z]{2}[0-9]+$/;
-function regionFromApiKey(apiKey) {
-  const [prefix, region, token] = apiKey.split("_");
-  if (prefix !== "bk" || !region || !token) return void 0;
-  return REGION_PATTERN.test(region) ? region : void 0;
-}
-function baseUrlForRegion(region) {
-  return `https://${region}.platform.bird.com`;
-}
-
-// src/errors.ts
-var BirdError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BirdError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdConnectionError = class extends BirdError {
-  constructor(message) {
-    super(message);
-    this.name = "BirdConnectionError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdTimeoutError = class extends BirdError {
-  timeoutMs;
-  constructor(message, timeoutMs) {
-    super(message);
-    this.name = "BirdTimeoutError";
-    this.timeoutMs = timeoutMs;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdWebhookVerificationError = class extends BirdError {
-  constructor(message) {
-    super(message);
-    this.name = "BirdWebhookVerificationError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdAPIError = class extends BirdError {
-  statusCode;
-  code;
-  type;
-  errorName;
-  docUrl;
-  requestId;
-  param;
-  vendorCode;
-  remediation;
-  next;
-  constructor(fields) {
-    super(fields.message);
-    this.name = "BirdAPIError";
-    this.statusCode = fields.statusCode;
-    this.code = fields.code;
-    this.type = fields.type;
-    this.errorName = fields.errorName;
-    this.docUrl = fields.docUrl;
-    this.requestId = fields.requestId;
-    this.param = fields.param;
-    this.vendorCode = fields.vendorCode;
-    this.remediation = fields.remediation;
-    this.next = fields.next;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdAuthError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdAuthError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdPermissionError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdPermissionError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdNotFoundError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdNotFoundError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdConflictError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdConflictError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdBadRequestError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdBadRequestError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdBillingError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdBillingError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdPreconditionError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdPreconditionError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdPayloadTooLargeError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdPayloadTooLargeError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdInternalError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdInternalError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdNotImplementedError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdNotImplementedError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdMisdirectedError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdMisdirectedError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdServiceUnavailableError = class extends BirdAPIError {
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdServiceUnavailableError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdValidationError = class extends BirdAPIError {
-  details;
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdValidationError";
-    this.details = fields.details;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var BirdRateLimitError = class extends BirdAPIError {
-  retryAfter;
-  constructor(fields) {
-    super(fields);
-    this.name = "BirdRateLimitError";
-    this.retryAfter = fields.retryAfter;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-function parseRetryAfter(headers) {
-  const header = headers?.get("Retry-After");
-  if (!header) return void 0;
-  const seconds = Number(header);
-  const value = Number.isFinite(seconds) ? seconds : (Date.parse(header) - Date.now()) / 1e3;
-  return Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
-}
-function inferType(status) {
-  switch (status) {
-    case 400:
-      return "bad_request_error";
-    case 401:
-      return "auth_error";
-    case 402:
-      return "billing_error";
-    case 403:
-      return "permission_error";
-    case 404:
-      return "not_found_error";
-    case 409:
-      return "conflict_error";
-    case 412:
-    case 428:
-      return "precondition_error";
-    case 413:
-      return "payload_too_large_error";
-    case 421:
-      return "misdirected_error";
-    case 422:
-      return "validation_error";
-    case 429:
-      return "rate_limit_error";
-    case 501:
-      return "not_implemented_error";
-    case 503:
-      return "service_unavailable_error";
-    default:
-      return status >= 500 ? "internal_error" : "bad_request_error";
-  }
-}
-function mapResponseToError(status, body, headers) {
-  const raw = body ?? {};
-  const b = raw.error ?? raw ?? {};
-  const fields = {
-    statusCode: status,
-    code: b.code ?? "unknown",
-    type: b.type ?? inferType(status),
-    errorName: b.name ?? "",
-    message: b.message ?? `Request failed with status ${status}`,
-    docUrl: b.doc_url ?? "",
-    requestId: b.request_id ?? headers?.get("X-Request-Id") ?? "",
-    param: b.param,
-    vendorCode: b.vendor_code,
-    remediation: b.remediation,
-    next: b.next ?? []
-    // normalize a null/absent wire `next` to [] so callers can always iterate
-  };
-  switch (fields.type) {
-    case "auth_error":
-      return new BirdAuthError(fields);
-    case "permission_error":
-      return new BirdPermissionError(fields);
-    case "not_found_error":
-      return new BirdNotFoundError(fields);
-    case "conflict_error":
-      return new BirdConflictError(fields);
-    case "bad_request_error":
-      return new BirdBadRequestError(fields);
-    case "billing_error":
-      return new BirdBillingError(fields);
-    case "precondition_error":
-      return new BirdPreconditionError(fields);
-    case "payload_too_large_error":
-      return new BirdPayloadTooLargeError(fields);
-    case "internal_error":
-      return new BirdInternalError(fields);
-    case "not_implemented_error":
-      return new BirdNotImplementedError(fields);
-    case "misdirected_error":
-      return new BirdMisdirectedError(fields);
-    case "service_unavailable_error":
-      return new BirdServiceUnavailableError(fields);
-    case "rate_limit_error":
-      return new BirdRateLimitError({
-        ...fields,
-        retryAfter: parseRetryAfter(headers)
-      });
-    case "validation_error":
-      return new BirdValidationError({ ...fields, details: b.details ?? [] });
-    default:
-      return new BirdAPIError(fields);
-  }
-}
-
-// src/core/http.ts
-var BACKOFF_BASE_MS = 500;
-var BACKOFF_CAP_MS = 8e3;
-var RETRY_AFTER_CAP_MS = 6e4;
-var BirdHTTPClient = class {
-  constructor(defaults) {
-    this.defaults = defaults;
-  }
-  defaults;
-  /**
-   * Run a generated hey-api SDK call through the request lifecycle.
-   *
-   * @param call  Invokes the SDK function; receives the per-attempt signal and
-   *              the idempotency key to set as a header.
-   * @returns the parsed body plus transport metadata.
-   * @throws  a `BirdError` subclass on terminal failure; the native
-   *          `AbortError` if the caller's signal aborts.
-   */
-  async request(call, options) {
-    const maxRetries = options.maxRetries ?? this.defaults.maxRetries;
-    const timeout = options.timeout ?? this.defaults.timeout;
-    const idempotencyKey = options.idempotencyKey ?? (isMutation(options.method) ? crypto.randomUUID() : void 0);
-    for (let attempt = 0; ; attempt++) {
-      throwIfAborted(options.signal);
-      const retryOrThrow = async (terminal) => {
-        if (attempt >= maxRetries) throw terminal();
-        await sleep(backoffDelay(attempt), options.signal);
-      };
-      const timeoutSignal = AbortSignal.timeout(timeout);
-      const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
-      let outcome;
-      try {
-        outcome = await call({ signal, idempotencyKey });
-      } catch (err) {
-        throwIfAborted(options.signal);
-        await retryOrThrow(
-          () => timeoutSignal.aborted ? new BirdTimeoutError(`Request timed out after ${timeout}ms`, timeout) : new BirdConnectionError(errorMessage(err))
-        );
-        continue;
-      }
-      const res = outcome.response;
-      if (!res) {
-        await retryOrThrow(() => new BirdConnectionError("No response received from the server"));
-        continue;
-      }
-      if (res.ok) {
-        return { data: outcome.data, response: toBirdResponse(res) };
-      }
-      if (!isRetryableStatus(res.status) || attempt >= maxRetries) {
-        throw mapResponseToError(res.status, outcome.error, res.headers);
-      }
-      await sleep(retryDelay(attempt, res.headers), options.signal);
-    }
-  }
-};
-function isMutation(method) {
-  return ["POST", "PATCH", "DELETE"].includes(method.toUpperCase());
-}
-function isRetryableStatus(status) {
-  return [408, 429, 500, 502, 503, 504].includes(status);
-}
-function backoffDelay(attempt) {
-  const ceiling = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** attempt);
-  return Math.random() * ceiling;
-}
-function retryDelay(attempt, headers) {
-  const seconds = parseRetryAfter(headers);
-  return seconds === void 0 ? backoffDelay(attempt) : Math.min(seconds * 1e3, RETRY_AFTER_CAP_MS);
-}
-function toBirdResponse(res) {
-  return {
-    status: res.status,
-    headers: res.headers,
-    requestId: res.headers.get("X-Request-Id") ?? ""
-  };
-}
-function abortReason(signal) {
-  return signal?.reason ?? new DOMException("Aborted", "AbortError");
-}
-function throwIfAborted(signal) {
-  if (signal?.aborted) throw abortReason(signal);
-}
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(abortReason(signal));
-      return;
-    }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(abortReason(signal));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function errorMessage(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
-}
-
-// src/core/result.ts
-function basePromise(inner) {
-  const promise = inner.then((r) => r.data);
-  void promise.catch(() => {
-  });
-  promise.withResponse = () => inner;
-  promise.safe = () => toSafe(inner);
-  return promise;
-}
-function apiPromise(inner) {
-  return basePromise(inner);
-}
-function paginate(fetchPage) {
-  const first = fetchPage();
-  const promise = basePromise(first);
-  promise[Symbol.asyncIterator] = async function* () {
-    let result = await first;
-    for (; ; ) {
-      for (const item of result.data.data) yield item;
-      if (result.data.next_cursor == null) return;
-      result = await fetchPage(result.data.next_cursor);
-    }
-  };
-  return promise;
-}
-function toSafe(inner) {
-  return inner.then(
-    ({ data, response }) => ({ data, error: null, response }),
-    (error) => {
-      if (error instanceof BirdError) return { data: null, error, response: null };
-      throw error;
-    }
-  );
-}
-
-// src/generated/client.gen.ts
-var client = createClient(createConfig());
-
-// src/generated/sdk.gen.ts
-var listEmailMessages = (options) => (options?.client ?? client).get({
-  security: [
-    { scheme: "bearer", type: "http" },
-    {
-      in: "cookie",
-      name: "bird_session",
-      type: "apiKey"
-    }
-  ],
-  url: "/v1/email/messages",
-  ...options
-});
-var createEmailMessage = (options) => (options.client ?? client).post({
-  security: [
-    { scheme: "bearer", type: "http" },
-    {
-      in: "cookie",
-      name: "bird_session",
-      type: "apiKey"
-    }
-  ],
-  url: "/v1/email/messages",
-  ...options,
-  headers: {
-    "Content-Type": "application/json",
-    ...options.headers
-  }
-});
-var createEmailMessageBatch = (options) => (options.client ?? client).post({
-  security: [
-    { scheme: "bearer", type: "http" },
-    {
-      in: "cookie",
-      name: "bird_session",
-      type: "apiKey"
-    }
-  ],
-  url: "/v1/email/batches",
-  ...options,
-  headers: {
-    "Content-Type": "application/json",
-    ...options.headers
-  }
-});
-var getEmailMessage = (options) => (options.client ?? client).get({
-  security: [
-    { scheme: "bearer", type: "http" },
-    {
-      in: "cookie",
-      name: "bird_session",
-      type: "apiKey"
-    }
-  ],
-  url: "/v1/email/messages/{message_id}",
-  ...options
-});
-
-// src/resources/base.ts
-var Resource = class {
-  constructor(core, client2) {
-    this.core = core;
-    this.client = client2;
-  }
-  core;
-  client;
-  /** Run a single typed call through the lifecycle. */
-  call(method, options, invoke) {
-    return apiPromise(
-      this.core.request((ctx) => invoke(callContext(ctx, options)), lifecycle(method, options))
-    );
-  }
-  /** Run a cursor-paginated list through the lifecycle (each page retried independently). */
-  paginated(method, options, invoke) {
-    return paginate(
-      (cursor) => this.core.request(
-        (ctx) => invoke(callContext(ctx, options), cursor),
-        lifecycle(method, options)
-      )
-    );
-  }
-};
-function callContext(ctx, options) {
-  return { signal: ctx.signal, headers: mergeHeaders2(ctx.idempotencyKey, options?.headers) };
-}
-function lifecycle(method, options) {
-  return {
-    method,
-    idempotencyKey: options?.idempotencyKey,
-    signal: options?.signal,
-    timeout: options?.timeout,
-    maxRetries: options?.maxRetries
-  };
-}
-function mergeHeaders2(idempotencyKey, extra) {
-  return {
-    ...extra,
-    ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
-  };
-}
-
-// src/resources/email.ts
-var EmailResource = class extends Resource {
-  #defaults;
-  constructor(core, client2, defaults) {
-    super(core, client2);
-    this.#defaults = defaults;
-  }
-  /**
-   * Send an email message. Resolves once the message is accepted for delivery
-   * (the API's 202). Throws on failure — a 422 (unverified sender, all
-   * recipients suppressed, validation) is a `BirdValidationError`. Fields set as
-   * channel defaults may be omitted (per-send value wins).
-   *
-   * @example Send a message
-   * const msg = await bird.email.send({
-   *   from: { email: "onboarding@messagebird.dev", name: "Bird" },
-   *   to: ["delivered@messagebird.dev"],
-   *   subject: "Hello from Bird",
-   *   html: "<p>My first Bird email.</p>",
-   * });
-   * console.log(msg.id, msg.status); // "em_…", "accepted"
-   *
-   * @example A richer send — cc/bcc, reply-to, tags, metadata, click-tracking off, and an idempotency key (safe to retry; the server dedupes)
-   * await bird.email.send(
-   *   {
-   *     from: "hello@acme.com",
-   *     to: ["a@example.com", "b@example.com"],
-   *     cc: ["manager@example.com"],
-   *     reply_to: ["support@acme.com"],
-   *     subject: "Your March invoice",
-   *     html: "<p>Attached.</p>",
-   *     tags: [{ name: "category", value: "billing" }],
-   *     metadata: { invoice_id: "inv_123" },
-   *     track_clicks: false,
-   *   },
-   *   { idempotencyKey: "invoice-march/cust_1" },
-   * );
-   *
-   * @example Branch on the typed error hierarchy
-   * import { BirdRateLimitError, BirdValidationError, BirdAPIError } from "@messagebird/sdk";
-   *
-   * try {
-   *   await bird.email.send({
-   *     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-   *     to: ["delivered@messagebird.dev"],
-   *     subject: "Hello from Bird",
-   *     html: "<p>My first Bird email.</p>",
-   *   });
-   * } catch (err) {
-   *   if (err instanceof BirdRateLimitError) console.log(`rate limited — retry in ${err.retryAfter}s`);
-   *   else if (err instanceof BirdValidationError) console.error(err.details);
-   *   else if (err instanceof BirdAPIError) console.error(err.code, err.requestId);
-   *   else throw err;
-   * }
-   *
-   * @example Errors as values with `.safe()`
-   * const { data, error } = await bird.email
-   *   .send({
-   *     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-   *     to: ["delivered@messagebird.dev"],
-   *     subject: "Hello from Bird",
-   *     html: "<p>My first Bird email.</p>",
-   *   })
-   *   .safe();
-   * if (error) console.error(error.message);
-   * else console.log(data.id);
-   */
-  send(params, options) {
-    const body = { ...this.#defaults, ...params };
-    return this.call(
-      "POST",
-      options,
-      ({ signal, headers }) => createEmailMessage({ client: this.client, body, headers, signal })
-    );
-  }
-  /**
-   * Send a batch of up to 100 independent email messages in one request. The
-   * batch is validated as a unit — if any item fails validation (unverified
-   * sender, all recipients suppressed, field-level errors) the whole batch is
-   * rejected with a `BirdValidationError` and nothing is queued. Resolves with
-   * one accepted item per submitted message, in submission order, once the batch
-   * is accepted (the API's 202). Channel defaults are applied per item.
-   *
-   * @example Send a batch of messages
-   * const batch = await bird.email.sendBatch([
-   *   {
-   *     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-   *     to: ["alice@example.com"],
-   *     subject: "Your receipt",
-   *     html: "<p>Thanks, Alice.</p>",
-   *   },
-   *   {
-   *     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-   *     to: ["bob@example.com"],
-   *     subject: "Your receipt",
-   *     html: "<p>Thanks, Bob.</p>",
-   *   },
-   * ]);
-   * for (const item of batch.data) console.log(item.id, item.status);
-   */
-  sendBatch(params, options) {
-    const body = params.map((item) => ({
-      ...this.#defaults,
-      ...item
-    }));
-    return this.call(
-      "POST",
-      options,
-      ({ signal, headers }) => createEmailMessageBatch({ client: this.client, body, headers, signal })
-    );
-  }
-  /**
-   * Fetch a message with aggregate delivery status.
-   *
-   * @example
-   * const msg = await bird.email.get("em_abc123");
-   * msg.status; // "accepted" | "processed" | "delivered" | "bounced" | …
-   * msg.delivered_count;
-   * msg.bounced_count;
-   */
-  get(messageId, options) {
-    return this.call(
-      "GET",
-      options,
-      ({ signal, headers }) => getEmailMessage({
-        client: this.client,
-        path: { message_id: messageId },
-        headers,
-        signal
-      })
-    );
-  }
-  /**
-   * List messages, newest first. `await` resolves the first page; `for await`
-   * walks every message across all pages.
-   *
-   * @example Iterate every message, or take one page
-   * for await (const message of bird.email.list({ status: "bounced" })) {
-   *   console.log(message.id);
-   * }
-   * const page = await bird.email.list({ limit: 50 }); // page.data, page.next_cursor
-   */
-  list(query, options) {
-    return this.paginated(
-      "GET",
-      options,
-      ({ signal, headers }, cursor) => listEmailMessages({
-        client: this.client,
-        query: { ...query, starting_after: cursor ?? query?.starting_after },
-        headers,
-        signal
-      })
-    );
-  }
-};
-var WebhooksResource = class {
-  #secret;
-  constructor(config) {
-    this.#secret = config?.secret;
-  }
-  /**
-   * Verify a webhook delivery and return the typed event.
-   *
-   * **Pass the raw request body**, exactly as received — do NOT parse it first.
-   * The Standard Webhooks signature is computed over the raw bytes, so parsing
-   * and re-serializing before verifying is the classic webhook bug.
-   *
-   * The secret comes from `webhooks.secret` on the client; pass `{ secret }` to
-   * override per call. Throws {@link BirdWebhookVerificationError} on a bad
-   * signature, a stale timestamp, or missing/malformed headers. Unknown event
-   * types are returned as-is (handle them in a `default` case) so a newer server
-   * event can't break an older SDK.
-   *
-   * @example One call verifies the signature and returns the typed event
-   * // Pass the RAW request body; set the secret via new BirdClient({ webhooks: { secret } }).
-   * const event = bird.webhooks.unwrap(rawBody, headers);
-   * console.log(event.type); // discriminated union — narrow on event.type
-   *
-   * @example Verify and dispatch — pass the raw request body, never the parsed JSON
-   * // new BirdClient({ apiKey, webhooks: { secret } })
-   * try {
-   *   const event = bird.webhooks.unwrap(rawBody, req.headers);
-   *   switch (event.type) {
-   *     case "email.delivered":
-   *       markDelivered(event.email_id, event.recipient); // narrowed; fields are flat
-   *       break;
-   *     case "email.bounced":
-   *     case "email.complained":
-   *       suppress(event.recipient);
-   *       break;
-   *     default: // unknown future event types — an older SDK won't break on a new one
-   *   }
-   * } catch (err) {
-   *   if (err instanceof BirdWebhookVerificationError) {
-   *     // reject with 400 — bad signature, stale timestamp, or missing/malformed headers
-   *   } else throw err;
-   * }
-   */
-  unwrap(payload, headers, options) {
-    const secret = options?.secret ?? this.#secret;
-    if (!secret) {
-      throw new Error(
-        "No webhook secret. Set `webhooks: { secret }` on the client, or pass `{ secret }` to unwrap."
-      );
-    }
-    const wh = new Webhook(secret);
-    let verified;
-    try {
-      verified = wh.verify(payload, toHeaderRecord(headers));
-    } catch (err) {
-      throw new BirdWebhookVerificationError(
-        err instanceof Error ? err.message : "Webhook signature verification failed"
-      );
-    }
-    return verified;
-  }
-};
-function toHeaderRecord(headers) {
-  return headers instanceof Headers ? Object.fromEntries(headers) : headers;
-}
-
-// src/client.ts
-var DEFAULT_TIMEOUT_MS = 6e4;
-var DEFAULT_MAX_RETRIES = 2;
-function resolveBaseUrl(options) {
-  if (options.baseUrl) return options.baseUrl;
-  const region = options.region ?? regionFromApiKey(options.apiKey);
-  if (!region) {
-    throw new Error(
-      "Unable to determine region: API key is not in the expected bk_{region}_{token} format. Pass an explicit `region` or `baseUrl`."
-    );
-  }
-  return baseUrlForRegion(region);
-}
-function resolveRawRequestUrl(baseUrl, path) {
-  if (!path.startsWith("/") || path.startsWith("//")) {
-    throw new TypeError(
-      "bird.request path must be an absolute path starting with a single `/`"
-    );
-  }
-  const base = new URL(baseUrl);
-  const url = new URL(baseUrl + path);
-  if (url.origin !== base.origin) {
-    throw new TypeError(
-      "bird.request path must stay on the configured Bird API origin"
-    );
-  }
-  return url;
-}
-var BirdClient = class {
-  core;
-  // The generated hey-api client, configured with this instance's base URL,
-  // auth, and fetch. Resources call the generated SDK functions through it.
-  #client;
-  #baseUrl;
-  #fetch;
-  #headers;
-  /** The email channel — `bird.email.send(...)`, `.get(...)`, `.list(...)`. */
-  email;
-  /** Webhooks — `bird.webhooks.unwrap(payload, headers)` verifies an inbound delivery. */
-  webhooks;
-  constructor(options) {
-    const opts = options;
-    this.#baseUrl = resolveBaseUrl(opts);
-    this.#fetch = opts.fetch ?? fetch;
-    this.#headers = {
-      ...opts.defaultHeaders,
-      Authorization: `Bearer ${opts.apiKey}`,
-      "User-Agent": `bird-sdk-js/${"0.2.2"}`,
-      // Bird-* client-identity headers (ADR-0074): the API attributes the SDK
-      // surface from these, not the User-Agent. Edge-safe, so no os/arch/runtime
-      // (those need Node globals this SDK must not touch); surface + version only.
-      "Bird-Surface": "sdk-js",
-      "Bird-Version": "0.2.2"
-    };
-    this.#client = createClient(
-      createConfig({
-        baseUrl: this.#baseUrl,
-        fetch: this.#fetch,
-        headers: this.#headers
-      })
-    );
-    this.core = new BirdHTTPClient({
-      timeout: opts.timeout ?? DEFAULT_TIMEOUT_MS,
-      maxRetries: opts.maxRetries ?? DEFAULT_MAX_RETRIES
-    });
-    this.email = new EmailResource(
-      this.core,
-      this.#client,
-      opts.email
-    );
-    this.webhooks = new WebhooksResource(opts.webhooks);
-  }
-  /**
-   * Escape hatch for endpoints the typed resources don't cover. Runs the full
-   * lifecycle (auth, retries, idempotency, error mapping); you supply the
-   * response type. Prefer a typed resource method where one exists.
-   *
-   * @throws {TypeError} if `req.path` does not start with exactly one `/` or
-   *   resolves to a different origin than the configured Bird API base URL.
-   *
-   * @example Reach an endpoint outside the curated surface — you supply the response type
-   * type Suppressions = { data: Array<{ recipient: string }> };
-   * const suppressions = await bird.request<Suppressions>({ method: "GET", path: "/v1/email/suppressions" });
-   * console.log(suppressions.data.length);
-   */
-  request(req, options) {
-    const url = resolveRawRequestUrl(this.#baseUrl, req.path);
-    return apiPromise(
-      this.core.request(
-        (ctx) => this.#raw(url, req, ctx, options?.headers),
-        {
-          method: req.method,
-          idempotencyKey: options?.idempotencyKey,
-          signal: options?.signal,
-          timeout: options?.timeout,
-          maxRetries: options?.maxRetries
-        }
-      )
-    );
-  }
-  async #raw(url, req, ctx, extraHeaders) {
-    url = new URL(url);
-    if (req.query) {
-      for (const [key, value] of Object.entries(req.query)) {
-        if (value !== void 0) url.searchParams.set(key, String(value));
-      }
-    }
-    const headers = {
-      ...extraHeaders,
-      ...this.#headers
-    };
-    if (ctx.idempotencyKey) headers["Idempotency-Key"] = ctx.idempotencyKey;
-    if (req.body !== void 0) headers["Content-Type"] = "application/json";
-    const response = await this.#fetch(url, {
-      method: req.method,
-      headers,
-      body: req.body !== void 0 ? JSON.stringify(req.body) : void 0,
-      signal: ctx.signal
-    });
-    if (response.ok) {
-      const data = response.status === 204 ? void 0 : await response.json().catch(() => void 0);
-      return { data, response };
-    }
-    const error = await response.clone().json().catch(() => void 0);
-    return { error, response };
-  }
-};
-
-// src/event-types.gen.ts
-var WebhookEventType = {
-  DomainFailed: "domain.failed",
-  DomainVerified: "domain.verified",
-  EmailAccepted: "email.accepted",
-  EmailBounced: "email.bounced",
-  EmailCanceled: "email.canceled",
-  EmailClicked: "email.clicked",
-  EmailComplained: "email.complained",
-  EmailDeferred: "email.deferred",
-  EmailDelivered: "email.delivered",
-  EmailListUnsubscribed: "email.list_unsubscribed",
-  EmailOpened: "email.opened",
-  EmailOutOfBandBounce: "email.out_of_band_bounce",
-  EmailProcessed: "email.processed",
-  EmailReceived: "email.received",
-  EmailRejected: "email.rejected",
-  EmailScheduled: "email.scheduled",
-  EmailSuppressionCreated: "email_suppression.created",
-  EmailUnsubscribed: "email.unsubscribed",
-  SmsAccepted: "sms.accepted",
-  SmsDelivered: "sms.delivered",
-  SmsExpired: "sms.expired",
-  SmsFailed: "sms.failed",
-  SmsRejected: "sms.rejected",
-  SmsSent: "sms.sent",
-  SmsUndelivered: "sms.undelivered"
-};
-
-export { BirdAPIError, BirdAuthError, BirdBadRequestError, BirdBillingError, BirdClient, BirdConflictError, BirdConnectionError, BirdError, BirdInternalError, BirdMisdirectedError, BirdNotFoundError, BirdNotImplementedError, BirdPayloadTooLargeError, BirdPermissionError, BirdPreconditionError, BirdRateLimitError, BirdServiceUnavailableError, BirdTimeoutError, BirdValidationError, BirdWebhookVerificationError, WebhookEventType, baseUrlForRegion, regionFromApiKey };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map