increase 0.1.0

package/fetch-polyfill.ts

@@ -0,0 +1,69 @@
+import type NodeFetch from 'node-fetch';
+import type { RequestInfo, RequestInit, Response } from 'node-fetch';
+import type KeepAliveAgent from 'agentkeepalive';
+import type { Agent } from 'http';
+import { AbortController as AbortControllerPolyfill } from 'abort-controller';
+
+declare const Deno: any;
+// For now, we just pretend that Fetch is the same type as NodeFetch.
+declare const fetch: Fetch | undefined;
+
+let nodeFetch: typeof NodeFetch | undefined = undefined;
+let nodeFetchImportError: unknown;
+let defaultHttpAgent: Agent;
+let defaultHttpsAgent: Agent;
+
+// In a Node environment, we prefer `node-fetch` to other fetch implementations
+// which may be present, because it allows keepAlive and others don't.
+// Alternative, "Web Standards"-based environments typically provide fetch implementations
+// which provide good performance for this by default, and may not support node-fetch.
+const isProbablyNode = typeof process !== 'undefined' && typeof Deno === 'undefined';
+if (isProbablyNode) {
+  try {
+    /* eslint-disable @typescript-eslint/no-var-requires */
+    nodeFetch = require('node-fetch').default;
+    const KeepAliveHttpAgent: typeof KeepAliveAgent = require('agentkeepalive');
+    /* eslint-enable @typescript-eslint/no-var-requires */
+
+    defaultHttpAgent = new KeepAliveHttpAgent({ keepAlive: true });
+    defaultHttpsAgent = new KeepAliveHttpAgent.HttpsAgent({ keepAlive: true });
+  } catch (e) {
+    // We can fall back to a built-in "fetch".
+    nodeFetchImportError = e;
+  }
+}
+
+// Polyfill global object if needed.
+AbortController = typeof AbortController !== undefined ?
+    AbortController
+  : (AbortControllerPolyfill as typeof AbortController);
+
+export type Fetch = (url: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export const getFetch = (): Fetch => {
+  if (isProbablyNode && nodeFetch) {
+    return nodeFetch;
+  }
+
+  // For other environments, use a global fetch function expected to already be present
+  if (typeof fetch === 'undefined' || typeof fetch !== 'function') {
+    if (isProbablyNode) {
+      throw new Error(
+        `Could not import "node-fetch", and no global "fetch" function is defined.`,
+        // @ts-expect-error This is only Node 16.9.0+, but isn't harmful in other contexts.
+        { cause: nodeFetchImportError },
+      );
+    }
+    throw new Error(
+      `Unexpected: running in a non-Node environment without a global "fetch" function defined.`,
+    );
+  }
+
+  return fetch;
+};
+
+export const getDefaultAgent = (url: string): Agent | undefined => {
+  if (defaultHttpsAgent && url.startsWith('https')) return defaultHttpsAgent;
+  if (defaultHttpAgent) return defaultHttpAgent;
+  return undefined;
+};

package/index.ts

@@ -0,0 +1,276 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import qs from 'qs';
+import * as Core from './core';
+import * as Pagination from './pagination';
+import * as API from './resources';
+import type { Agent } from 'http';
+import * as FileFromPath from 'formdata-node/file-from-path';
+
+const environments = {
+  production: 'https://api.increase.com',
+  sandbox: 'https://sandbox.increase.com',
+};
+
+type Config = {
+  /**
+   * Defaults to process.env["INCREASE_API_KEY"].
+   */
+  apiKey?: string;
+  environment?: keyof typeof environments;
+  baseURL?: string;
+  timeout?: number;
+  httpAgent?: Agent;
+};
+
+/** Instantiate the API Client. */
+export class Increase extends Core.APIClient {
+  apiKey: string;
+
+  constructor(config?: Config) {
+    const options: Config = {
+      apiKey: process.env['INCREASE_API_KEY'] || '',
+      environment: 'production',
+      ...config,
+    };
+
+    if (!options.apiKey && options.apiKey !== null) {
+      throw new Error(
+        "The INCREASE_API_KEY environment variable is missing or empty; either provide it, or instantiate the Increase client with an apiKey option, like new Increase({ apiKey: 'my api key' }).",
+      );
+    }
+
+    super({
+      baseURL: options.baseURL || environments[options.environment || 'production'],
+      timeout: options.timeout,
+      httpAgent: options.httpAgent,
+    });
+    this.apiKey = options.apiKey;
+  }
+
+  accounts: API.Accounts = new API.Accounts(this);
+  accountNumbers: API.AccountNumbers = new API.AccountNumbers(this);
+  realTimeDecisions: API.RealTimeDecisions = new API.RealTimeDecisions(this);
+  cards: API.Cards = new API.Cards(this);
+  cardDisputes: API.CardDisputes = new API.CardDisputes(this);
+  cardProfiles: API.CardProfiles = new API.CardProfiles(this);
+  externalAccounts: API.ExternalAccounts = new API.ExternalAccounts(this);
+  digitalWalletTokens: API.DigitalWalletTokens = new API.DigitalWalletTokens(this);
+  transactions: API.Transactions = new API.Transactions(this);
+  pendingTransactions: API.PendingTransactions = new API.PendingTransactions(this);
+  declinedTransactions: API.DeclinedTransactions = new API.DeclinedTransactions(this);
+  limits: API.Limits = new API.Limits(this);
+  accountTransfers: API.AccountTransfers = new API.AccountTransfers(this);
+  achTransfers: API.ACHTransfers = new API.ACHTransfers(this);
+  inboundACHTransferReturns: API.InboundACHTransferReturns = new API.InboundACHTransferReturns(this);
+  achPrenotifications: API.ACHPrenotifications = new API.ACHPrenotifications(this);
+  documents: API.Documents = new API.Documents(this);
+  wireTransfers: API.WireTransfers = new API.WireTransfers(this);
+  checkTransfers: API.CheckTransfers = new API.CheckTransfers(this);
+  entities: API.Entities = new API.Entities(this);
+  inboundWireDrawdownRequests: API.InboundWireDrawdownRequests = new API.InboundWireDrawdownRequests(this);
+  wireDrawdownRequests: API.WireDrawdownRequests = new API.WireDrawdownRequests(this);
+  events: API.Events = new API.Events(this);
+  eventSubscriptions: API.EventSubscriptions = new API.EventSubscriptions(this);
+  files: API.Files = new API.Files(this);
+  groups: API.Groups = new API.Groups(this);
+  oauthConnections: API.OauthConnections = new API.OauthConnections(this);
+  checkDeposits: API.CheckDeposits = new API.CheckDeposits(this);
+  routingNumbers: API.RoutingNumbers = new API.RoutingNumbers(this);
+  accountStatements: API.AccountStatements = new API.AccountStatements(this);
+  simulations: API.Simulations = new API.Simulations(this);
+
+  protected override authHeaders(): Core.Headers {
+    return { Authorization: `Bearer ${this.apiKey}` };
+  }
+
+  protected override qsOptions(): qs.IStringifyOptions {
+    return { allowDots: true, arrayFormat: 'comma' };
+  }
+
+  static APIError = Core.APIError;
+
+  static APIConnectionError = Core.APIConnectionError;
+  static APIConnectionTimeoutError = Core.APIConnectionTimeoutError;
+
+  static BadRequestError = Core.BadRequestError;
+  static AuthenticationError = Core.AuthenticationError;
+  static PermissionDeniedError = Core.PermissionDeniedError;
+  static NotFoundError = Core.NotFoundError;
+  static ConflictError = Core.ConflictError;
+  static UnprocessableEntityError = Core.UnprocessableEntityError;
+  static RateLimitError = Core.RateLimitError;
+  static InternalServerError = Core.InternalServerError;
+}
+
+export const {
+  APIError,
+
+  APIConnectionError,
+  APIConnectionTimeoutError,
+
+  BadRequestError,
+  AuthenticationError,
+  PermissionDeniedError,
+  NotFoundError,
+  ConflictError,
+  UnprocessableEntityError,
+  RateLimitError,
+  InternalServerError,
+} = Increase;
+
+export namespace Increase {
+  // Helper functions
+  export import fileFromPath = FileFromPath.fileFromPath;
+
+  export import Page = Pagination.Page;
+  export import PageParams = Pagination.PageParams;
+  export import PageResponse = Pagination.PageResponse;
+
+  export import Account = API.Account;
+  export import AccountsPage = API.AccountsPage;
+  export import AccountCreateParams = API.AccountCreateParams;
+  export import AccountUpdateParams = API.AccountUpdateParams;
+  export import AccountListParams = API.AccountListParams;
+
+  export import AccountNumber = API.AccountNumber;
+  export import AccountNumbersPage = API.AccountNumbersPage;
+  export import AccountNumberCreateParams = API.AccountNumberCreateParams;
+  export import AccountNumberUpdateParams = API.AccountNumberUpdateParams;
+  export import AccountNumberListParams = API.AccountNumberListParams;
+
+  export import RealTimeDecision = API.RealTimeDecision;
+  export import RealTimeDecisionActionParams = API.RealTimeDecisionActionParams;
+
+  export import Card = API.Card;
+  export import CardDetails = API.CardDetails;
+  export import CardsPage = API.CardsPage;
+  export import CardCreateParams = API.CardCreateParams;
+  export import CardUpdateParams = API.CardUpdateParams;
+  export import CardListParams = API.CardListParams;
+
+  export import CardDispute = API.CardDispute;
+  export import CardDisputesPage = API.CardDisputesPage;
+  export import CardDisputeCreateParams = API.CardDisputeCreateParams;
+  export import CardDisputeListParams = API.CardDisputeListParams;
+
+  export import CardProfile = API.CardProfile;
+  export import CardProfilesPage = API.CardProfilesPage;
+  export import CardProfileCreateParams = API.CardProfileCreateParams;
+  export import CardProfileListParams = API.CardProfileListParams;
+
+  export import ExternalAccount = API.ExternalAccount;
+  export import ExternalAccountsPage = API.ExternalAccountsPage;
+  export import ExternalAccountCreateParams = API.ExternalAccountCreateParams;
+  export import ExternalAccountUpdateParams = API.ExternalAccountUpdateParams;
+  export import ExternalAccountListParams = API.ExternalAccountListParams;
+
+  export import DigitalWalletToken = API.DigitalWalletToken;
+  export import DigitalWalletTokensPage = API.DigitalWalletTokensPage;
+  export import DigitalWalletTokenListParams = API.DigitalWalletTokenListParams;
+
+  export import Transaction = API.Transaction;
+  export import TransactionsPage = API.TransactionsPage;
+  export import TransactionListParams = API.TransactionListParams;
+
+  export import PendingTransaction = API.PendingTransaction;
+  export import PendingTransactionsPage = API.PendingTransactionsPage;
+  export import PendingTransactionListParams = API.PendingTransactionListParams;
+
+  export import DeclinedTransaction = API.DeclinedTransaction;
+  export import DeclinedTransactionsPage = API.DeclinedTransactionsPage;
+  export import DeclinedTransactionListParams = API.DeclinedTransactionListParams;
+
+  export import Limit = API.Limit;
+  export import LimitsPage = API.LimitsPage;
+  export import LimitCreateParams = API.LimitCreateParams;
+  export import LimitUpdateParams = API.LimitUpdateParams;
+  export import LimitListParams = API.LimitListParams;
+
+  export import AccountTransfer = API.AccountTransfer;
+  export import AccountTransfersPage = API.AccountTransfersPage;
+  export import AccountTransferCreateParams = API.AccountTransferCreateParams;
+  export import AccountTransferListParams = API.AccountTransferListParams;
+
+  export import ACHTransfer = API.ACHTransfer;
+  export import ACHTransfersPage = API.ACHTransfersPage;
+  export import ACHTransferCreateParams = API.ACHTransferCreateParams;
+  export import ACHTransferListParams = API.ACHTransferListParams;
+
+  export import InboundACHTransferReturn = API.InboundACHTransferReturn;
+  export import InboundACHTransferReturnsPage = API.InboundACHTransferReturnsPage;
+  export import InboundACHTransferReturnCreateParams = API.InboundACHTransferReturnCreateParams;
+  export import InboundACHTransferReturnListParams = API.InboundACHTransferReturnListParams;
+
+  export import ACHPrenotification = API.ACHPrenotification;
+  export import ACHPrenotificationsPage = API.ACHPrenotificationsPage;
+  export import ACHPrenotificationCreateParams = API.ACHPrenotificationCreateParams;
+  export import ACHPrenotificationListParams = API.ACHPrenotificationListParams;
+
+  export import Document = API.Document;
+  export import DocumentsPage = API.DocumentsPage;
+  export import DocumentListParams = API.DocumentListParams;
+
+  export import WireTransfer = API.WireTransfer;
+  export import WireTransfersPage = API.WireTransfersPage;
+  export import WireTransferCreateParams = API.WireTransferCreateParams;
+  export import WireTransferListParams = API.WireTransferListParams;
+
+  export import CheckTransfer = API.CheckTransfer;
+  export import CheckTransfersPage = API.CheckTransfersPage;
+  export import CheckTransferCreateParams = API.CheckTransferCreateParams;
+  export import CheckTransferListParams = API.CheckTransferListParams;
+
+  export import Entity = API.Entity;
+  export import EntitiesPage = API.EntitiesPage;
+  export import EntityCreateParams = API.EntityCreateParams;
+  export import EntityListParams = API.EntityListParams;
+
+  export import InboundWireDrawdownRequest = API.InboundWireDrawdownRequest;
+  export import InboundWireDrawdownRequestsPage = API.InboundWireDrawdownRequestsPage;
+  export import InboundWireDrawdownRequestListParams = API.InboundWireDrawdownRequestListParams;
+
+  export import WireDrawdownRequest = API.WireDrawdownRequest;
+  export import WireDrawdownRequestsPage = API.WireDrawdownRequestsPage;
+  export import WireDrawdownRequestCreateParams = API.WireDrawdownRequestCreateParams;
+  export import WireDrawdownRequestListParams = API.WireDrawdownRequestListParams;
+
+  export import Event = API.Event;
+  export import EventsPage = API.EventsPage;
+  export import EventListParams = API.EventListParams;
+
+  export import EventSubscription = API.EventSubscription;
+  export import EventSubscriptionsPage = API.EventSubscriptionsPage;
+  export import EventSubscriptionCreateParams = API.EventSubscriptionCreateParams;
+  export import EventSubscriptionUpdateParams = API.EventSubscriptionUpdateParams;
+  export import EventSubscriptionListParams = API.EventSubscriptionListParams;
+
+  export import File = API.File;
+  export import FilesPage = API.FilesPage;
+  export import FileCreateParams = API.FileCreateParams;
+  export import FileListParams = API.FileListParams;
+
+  export import Group = API.Group;
+
+  export import OauthConnection = API.OauthConnection;
+  export import OauthConnectionsPage = API.OauthConnectionsPage;
+  export import OauthConnectionListParams = API.OauthConnectionListParams;
+
+  export import CheckDeposit = API.CheckDeposit;
+  export import CheckDepositsPage = API.CheckDepositsPage;
+  export import CheckDepositCreateParams = API.CheckDepositCreateParams;
+  export import CheckDepositListParams = API.CheckDepositListParams;
+
+  export import RoutingNumber = API.RoutingNumber;
+  export import RoutingNumbersPage = API.RoutingNumbersPage;
+  export import RoutingNumberListParams = API.RoutingNumberListParams;
+
+  export import AccountStatement = API.AccountStatement;
+  export import AccountStatementsPage = API.AccountStatementsPage;
+  export import AccountStatementListParams = API.AccountStatementListParams;
+
+  export import PointOfServiceEntryMode = API.PointOfServiceEntryMode;
+}
+
+exports = module.exports = Increase;
+export default Increase;

package/jest.config.js

@@ -0,0 +1,8 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleNameMapper: {
+    '^~/(.*)$': '<rootDir>/$1',
+  },
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "increase",
+  "version": "0.1.0",
+  "description": "Client library for the Increase API",
+  "author": "Increase <dev-feedback@increase.com>",
+  "types": "dist/cjs/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "type": "commonjs",
+  "repository": "github:increase/increase-node",
+  "license": "Apache-2.0",
+  "private": false,
+  "scripts": {
+    "test": "bin/check-test-server && yarn jest",
+    "build": "bash ./build",
+    "prepack": "yarn build",
+    "format": "prettier --write .",
+    "tsn": "ts-node -r tsconfig-paths/register",
+    "fix": "eslint --fix --ext ts,js ."
+  },
+  "dependencies": {
+    "@types/node": "^18.11.18",
+    "@types/node-fetch": "^2.6.1",
+    "@types/qs": "^6.9.7",
+    "abort-controller": "^3.0.0",
+    "agentkeepalive": "^4.2.1",
+    "digest-fetch": "^1.3.0",
+    "form-data-encoder": "1.7.2",
+    "formdata-node": "^4.3.2",
+    "node-fetch": "^2.6.7",
+    "qs": "^6.10.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^27.5.0",
+    "@typescript-eslint/eslint-plugin": "^5.33.0",
+    "@typescript-eslint/parser": "^5.33.0",
+    "eslint": "^8.22.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "increase": "link:.",
+    "jest": "^28.1.0",
+    "prettier": "rattrayalex/prettier#postfix-ternaries",
+    "ts-jest": "^28.0.2",
+    "ts-node": "^10.5.0",
+    "tsc-alias": "^1.6.9",
+    "tsconfig-paths": "^3.12.0",
+    "typescript": "^4.8.2"
+  }
+}

package/pagination.ts

@@ -0,0 +1,58 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import { AbstractPage, APIResponse, APIClient, FinalRequestOptions, PageInfo } from './core';
+
+export interface PageResponse<Item> {
+  data: Array<Item>;
+
+  /**
+   * A pointer to a place in the list.
+   */
+  next_cursor: string | null;
+}
+
+export interface PageParams {
+  /**
+   * Return the page of entries after this one.
+   */
+  cursor?: string;
+
+  /**
+   * Limit the size of the list that is returned. The default (and maximum) is 100
+   * objects.
+   */
+  limit?: number;
+}
+
+export class Page<Item> extends AbstractPage<Item> implements PageResponse<Item> {
+  data: Array<Item>;
+  /** A pointer to a place in the list. */
+  next_cursor: string | null;
+
+  constructor(client: APIClient, response: APIResponse<PageResponse<Item>>, options: FinalRequestOptions) {
+    super(client, response, options);
+
+    this.data = response.data;
+    this.next_cursor = response.next_cursor;
+  }
+
+  getPaginatedItems(): Item[] {
+    return this.data;
+  }
+
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams(): Partial<PageParams> | null {
+    const info = this.nextPageInfo();
+    if (!info) return null;
+    if ('params' in info) return info.params;
+    const params = Object.fromEntries(info.url.searchParams);
+    if (!Object.keys(params).length) return null;
+    return params;
+  }
+
+  nextPageInfo(): PageInfo | null {
+    if (!this.next_cursor) return null;
+
+    return { params: { cursor: this.next_cursor } };
+  }
+}

package/resource.ts

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import type { Increase } from './index';
+
+export class APIResource {
+  protected client: Increase;
+  constructor(client: Increase) {
+    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);
+  }
+
+  protected get: Increase['get'];
+  protected post: Increase['post'];
+  protected patch: Increase['patch'];
+  protected put: Increase['put'];
+  protected delete: Increase['delete'];
+  protected getAPIList: Increase['getAPIList'];
+}

package/resources/account-numbers.ts

@@ -0,0 +1,141 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import * as Core from '~/core';
+import { APIResource } from '~/resource';
+import { isRequestOptions } from '~/core';
+import { Page, PageParams } from '~/pagination';
+
+export class AccountNumbers extends APIResource {
+  /**
+   * Create an Account Number
+   */
+  create(
+    body: AccountNumberCreateParams,
+    options?: Core.RequestOptions,
+  ): Promise<Core.APIResponse<AccountNumber>> {
+    return this.post('/account_numbers', { body, ...options });
+  }
+
+  /**
+   * Retrieve an Account Number
+   */
+  retrieve(accountNumberId: string, options?: Core.RequestOptions): Promise<Core.APIResponse<AccountNumber>> {
+    return this.get(`/account_numbers/${accountNumberId}`, options);
+  }
+
+  /**
+   * Update an Account Number
+   */
+  update(
+    accountNumberId: string,
+    body: AccountNumberUpdateParams,
+    options?: Core.RequestOptions,
+  ): Promise<Core.APIResponse<AccountNumber>> {
+    return this.patch(`/account_numbers/${accountNumberId}`, { body, ...options });
+  }
+
+  /**
+   * List Account Numbers
+   */
+  list(query?: AccountNumberListParams, options?: Core.RequestOptions): Core.PagePromise<AccountNumbersPage>;
+  list(options?: Core.RequestOptions): Core.PagePromise<AccountNumbersPage>;
+  list(
+    query: AccountNumberListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<AccountNumbersPage> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+
+    return this.getAPIList('/account_numbers', AccountNumbersPage, { query, ...options });
+  }
+}
+
+export class AccountNumbersPage extends Page<AccountNumber> {}
+
+/**
+ * Each account can have multiple account and routing numbers. We recommend that
+ * you use a set per vendor. This is similar to how you use different passwords for
+ * different websites. Account numbers can also be used to seamlessly reconcile
+ * inbound payments. Generating a unique account number per vendor ensures you
+ * always know the originator of an incoming payment.
+ */
+export interface AccountNumber {
+  /**
+   * The identifier for the account this Account Number belongs to.
+   */
+  account_id: string;
+
+  /**
+   * The account number.
+   */
+  account_number: string;
+
+  /**
+   * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time at which the Account
+   * Number was created.
+   */
+  created_at: string;
+
+  /**
+   * The Account Number identifier.
+   */
+  id: string;
+
+  /**
+   * The name you choose for the Account Number.
+   */
+  name: string;
+
+  /**
+   * The American Bankers' Association (ABA) Routing Transit Number (RTN).
+   */
+  routing_number: string;
+
+  /**
+   * This indicates if payments can be made to the Account Number.
+   */
+  status: 'active' | 'disabled' | 'canceled';
+
+  /**
+   * A constant representing the object's type. For this resource it will always be
+   * `account_number`.
+   */
+  type: 'account_number';
+}
+
+export interface AccountNumberCreateParams {
+  /**
+   * The Account the Account Number should belong to.
+   */
+  account_id: string;
+
+  /**
+   * The name you choose for the Account Number.
+   */
+  name: string;
+}
+
+export interface AccountNumberUpdateParams {
+  /**
+   * The name you choose for the Account Number.
+   */
+  name?: string;
+
+  /**
+   * This indicates if transfers can be made to the Account Number.
+   */
+  status?: 'active' | 'disabled' | 'canceled';
+}
+
+export interface AccountNumberListParams extends PageParams {
+  /**
+   * Filter Account Numbers to those belonging to the specified Account.
+   */
+  account_id?: string;
+
+  /**
+   * The status to retrieve Account Numbers for.
+   */
+  status?: 'active' | 'disabled' | 'canceled';
+}