increase 0.1.0

package/dist/cjs/core.js

@@ -0,0 +1,978 @@
+'use strict';
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+var __classPrivateFieldSet =
+  (this && this.__classPrivateFieldSet) ||
+  function (receiver, state, value, kind, f) {
+    if (kind === 'm') throw new TypeError('Private method is not writable');
+    if (kind === 'a' && !f) throw new TypeError('Private accessor was defined without a setter');
+    if (typeof state === 'function' ? receiver !== state || !f : !state.has(receiver))
+      throw new TypeError('Cannot write private member to an object whose class did not declare it');
+    return (
+      kind === 'a' ? f.call(receiver, value)
+      : f ? (f.value = value)
+      : state.set(receiver, value),
+      value
+    );
+  };
+var __classPrivateFieldGet =
+  (this && this.__classPrivateFieldGet) ||
+  function (receiver, state, kind, f) {
+    if (kind === 'a' && !f) throw new TypeError('Private accessor was defined without a getter');
+    if (typeof state === 'function' ? receiver !== state || !f : !state.has(receiver))
+      throw new TypeError('Cannot read private member from an object whose class did not declare it');
+    return (
+      kind === 'm' ? f
+      : kind === 'a' ? f.call(receiver)
+      : f ? f.value
+      : state.get(receiver)
+    );
+  };
+var __rest =
+  (this && this.__rest) ||
+  function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === 'function')
+      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+      }
+    return t;
+  };
+var __await =
+  (this && this.__await) ||
+  function (v) {
+    return this instanceof __await ? ((this.v = v), this) : new __await(v);
+  };
+var __asyncGenerator =
+  (this && this.__asyncGenerator) ||
+  function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError('Symbol.asyncIterator is not defined.');
+    var g = generator.apply(thisArg, _arguments || []),
+      i,
+      q = [];
+    return (
+      (i = {}),
+      verb('next'),
+      verb('throw'),
+      verb('return'),
+      (i[Symbol.asyncIterator] = function () {
+        return this;
+      }),
+      i
+    );
+    function verb(n) {
+      if (g[n])
+        i[n] = function (v) {
+          return new Promise(function (a, b) {
+            q.push([n, v, a, b]) > 1 || resume(n, v);
+          });
+        };
+    }
+    function resume(n, v) {
+      try {
+        step(g[n](v));
+      } catch (e) {
+        settle(q[0][3], e);
+      }
+    }
+    function step(r) {
+      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+      resume('next', value);
+    }
+    function reject(value) {
+      resume('throw', value);
+    }
+    function settle(f, v) {
+      if ((f(v), q.shift(), q.length)) resume(q[0][0], q[0][1]);
+    }
+  };
+var __asyncValues =
+  (this && this.__asyncValues) ||
+  function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError('Symbol.asyncIterator is not defined.');
+    var m = o[Symbol.asyncIterator],
+      i;
+    return m ? m.call(o)
+      : ((o = typeof __values === 'function' ? __values(o) : o[Symbol.iterator]()),
+        (i = {}),
+        verb('next'),
+        verb('throw'),
+        verb('return'),
+        (i[Symbol.asyncIterator] = function () {
+          return this;
+        }),
+        i);
+    function verb(n) {
+      i[n] =
+        o[n] &&
+        function (v) {
+          return new Promise(function (resolve, reject) {
+            (v = o[n](v)), settle(resolve, reject, v.done, v.value);
+          });
+        };
+    }
+    function settle(resolve, reject, d, v) {
+      Promise.resolve(v).then(function (v) {
+        resolve({ value: v, done: d });
+      }, reject);
+    }
+  };
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+var _AbstractPage_client;
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getHeader =
+  exports.isHeadersProtocol =
+  exports.hasOwn =
+  exports.isEmptyObj =
+  exports.coerceBoolean =
+  exports.coerceFloat =
+  exports.coerceInteger =
+  exports.ensurePresent =
+  exports.multipartFormRequestOptions =
+  exports.maybeMultipartFormRequestOptions =
+  exports.APIConnectionTimeoutError =
+  exports.APIConnectionError =
+  exports.InternalServerError =
+  exports.RateLimitError =
+  exports.UnprocessableEntityError =
+  exports.ConflictError =
+  exports.NotFoundError =
+  exports.PermissionDeniedError =
+  exports.AuthenticationError =
+  exports.BadRequestError =
+  exports.APIError =
+  exports.isRequestOptions =
+  exports.createResponseHeaders =
+  exports.Stream =
+  exports.PagePromise =
+  exports.AbstractPage =
+  exports.APIResource =
+  exports.APIClient =
+    void 0;
+const qs_1 = __importDefault(require('qs'));
+const formdata_node_1 = require('formdata-node');
+const form_data_encoder_1 = require('form-data-encoder');
+const stream_1 = require('stream');
+const version_1 = require('./version');
+const fetch_polyfill_1 = require('./fetch-polyfill');
+class APIClient {
+  constructor({
+    baseURL,
+    maxRetries = 2,
+    timeout = 60 * 1000, // 60s
+    httpAgent,
+  }) {
+    this.baseURL = baseURL;
+    this.maxRetries = validatePositiveInteger('maxRetries', maxRetries);
+    this.timeout = validatePositiveInteger('timeout', timeout);
+    this.httpAgent = httpAgent;
+    this.fetch = (0, fetch_polyfill_1.getFetch)();
+  }
+  authHeaders() {
+    return {};
+  }
+  /**
+   * Override this to add your own default headers, for example:
+   *
+   *  {
+   *    ...super.defaultHeaders(),
+   *    Authorization: 'Bearer 123',
+   *  }
+   */
+  defaultHeaders() {
+    return Object.assign(
+      Object.assign(
+        { Accept: 'application/json', 'Content-Type': 'application/json', 'User-Agent': this.getUserAgent() },
+        getPlatformHeaders(),
+      ),
+      this.authHeaders(),
+    );
+  }
+  /**
+   * Override this to add your own headers validation:
+   */
+  validateHeaders(headers, customHeaders) {}
+  /**
+   * Override this to add your own qs.stringify options, for example:
+   *
+   *  {
+   *    ...super.qsOptions(),
+   *    strictNullHandling: true,
+   *  }
+   */
+  qsOptions() {
+    return {};
+  }
+  defaultIdempotencyKey() {
+    return `stainless-node-retry-${uuid4()}`;
+  }
+  get(path, opts) {
+    return this.request(Object.assign({ method: 'get', path }, opts));
+  }
+  post(path, opts) {
+    return this.request(Object.assign({ method: 'post', path }, opts));
+  }
+  patch(path, opts) {
+    return this.request(Object.assign({ method: 'patch', path }, opts));
+  }
+  put(path, opts) {
+    return this.request(Object.assign({ method: 'put', path }, opts));
+  }
+  delete(path, opts) {
+    return this.request(Object.assign({ method: 'delete', path }, opts));
+  }
+  getAPIList(path, Page, opts) {
+    return this.requestAPIList(Page, Object.assign({ method: 'get', path }, opts));
+  }
+  buildRequest(options) {
+    var _a, _b, _c;
+    const { method, path, query, headers: headers = {} } = options;
+    const body =
+      options.body instanceof stream_1.Readable ? options.body
+      : options.body ? JSON.stringify(options.body, null, 2)
+      : null;
+    const contentLength = typeof body === 'string' ? body.length.toString() : null;
+    const url = this.buildURL(path, query);
+    const httpAgent = (
+        (_b = (_a = options.httpAgent) !== null && _a !== void 0 ? _a : this.httpAgent) !== null &&
+        _b !== void 0
+      ) ?
+        _b
+      : (0, fetch_polyfill_1.getDefaultAgent)(url);
+    const timeout = (_c = options.timeout) !== null && _c !== void 0 ? _c : this.timeout;
+    validatePositiveInteger('timeout', timeout);
+    if (this.idempotencyHeader && method !== 'get') {
+      if (!options.idempotencyKey) options.idempotencyKey = this.defaultIdempotencyKey();
+      headers[this.idempotencyHeader] = options.idempotencyKey;
+    }
+    const reqHeaders = Object.assign(
+      Object.assign(
+        Object.assign({}, contentLength && { 'Content-Length': contentLength }),
+        this.defaultHeaders(),
+      ),
+      headers,
+    );
+    // Strip any headers being explicitly omitted with null
+    Object.keys(reqHeaders).forEach((key) => reqHeaders[key] === null && delete reqHeaders[key]);
+    const req = Object.assign(
+      Object.assign(Object.assign({ method }, body && { body }), { headers: reqHeaders }),
+      httpAgent && { agent: httpAgent },
+    );
+    this.validateHeaders(reqHeaders, headers);
+    return { req, url, timeout };
+  }
+  request(options, retriesRemaining) {
+    var _a;
+    if (retriesRemaining === void 0) {
+      retriesRemaining = (_a = options.maxRetries) !== null && _a !== void 0 ? _a : this.maxRetries;
+    }
+    return __awaiter(this, void 0, void 0, function* () {
+      const { req, url, timeout } = this.buildRequest(options);
+      this.debug('request', url, options, req.headers);
+      const controller = new AbortController();
+      const response = yield this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+      if (response instanceof Error) {
+        if (retriesRemaining) return this.retryRequest(options, retriesRemaining);
+        if (response.name === 'AbortError') throw new APIConnectionTimeoutError();
+        throw new APIConnectionError({ cause: response });
+      }
+      const responseHeaders = (0, exports.createResponseHeaders)(response.headers);
+      if (!response.ok) {
+        if (retriesRemaining && this.shouldRetry(response)) {
+          return this.retryRequest(options, retriesRemaining, responseHeaders);
+        }
+        const errText = yield response.text().catch(() => 'Unknown');
+        const errJSON = safeJSON(errText);
+        const errMessage = errJSON ? undefined : errText;
+        this.debug('response', response.status, url, responseHeaders, errMessage);
+        const err = APIError.generate(response.status, errJSON, errMessage, responseHeaders);
+        throw err;
+      }
+      if (options.stream) {
+        // TODO: see if any cast can be removed
+        return new Stream(response, controller);
+      }
+      const contentType = response.headers.get('content-type');
+      if (
+        contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/json')
+      ) {
+        const json = yield response.json();
+        if (typeof json === 'object' && json != null) {
+          /** @deprecated – we expect to change this interface in the near future. */
+          Object.defineProperty(json, 'responseHeaders', {
+            enumerable: false,
+            writable: false,
+            value: responseHeaders,
+          });
+        }
+        this.debug('response', response.status, url, responseHeaders, json);
+        return json;
+      }
+      // TODO handle blob, arraybuffer, other content types, etc.
+      const text = response.text();
+      this.debug('response', response.status, url, responseHeaders, text);
+      return text;
+    });
+  }
+  requestAPIList(Page, options) {
+    const requestPromise = this.request(options);
+    return new PagePromise(this, requestPromise, options, Page);
+  }
+  buildURL(path, query) {
+    const url = isAbsoluteURL(path) ? new URL(path) : new URL(this.baseURL + path);
+    if (query) {
+      url.search = qs_1.default.stringify(query, this.qsOptions());
+    }
+    return url.toString();
+  }
+  fetchWithTimeout(url, _a = {}, ms, controller) {
+    var { signal } = _a,
+      options = __rest(_a, ['signal']);
+    return __awaiter(this, void 0, void 0, function* () {
+      if (signal) signal.addEventListener('abort', controller.abort);
+      const timeout = setTimeout(() => controller.abort(), ms);
+      return this.getRequestClient()
+        .fetch(url, Object.assign({ signal: controller.signal }, options))
+        .finally(() => {
+          clearTimeout(timeout);
+        });
+    });
+  }
+  getRequestClient() {
+    return { fetch: this.fetch };
+  }
+  shouldRetry(response) {
+    // Note this is not a standard header.
+    const shouldRetryHeader = response.headers.get('x-should-retry');
+    // If the server explicitly says whether or not to retry, obey.
+    if (shouldRetryHeader === 'true') return true;
+    if (shouldRetryHeader === 'false') return false;
+    // Retry on lock timeouts.
+    if (response.status === 409) return true;
+    // Retry on rate limits.
+    if (response.status === 429) return true;
+    // Retry internal errors.
+    if (response.status >= 500) return true;
+    return false;
+  }
+  retryRequest(options, retriesRemaining, responseHeaders) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      retriesRemaining -= 1;
+      // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+      //
+      // TODO: we may want to handle the case where the header is using the http-date syntax: "Retry-After: <http-date>".
+      // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#syntax for details.
+      const retryAfter = parseInt(
+        (responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders['retry-after']) ||
+          '',
+      );
+      const maxRetries = (_a = options.maxRetries) !== null && _a !== void 0 ? _a : this.maxRetries;
+      const timeout = this.calculateRetryTimeoutSeconds(retriesRemaining, retryAfter, maxRetries) * 1000;
+      yield sleep(timeout);
+      return this.request(options, retriesRemaining);
+    });
+  }
+  calculateRetryTimeoutSeconds(retriesRemaining, retryAfter, maxRetries) {
+    const initialRetryDelay = 0.5;
+    const maxRetryDelay = 2;
+    // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
+    // just do what it says.
+    if (Number.isInteger(retryAfter) && retryAfter <= 60) {
+      return retryAfter;
+    }
+    const numRetries = maxRetries - retriesRemaining;
+    // Apply exponential backoff, but not more than the max.
+    const sleepSeconds = Math.min(initialRetryDelay * Math.pow(numRetries - 1, 2), maxRetryDelay);
+    // Apply some jitter, plus-or-minus half a second.
+    const jitter = Math.random() - 0.5;
+    return sleepSeconds + jitter;
+  }
+  getUserAgent() {
+    return `${this.constructor.name}/JS ${version_1.VERSION}`;
+  }
+  debug(action, ...args) {
+    if (process.env['DEBUG'] === 'true') {
+      console.log(`${this.constructor.name}:DEBUG:${action}`, ...args);
+    }
+  }
+}
+exports.APIClient = APIClient;
+class APIResource {
+  constructor(client) {
+    this.client = client;
+    this.get = client.get.bind(client);
+    this.post = client.post.bind(client);
+    this.patch = client.patch.bind(client);
+    this.put = client.put.bind(client);
+    this.delete = client.delete.bind(client);
+    this.getAPIList = client.getAPIList.bind(client);
+  }
+}
+exports.APIResource = APIResource;
+class AbstractPage {
+  constructor(client, response, options) {
+    _AbstractPage_client.set(this, void 0);
+    __classPrivateFieldSet(this, _AbstractPage_client, client, 'f');
+    this.options = options;
+  }
+  hasNextPage() {
+    const items = this.getPaginatedItems();
+    if (!items.length) return false;
+    return this.nextPageInfo() != null;
+  }
+  getNextPage() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const nextInfo = this.nextPageInfo();
+      if (!nextInfo) {
+        throw new Error(
+          'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
+        );
+      }
+      const nextOptions = Object.assign({}, this.options);
+      if ('params' in nextInfo) {
+        nextOptions.query = Object.assign(Object.assign({}, nextOptions.query), nextInfo.params);
+      } else if ('url' in nextInfo) {
+        const params = [...Object.entries(nextOptions.query || {}), ...nextInfo.url.searchParams.entries()];
+        for (const [key, value] of params) {
+          nextInfo.url.searchParams.set(key, value);
+        }
+        nextOptions.query = undefined;
+        nextOptions.path = nextInfo.url.toString();
+      }
+      return yield __classPrivateFieldGet(this, _AbstractPage_client, 'f').requestAPIList(
+        this.constructor,
+        nextOptions,
+      );
+    });
+  }
+  iterPages() {
+    return __asyncGenerator(this, arguments, function* iterPages_1() {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      let page = this;
+      yield yield __await(page);
+      while (page.hasNextPage()) {
+        page = yield __await(page.getNextPage());
+        yield yield __await(page);
+      }
+    });
+  }
+  [((_AbstractPage_client = new WeakMap()), Symbol.asyncIterator)]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      var _b, e_1, _c, _d;
+      try {
+        for (
+          var _e = true, _f = __asyncValues(this.iterPages()), _g;
+          (_g = yield __await(_f.next())), (_b = _g.done), !_b;
+
+        ) {
+          _d = _g.value;
+          _e = false;
+          try {
+            const page = _d;
+            for (const item of page.getPaginatedItems()) {
+              yield yield __await(item);
+            }
+          } finally {
+            _e = true;
+          }
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+    });
+  }
+}
+exports.AbstractPage = AbstractPage;
+class PagePromise extends Promise {
+  /**
+   * This subclass of Promise will resolve to an instantiated Page once the request completes.
+   */
+  constructor(client, requestPromise, options, Page) {
+    super((resolve, reject) =>
+      requestPromise.then((response) => resolve(new Page(client, response, options))).catch(reject),
+    );
+  }
+  /**
+   * Enable subclassing Promise.
+   * Ref: https://stackoverflow.com/a/60328122
+   */
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      var _b, e_2, _c, _d;
+      const page = yield __await(this);
+      try {
+        for (
+          var _e = true, page_1 = __asyncValues(page), page_1_1;
+          (page_1_1 = yield __await(page_1.next())), (_b = page_1_1.done), !_b;
+
+        ) {
+          _d = page_1_1.value;
+          _e = false;
+          try {
+            const item = _d;
+            yield yield __await(item);
+          } finally {
+            _e = true;
+          }
+        }
+      } catch (e_2_1) {
+        e_2 = { error: e_2_1 };
+      } finally {
+        try {
+          if (!_e && !_b && (_c = page_1.return)) yield __await(_c.call(page_1));
+        } finally {
+          if (e_2) throw e_2.error;
+        }
+      }
+    });
+  }
+}
+exports.PagePromise = PagePromise;
+class Stream {
+  constructor(response, controller) {
+    this.response = response;
+    this.controller = controller;
+    this.responseHeaders = (0, exports.createResponseHeaders)(response.headers);
+  }
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      var _b, e_3, _c, _d;
+      if (!this.response.body) {
+        // TODO: abort?
+        throw new Error(`Attempted to iterate over a response with no body`);
+      }
+      try {
+        for (
+          var _e = true, _f = __asyncValues(this.response.body), _g;
+          (_g = yield __await(_f.next())), (_b = _g.done), !_b;
+
+        ) {
+          _d = _g.value;
+          _e = false;
+          try {
+            const chunk = _d;
+            let text;
+            if (chunk instanceof Buffer) {
+              text = chunk.toString();
+            } else {
+              text = chunk;
+            }
+            if (text.startsWith('data: ')) {
+              text = text.substring(6);
+            }
+            if (text.startsWith('[DONE]')) {
+              break;
+            }
+            yield yield __await(JSON.parse(text));
+          } finally {
+            _e = true;
+          }
+        }
+      } catch (e_3_1) {
+        e_3 = { error: e_3_1 };
+      } finally {
+        try {
+          if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
+        } finally {
+          if (e_3) throw e_3.error;
+        }
+      }
+      this.controller.abort();
+    });
+  }
+}
+exports.Stream = Stream;
+const createResponseHeaders = (headers) => {
+  return new Proxy(Object.fromEntries(headers.entries()), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
+    },
+  });
+};
+exports.createResponseHeaders = createResponseHeaders;
+// This is required so that we can determine if a given object matches the RequestOptions
+// type at runtime. While this requires duplication, it is enforced by the TypeScript
+// compiler such that any missing / extraneous keys will cause an error.
+const requestOptionsKeys = {
+  method: true,
+  path: true,
+  query: true,
+  body: true,
+  headers: true,
+  maxRetries: true,
+  stream: true,
+  timeout: true,
+  httpAgent: true,
+  idempotencyKey: true,
+};
+const isRequestOptions = (obj) => {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    !isEmptyObj(obj) &&
+    Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k))
+  );
+};
+exports.isRequestOptions = isRequestOptions;
+class APIError extends Error {
+  constructor(status, error, message, headers) {
+    super(message || (error === null || error === void 0 ? void 0 : error.message));
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+  static generate(status, error, message, headers) {
+    if (!status) return new APIConnectionError({ cause: castToError(error) });
+    if (status === 400) return new BadRequestError(status, error, message, headers);
+    if (status === 401) return new AuthenticationError(status, error, message, headers);
+    if (status === 403) return new PermissionDeniedError(status, error, message, headers);
+    if (status === 404) return new NotFoundError(status, error, message, headers);
+    if (status === 409) return new ConflictError(status, error, message, headers);
+    if (status === 422) return new UnprocessableEntityError(status, error, message, headers);
+    if (status === 429) return new RateLimitError(status, error, message, headers);
+    if (status >= 500) return new InternalServerError(status, error, message, headers);
+    return new APIError(status, error, message, headers);
+  }
+}
+exports.APIError = APIError;
+class BadRequestError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 400;
+  }
+}
+exports.BadRequestError = BadRequestError;
+class AuthenticationError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 401;
+  }
+}
+exports.AuthenticationError = AuthenticationError;
+class PermissionDeniedError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 403;
+  }
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+class NotFoundError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 404;
+  }
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 409;
+  }
+}
+exports.ConflictError = ConflictError;
+class UnprocessableEntityError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 422;
+  }
+}
+exports.UnprocessableEntityError = UnprocessableEntityError;
+class RateLimitError extends APIError {
+  constructor() {
+    super(...arguments);
+    this.status = 429;
+  }
+}
+exports.RateLimitError = RateLimitError;
+class InternalServerError extends APIError {}
+exports.InternalServerError = InternalServerError;
+class APIConnectionError extends APIError {
+  constructor({ message, cause }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    this.status = undefined;
+    // eslint-disable-next-line
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+exports.APIConnectionError = APIConnectionError;
+class APIConnectionTimeoutError extends APIConnectionError {
+  constructor() {
+    super({ message: 'Request timed out.' });
+  }
+}
+exports.APIConnectionTimeoutError = APIConnectionTimeoutError;
+const getPlatformProperties = () => {
+  if (typeof Deno !== 'undefined' && Deno.build != null) {
+    return {
+      'X-Stainless-Lang': 'js',
+      'X-Stainless-Package-Version': version_1.VERSION,
+      'X-Stainless-OS': normalizePlatform(Deno.build.os),
+      'X-Stainless-Arch': normalizeArch(Deno.build.arch),
+      'X-Stainless-Runtime': 'deno',
+      'X-Stainless-Runtime-Version': Deno.version,
+    };
+  }
+  if (typeof process !== 'undefined') {
+    return {
+      'X-Stainless-Lang': 'js',
+      'X-Stainless-Package-Version': version_1.VERSION,
+      'X-Stainless-OS': normalizePlatform(process.platform),
+      'X-Stainless-Arch': normalizeArch(process.arch),
+      'X-Stainless-Runtime': 'node',
+      'X-Stainless-Runtime-Version': process.version,
+    };
+  }
+  // TODO add support for Cloudflare workers, browsers, etc.
+  return {
+    'X-Stainless-Lang': 'js',
+    'X-Stainless-Package-Version': version_1.VERSION,
+    'X-Stainless-OS': 'Unknown',
+    'X-Stainless-Arch': 'unknown',
+    'X-Stainless-Runtime': 'unknown',
+    'X-Stainless-Runtime-Version': 'unknown',
+  };
+};
+const normalizeArch = (arch) => {
+  // Node docs:
+  // - https://nodejs.org/api/process.html#processarch
+  // Deno docs:
+  // - https://doc.deno.land/deno/stable/~/Deno.build
+  if (arch === 'x32') return 'x32';
+  if (arch === 'x86_64' || arch === 'x64') return 'x64';
+  if (arch === 'arm') return 'arm';
+  if (arch === 'aarch64' || arch === 'arm64') return 'arm64';
+  if (arch) return `other:${arch}`;
+  return 'unknown';
+};
+const normalizePlatform = (platform) => {
+  // Node platforms:
+  // - https://nodejs.org/api/process.html#processplatform
+  // Deno platforms:
+  // - https://doc.deno.land/deno/stable/~/Deno.build
+  // - https://github.com/denoland/deno/issues/14799
+  platform = platform.toLowerCase();
+  // NOTE: this iOS check is untested and may not work
+  // Node does not work natively on IOS, there is a fork at
+  // https://github.com/nodejs-mobile/nodejs-mobile
+  // however it is unknown at the time of writing how to detect if it is running
+  if (platform.includes('ios')) return 'iOS';
+  if (platform === 'android') return 'Android';
+  if (platform === 'darwin') return 'MacOS';
+  if (platform === 'win32') return 'Windows';
+  if (platform === 'freebsd') return 'FreeBSD';
+  if (platform === 'openbsd') return 'OpenBSD';
+  if (platform === 'linux') return 'Linux';
+  if (platform) return `Other:${platform}`;
+  return 'Unknown';
+};
+let _platformHeaders;
+const getPlatformHeaders = () => {
+  return _platformHeaders !== null && _platformHeaders !== void 0 ?
+      _platformHeaders
+    : (_platformHeaders = getPlatformProperties());
+};
+const safeJSON = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};
+// https://stackoverflow.com/a/19709846
+const startsWithSchemeRegexp = new RegExp('^(?:[a-z]+:)?//', 'i');
+const isAbsoluteURL = (url) => {
+  return startsWithSchemeRegexp.test(url);
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const validatePositiveInteger = (name, n) => {
+  if (!Number.isInteger(n)) {
+    throw new Error(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return n;
+};
+const castToError = (err) => {
+  if (err instanceof Error) return err;
+  return new Error(err);
+};
+/**
+ * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value.
+ * Otherwise returns the request as is.
+ */
+const maybeMultipartFormRequestOptions = (opts) => {
+  // TODO: does this add unreasonable overhead in the case where we shouldn't use multipart/form-data?
+  const form = createForm(opts.body);
+  for (const [_, entry] of form.entries()) {
+    const value = entry.valueOf();
+    if (value instanceof formdata_node_1.File || value instanceof formdata_node_1.Blob) {
+      return getMultipartRequestOptions(form, opts);
+    }
+  }
+  return opts;
+};
+exports.maybeMultipartFormRequestOptions = maybeMultipartFormRequestOptions;
+const multipartFormRequestOptions = (opts) => {
+  return getMultipartRequestOptions(createForm(opts.body), opts);
+};
+exports.multipartFormRequestOptions = multipartFormRequestOptions;
+const createForm = (body) => {
+  const form = new formdata_node_1.FormData();
+  Object.entries(body || {}).forEach(([key, value]) => addFormValue(form, key, value));
+  return form;
+};
+const getMultipartRequestOptions = (form, opts) => {
+  const encoder = new form_data_encoder_1.FormDataEncoder(form);
+  return Object.assign(Object.assign({}, opts), {
+    headers: Object.assign(Object.assign(Object.assign({}, opts.headers), encoder.headers), {
+      'Content-Length': encoder.contentLength,
+    }),
+    body: stream_1.Readable.from(encoder),
+  });
+};
+const addFormValue = (form, key, value) => {
+  if (value == null) {
+    throw new TypeError(
+      `null is not a valid form data value, if you want to pass null then you need to use the string 'null'`,
+    );
+  }
+  // TODO: make nested formats configurable
+  if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean' ||
+    value instanceof formdata_node_1.File ||
+    value instanceof formdata_node_1.Blob
+  ) {
+    form.append(key, value);
+  } else if (Array.isArray(value)) {
+    value.forEach((entry) => {
+      addFormValue(form, key + '[]', entry);
+    });
+  } else if (typeof value === 'object') {
+    Object.entries(value).forEach(([name, prop]) => {
+      addFormValue(form, `${key}[${name}]`, prop);
+    });
+  } else {
+    throw new TypeError(
+      `Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`,
+    );
+  }
+};
+const ensurePresent = (value) => {
+  if (value == null) throw new Error(`Expected a value to be given but received ${value} instead.`);
+  return value;
+};
+exports.ensurePresent = ensurePresent;
+const coerceInteger = (value) => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value, 10);
+  throw new Error(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+exports.coerceInteger = coerceInteger;
+const coerceFloat = (value) => {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') return parseFloat(value);
+  throw new Error(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+exports.coerceFloat = coerceFloat;
+const coerceBoolean = (value) => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+exports.coerceBoolean = coerceBoolean;
+// https://stackoverflow.com/a/34491287
+function isEmptyObj(obj) {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+exports.isEmptyObj = isEmptyObj;
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+exports.hasOwn = hasOwn;
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+const uuid4 = () => {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+const isHeadersProtocol = (headers) => {
+  return typeof (headers === null || headers === void 0 ? void 0 : headers.get) === 'function';
+};
+exports.isHeadersProtocol = isHeadersProtocol;
+const getHeader = (headers, key) => {
+  const lowerKey = key.toLowerCase();
+  if ((0, exports.isHeadersProtocol)(headers)) return headers.get(key) || headers.get(lowerKey);
+  const value = headers[key] || headers[lowerKey];
+  if (Array.isArray(value)) {
+    if (value.length <= 1) return value[0];
+    console.warn(`Received ${value.length} entries for the ${key} header, using the first entry.`);
+    return value[0];
+  }
+  return value;
+};
+exports.getHeader = getHeader;
+//# sourceMappingURL=core.js.map