increase 0.1.0

package/dist/cjs/check-version.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/check-version.js

@@ -0,0 +1,21 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+const fs_1 = __importDefault(require('fs'));
+const main = () => {
+  const pkg = JSON.parse(fs_1.default.readFileSync('package.json').toString());
+  const version = pkg['version'];
+  if (!version) throw 'The version property is not set in the package.json file';
+  if (typeof version !== 'string') {
+    throw `Unexpected type for the package.json version field; got ${typeof version}, expected string`;
+  }
+  fs_1.default.writeFileSync('version.ts', `export const VERSION = '${version}';\n`);
+};
+if (require.main === module) {
+  main();
+}
+//# sourceMappingURL=check-version.js.map

package/dist/cjs/check-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-version.js","sourceRoot":"","sources":["../../check-version.ts"],"names":[],"mappings":";;;;;AAAA,4CAAoB;AAEpB,MAAM,IAAI,GAAG,GAAG,EAAE;IAChB,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,YAAE,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE,CAA4B,CAAC;IAC9F,MAAM,OAAO,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;IAC/B,IAAI,CAAC,OAAO;QAAE,MAAM,0DAA0D,CAAC;IAC/E,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;QAC/B,MAAM,2DAA2D,OAAO,OAAO,mBAAmB,CAAC;KACpG;IACD,YAAE,CAAC,aAAa,CAAC,YAAY,EAAE,2BAA2B,OAAO,MAAM,CAAC,CAAC;AAC3E,CAAC,CAAC;AAEF,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE;IAC3B,IAAI,EAAE,CAAC;CACR"}

package/dist/cjs/core.d.ts

@@ -0,0 +1,262 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="web" />
+/// <reference types="node" />
+/// <reference types="node" />
+import qs from 'qs';
+import type { Agent } from 'http';
+import type { RequestInfo, RequestInit, Response } from 'node-fetch';
+import { Readable } from 'stream';
+import { Fetch } from './fetch-polyfill';
+export declare abstract class APIClient {
+  baseURL: string;
+  maxRetries: number;
+  timeout: number;
+  httpAgent: Agent | undefined;
+  private fetch;
+  protected idempotencyHeader?: string;
+  constructor({
+    baseURL,
+    maxRetries,
+    timeout, // 60s
+    httpAgent,
+  }: {
+    baseURL: string;
+    maxRetries?: number;
+    timeout: number | undefined;
+    httpAgent: Agent | undefined;
+  });
+  protected authHeaders(): Headers;
+  /**
+   * Override this to add your own default headers, for example:
+   *
+   *  {
+   *    ...super.defaultHeaders(),
+   *    Authorization: 'Bearer 123',
+   *  }
+   */
+  protected defaultHeaders(): Headers;
+  /**
+   * Override this to add your own headers validation:
+   */
+  protected validateHeaders(headers: Headers, customHeaders: Headers): void;
+  /**
+   * Override this to add your own qs.stringify options, for example:
+   *
+   *  {
+   *    ...super.qsOptions(),
+   *    strictNullHandling: true,
+   *  }
+   */
+  protected qsOptions(): qs.IStringifyOptions | undefined;
+  protected defaultIdempotencyKey(): string;
+  get<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  post<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  patch<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  put<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  delete<Req extends {}, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  getAPIList<Item, PageClass extends AbstractPage<Item> = AbstractPage<Item>>(
+    path: string,
+    Page: new (...args: any[]) => PageClass,
+    opts?: RequestOptions<any>,
+  ): PagePromise<PageClass>;
+  buildRequest<Req extends {}>(
+    options: FinalRequestOptions<Req>,
+  ): {
+    req: RequestInit;
+    url: string;
+    timeout: number;
+  };
+  request<Req extends {}, Rsp>(
+    options: FinalRequestOptions<Req>,
+    retriesRemaining?: number,
+  ): Promise<APIResponse<Rsp>>;
+  requestAPIList<Item = unknown, PageClass extends AbstractPage<Item> = AbstractPage<Item>>(
+    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
+    options: FinalRequestOptions,
+  ): PagePromise<PageClass>;
+  buildURL<Req>(path: string, query: Req | undefined): string;
+  fetchWithTimeout(
+    url: RequestInfo,
+    { signal, ...options }: RequestInit | undefined,
+    ms: number,
+    controller: AbortController,
+  ): Promise<Response>;
+  protected getRequestClient(): RequestClient;
+  private shouldRetry;
+  private retryRequest;
+  private calculateRetryTimeoutSeconds;
+  private getUserAgent;
+  private debug;
+}
+export declare class APIResource {
+  protected client: APIClient;
+  constructor(client: APIClient);
+  protected get: APIClient['get'];
+  protected post: APIClient['post'];
+  protected patch: APIClient['patch'];
+  protected put: APIClient['put'];
+  protected delete: APIClient['delete'];
+  protected getAPIList: APIClient['getAPIList'];
+}
+export type PageInfo =
+  | {
+      url: URL;
+    }
+  | {
+      params: Record<string, unknown> | null;
+    };
+export declare abstract class AbstractPage<Item> implements AsyncIterable<Item> {
+  #private;
+  protected options: FinalRequestOptions;
+  constructor(client: APIClient, response: APIResponse<unknown>, options: FinalRequestOptions);
+  /**
+   * @deprecated Use nextPageInfo instead
+   */
+  abstract nextPageParams(): Partial<Record<string, unknown>> | null;
+  abstract nextPageInfo(): PageInfo | null;
+  abstract getPaginatedItems(): Item[];
+  hasNextPage(): boolean;
+  getNextPage(): Promise<AbstractPage<Item>>;
+  iterPages(): AsyncGenerator<AbstractPage<Item>, void, unknown>;
+  [Symbol.asyncIterator](): AsyncGenerator<Awaited<Item>, void, unknown>;
+}
+export declare class PagePromise<
+    PageClass extends AbstractPage<Item>,
+    Item = ReturnType<PageClass['getPaginatedItems']>[number],
+  >
+  extends Promise<PageClass>
+  implements AsyncIterable<Item>
+{
+  /**
+   * This subclass of Promise will resolve to an instantiated Page once the request completes.
+   */
+  constructor(
+    client: APIClient,
+    requestPromise: Promise<APIResponse<unknown>>,
+    options: FinalRequestOptions,
+    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
+  );
+  /**
+   * Enable subclassing Promise.
+   * Ref: https://stackoverflow.com/a/60328122
+   */
+  static get [Symbol.species](): PromiseConstructor;
+  /**
+   * Allow auto-paginating iteration on an unawaited list call, eg:
+   *
+   *    for await (const item of client.items.list()) {
+   *      console.log(item)
+   *    }
+   */
+  [Symbol.asyncIterator](): AsyncGenerator<Awaited<Item>, void, unknown>;
+}
+export declare class Stream<Item> implements AsyncIterable<Item>, APIResponse<Stream<Item>> {
+  response: Response;
+  responseHeaders: Headers;
+  private controller;
+  constructor(response: Response, controller: AbortController);
+  [Symbol.asyncIterator](): AsyncIterator<Item, any, undefined>;
+}
+export declare const createResponseHeaders: (
+  headers: Awaited<ReturnType<Fetch>>['headers'],
+) => Record<string, string>;
+type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export type RequestClient = {
+  fetch: Fetch;
+};
+export type Headers = Record<string, string | null | undefined>;
+export type KeysEnum<T> = {
+  [P in keyof Required<T>]: true;
+};
+export type RequestOptions<Req extends {} = Record<string, unknown> | Readable> = {
+  method?: HTTPMethod;
+  path?: string;
+  query?: Req | undefined;
+  body?: Req | undefined;
+  headers?: Headers | undefined;
+  maxRetries?: number;
+  stream?: boolean | undefined;
+  timeout?: number;
+  httpAgent?: Agent;
+  idempotencyKey?: string;
+};
+export declare const isRequestOptions: (
+  obj: unknown,
+) => obj is RequestOptions<Record<string, unknown> | Readable>;
+export type FinalRequestOptions<Req extends {} = Record<string, unknown> | Readable> = RequestOptions<Req> & {
+  method: HTTPMethod;
+  path: string;
+};
+export type APIResponse<T> = T & {
+  responseHeaders: Headers;
+};
+export declare class APIError extends Error {
+  readonly status: number | undefined;
+  readonly headers: Headers | undefined;
+  readonly error: Object | undefined;
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  );
+  static generate(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ): APIError;
+}
+export declare class BadRequestError extends APIError {
+  readonly status: 400;
+}
+export declare class AuthenticationError extends APIError {
+  readonly status: 401;
+}
+export declare class PermissionDeniedError extends APIError {
+  readonly status: 403;
+}
+export declare class NotFoundError extends APIError {
+  readonly status: 404;
+}
+export declare class ConflictError extends APIError {
+  readonly status: 409;
+}
+export declare class UnprocessableEntityError extends APIError {
+  readonly status: 422;
+}
+export declare class RateLimitError extends APIError {
+  readonly status: 429;
+}
+export declare class InternalServerError extends APIError {}
+export declare class APIConnectionError extends APIError {
+  readonly status: undefined;
+  constructor({ message, cause }: { message?: string; cause?: Error | undefined });
+}
+export declare class APIConnectionTimeoutError extends APIConnectionError {
+  constructor();
+}
+/**
+ * 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.
+ */
+export declare const maybeMultipartFormRequestOptions: <T extends {} = Record<string, unknown>>(
+  opts: RequestOptions<T>,
+) => RequestOptions<Readable | T>;
+export declare const multipartFormRequestOptions: <T extends {} = Record<string, unknown>>(
+  opts: RequestOptions<T>,
+) => RequestOptions<Readable | T>;
+export declare const ensurePresent: <T>(value: T | null | undefined) => T;
+export declare const coerceInteger: (value: unknown) => number;
+export declare const coerceFloat: (value: unknown) => number;
+export declare const coerceBoolean: (value: unknown) => boolean;
+export declare function isEmptyObj(obj: Object | null | undefined): boolean;
+export declare function hasOwn(obj: Object, key: string): boolean;
+export interface HeadersProtocol {
+  get: (header: string) => string | null | undefined;
+}
+export type HeadersLike = Record<string, string | string[] | undefined> | HeadersProtocol;
+export declare const isHeadersProtocol: (headers: any) => headers is HeadersProtocol;
+export declare const getHeader: (headers: HeadersLike, key: string) => string | null | undefined;
+export {};