modern-treasury 0.0.1

package/dist/cjs/core.d.ts

@@ -0,0 +1,215 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import qs from 'qs';
+import type { Agent } from 'http';
+import type NodeFetch from 'node-fetch';
+import type { RequestInfo, RequestInit, Response } from 'node-fetch';
+import { Readable } from 'stream';
+export declare abstract class APIClient {
+  apiKey: string | null;
+  baseURL: string;
+  maxRetries: number;
+  timeout: number;
+  httpAgent: Agent | undefined;
+  private fetch;
+  protected idempotencyHeader?: string;
+  constructor({
+    apiKey,
+    baseURL,
+    maxRetries,
+    timeout,
+    httpAgent,
+  }: {
+    apiKey: string | null;
+    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 qs.stringify options, for example:
+   *
+   *  {
+   *    ...super.qsOptions(),
+   *    strictNullHandling: true,
+   *  }
+   */
+  protected qsOptions(): qs.IStringifyOptions | undefined;
+  protected defaultIdempotencyKey(): string;
+  get<Req, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  post<Req, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  patch<Req, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  put<Req, Rsp>(path: string, opts?: RequestOptions<Req>): Promise<Rsp>;
+  delete<Req, 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>;
+  request<Req, 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,
+  ): Promise<Response>;
+  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 declare abstract class AbstractPage<Item> implements AsyncIterable<Item> {
+  #private;
+  protected options: FinalRequestOptions;
+  constructor(client: APIClient, response: APIResponse<unknown>, options: FinalRequestOptions);
+  abstract nextPageParams(): Partial<Record<string, unknown>> | 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 const createResponseHeaders: (
+  headers: Awaited<ReturnType<typeof NodeFetch>>['headers'],
+) => Record<string, string>;
+declare type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export declare type Headers = Record<string, string | null | undefined>;
+export declare type KeysEnum<T> = {
+  [P in keyof Required<T>]: true;
+};
+export declare type RequestOptions<Req extends {} = Record<string, unknown> | Readable> = {
+  method?: HTTPMethod;
+  path?: string;
+  query?: Req | undefined;
+  body?: Req | undefined;
+  headers?: Headers | undefined;
+  maxRetries?: number;
+  timeout?: number;
+  httpAgent?: Agent;
+};
+export declare const isRequestOptions: (
+  obj: unknown,
+) => obj is RequestOptions<Readable | Record<string, unknown>>;
+export declare type FinalRequestOptions<Req extends {} = Record<string, unknown> | Readable> =
+  RequestOptions<Req> & {
+    method: HTTPMethod;
+    path: string;
+    idempotencyKey?: string;
+  };
+export declare 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();
+}
+export declare const multipartFormRequestOptions: <T = Record<string, unknown>>(
+  opts: RequestOptions<T>,
+) => RequestOptions<Readable | T>;
+export declare const coerceInteger: (value: unknown) => number;
+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 declare 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 {};