increase 0.2.0 → 0.3.0

package/error.ts

@@ -0,0 +1,337 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import * as Core from '~/core';
+
+export class InvalidParametersError extends Core.BadRequestError {
+  detail: string | null;
+
+  /**
+   * All errors related to parsing the request parameters.
+   */
+  errors: Array<unknown>;
+
+  override status: 400;
+
+  title: string;
+
+  type: 'invalid_parameters_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+    this.errors = data?.['errors'];
+  }
+}
+
+export class MalformedRequestError extends Core.BadRequestError {
+  detail: string | null;
+
+  override status: 400;
+
+  title: string;
+
+  type: 'malformed_request_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class InvalidAPIKeyError extends Core.AuthenticationError {
+  detail: string | null;
+
+  override status: 401;
+
+  title: string;
+
+  type: 'invalid_api_key_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class EnvironmentMismatchError extends Core.PermissionDeniedError {
+  detail: string | null;
+
+  override status: 403;
+
+  title: string;
+
+  type: 'environment_mismatch_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class InsufficientPermissionsError extends Core.PermissionDeniedError {
+  detail: string | null;
+
+  override status: 403;
+
+  title: string;
+
+  type: 'insufficient_permissions_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class PrivateFeatureError extends Core.PermissionDeniedError {
+  detail: string | null;
+
+  override status: 403;
+
+  title: string;
+
+  type: 'private_feature_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class APIMethodNotFoundError extends Core.NotFoundError {
+  detail: string | null;
+
+  override status: 404;
+
+  title: string;
+
+  type: 'api_method_not_found_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class ObjectNotFoundError extends Core.NotFoundError {
+  detail: string | null;
+
+  override status: 404;
+
+  title: string;
+
+  type: 'object_not_found_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class IdempotencyConflictError extends Core.ConflictError {
+  detail: string | null;
+
+  override status: 409;
+
+  title: string;
+
+  type: 'idempotency_conflict_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class InvalidOperationError extends Core.ConflictError {
+  detail: string | null;
+
+  override status: 409;
+
+  title: string;
+
+  type: 'invalid_operation_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class IdempotencyUnprocessableError extends Core.UnprocessableEntityError {
+  detail: string | null;
+
+  override status: 422;
+
+  title: string;
+
+  type: 'idempotency_unprocessable_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}
+
+export class RateLimitedError extends Core.RateLimitError {
+  detail: string | null;
+
+  override status: 429;
+
+  title: string;
+
+  type: 'rate_limited_error';
+
+  retry_after?: number | null;
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+    this.retry_after = data?.['retry_after'];
+  }
+}
+
+export class InternalServerError extends Core.InternalServerError {
+  detail: string | null;
+
+  override status: 500;
+
+  title: string;
+
+  type: 'internal_server_error';
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const data = error as Record<string, any>;
+    super(status, error, data?.['title'] || message, headers);
+
+    this.type = data?.['type'];
+    this.title = data?.['title'];
+    this.detail = data?.['detail'];
+    this.status = data?.['status'];
+  }
+}

package/examples/api-error.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env yarn tsn -T
+
+import Increase, { InvalidAPIKeyError } from 'increase';
+
+const client = new Increase({ apiKey: 'invalid API key' });
+
+async function main() {
+  try {
+    await client.accounts.retrieve('<account id>');
+  } catch (err) {
+    if (err instanceof InvalidAPIKeyError) {
+      console.log(`Caught InvalidAPIKeyError`);
+    } else {
+      console.log(`Caught unknown error`);
+    }
+
+    console.log(err);
+  }
+}
+
+main().catch(console.error);

package/fetch-polyfill.ts

@@ -25,8 +25,8 @@ if (isProbablyNode) {
     const KeepAliveHttpAgent: typeof KeepAliveAgent = require('agentkeepalive');
     /* eslint-enable @typescript-eslint/no-var-requires */
 
-    defaultHttpAgent = new KeepAliveHttpAgent({ keepAlive: true });
-    defaultHttpsAgent = new KeepAliveHttpAgent.HttpsAgent({ keepAlive: true });
+    defaultHttpAgent = new KeepAliveHttpAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
+    defaultHttpsAgent = new KeepAliveHttpAgent.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
   } catch (e) {
     // We can fall back to a built-in "fetch".
     nodeFetchImportError = e;

package/index.ts

@@ -6,6 +6,7 @@ import * as Pagination from './pagination';
 import * as API from './resources';
 import type { Agent } from 'http';
 import * as FileFromPath from 'formdata-node/file-from-path';
+import * as Errors from '~/error';
 
 const environments = {
   production: 'https://api.increase.com',
@@ -21,6 +22,7 @@ type Config = {
   baseURL?: string;
   timeout?: number;
   httpAgent?: Agent;
+  maxRetries?: number;
 };
 
 /** Instantiate the API Client. */
@@ -44,6 +46,7 @@ export class Increase extends Core.APIClient {
       baseURL: options.baseURL || environments[options.environment || 'production'],
       timeout: options.timeout,
       httpAgent: options.httpAgent,
+      maxRetries: options.maxRetries,
     });
     this.apiKey = options.apiKey;
     this.idempotencyHeader = 'Idempotency-Key';
@@ -51,14 +54,21 @@ export class Increase extends Core.APIClient {
 
   accounts: API.Accounts = new API.Accounts(this);
   accountNumbers: API.AccountNumbers = new API.AccountNumbers(this);
+  bookkeepingAccounts: API.BookkeepingAccounts = new API.BookkeepingAccounts(this);
+  bookkeepingEntrySets: API.BookkeepingEntrySets = new API.BookkeepingEntrySets(this);
+  bookkeepingEntries: API.BookkeepingEntries = new API.BookkeepingEntries(this);
   realTimeDecisions: API.RealTimeDecisions = new API.RealTimeDecisions(this);
+  realTimePaymentsTransfers: API.RealTimePaymentsTransfers = new API.RealTimePaymentsTransfers(this);
+  balanceLookups: API.BalanceLookups = new API.BalanceLookups(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);
+  exports: API.Exports = new API.Exports(this);
   digitalWalletTokens: API.DigitalWalletTokens = new API.DigitalWalletTokens(this);
   transactions: API.Transactions = new API.Transactions(this);
   pendingTransactions: API.PendingTransactions = new API.PendingTransactions(this);
+  programs: API.Programs = new API.Programs(this);
   declinedTransactions: API.DeclinedTransactions = new API.DeclinedTransactions(this);
   limits: API.Limits = new API.Limits(this);
   accountTransfers: API.AccountTransfers = new API.AccountTransfers(this);
@@ -85,6 +95,77 @@ export class Increase extends Core.APIClient {
     return { Authorization: `Bearer ${this.apiKey}` };
   }
 
+  protected override makeStatusError(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Core.Headers | undefined,
+  ) {
+    const type = (error as Record<string, any>)?.['type'];
+
+    if (type === 'invalid_parameters_error') {
+      return new Errors.InvalidParametersError(status, error, message, headers);
+    }
+
+    if (type === 'malformed_request_error') {
+      return new Errors.MalformedRequestError(status, error, message, headers);
+    }
+
+    if (type === 'invalid_api_key_error') {
+      return new Errors.InvalidAPIKeyError(status, error, message, headers);
+    }
+
+    if (type === 'environment_mismatch_error') {
+      return new Errors.EnvironmentMismatchError(status, error, message, headers);
+    }
+
+    if (type === 'insufficient_permissions_error') {
+      return new Errors.InsufficientPermissionsError(status, error, message, headers);
+    }
+
+    if (type === 'private_feature_error') {
+      return new Errors.PrivateFeatureError(status, error, message, headers);
+    }
+
+    if (type === 'api_method_not_found_error') {
+      return new Errors.APIMethodNotFoundError(status, error, message, headers);
+    }
+
+    if (type === 'object_not_found_error') {
+      return new Errors.ObjectNotFoundError(status, error, message, headers);
+    }
+
+    if (type === 'idempotency_conflict_error') {
+      return new Errors.IdempotencyConflictError(status, error, message, headers);
+    }
+
+    if (type === 'invalid_operation_error') {
+      return new Errors.InvalidOperationError(status, error, message, headers);
+    }
+
+    if (type === 'idempotency_unprocessable_error') {
+      return new Errors.IdempotencyUnprocessableError(status, error, message, headers);
+    }
+
+    if (type === 'rate_limited_error') {
+      return new Errors.RateLimitedError(status, error, message, headers);
+    }
+
+    if (type === 'internal_server_error') {
+      return new Errors.InternalServerError(status, error, message, headers);
+    }
+    if (status === 500) {
+      return new Errors.InternalServerError(
+        status,
+        { type: 'internal_server_error', title: '', detail: null, status: 500 },
+        message,
+        headers,
+      );
+    }
+
+    return super.makeStatusError(status, error, message, headers);
+  }
+
   protected override qsOptions(): qs.IStringifyOptions {
     return { allowDots: true, arrayFormat: 'comma' };
   }
@@ -101,7 +182,20 @@ export class Increase extends Core.APIClient {
   static ConflictError = Core.ConflictError;
   static UnprocessableEntityError = Core.UnprocessableEntityError;
   static RateLimitError = Core.RateLimitError;
-  static InternalServerError = Core.InternalServerError;
+
+  static RateLimitedError = Errors.RateLimitedError;
+  static InvalidAPIKeyError = Errors.InvalidAPIKeyError;
+  static InternalServerError = Errors.InternalServerError;
+  static ObjectNotFoundError = Errors.ObjectNotFoundError;
+  static PrivateFeatureError = Errors.PrivateFeatureError;
+  static InvalidOperationError = Errors.InvalidOperationError;
+  static MalformedRequestError = Errors.MalformedRequestError;
+  static APIMethodNotFoundError = Errors.APIMethodNotFoundError;
+  static InvalidParametersError = Errors.InvalidParametersError;
+  static EnvironmentMismatchError = Errors.EnvironmentMismatchError;
+  static IdempotencyConflictError = Errors.IdempotencyConflictError;
+  static InsufficientPermissionsError = Errors.InsufficientPermissionsError;
+  static IdempotencyUnprocessableError = Errors.IdempotencyUnprocessableError;
 }
 
 export const {
@@ -117,9 +211,24 @@ export const {
   ConflictError,
   UnprocessableEntityError,
   RateLimitError,
-  InternalServerError,
 } = Increase;
 
+export const {
+  RateLimitedError,
+  InvalidAPIKeyError,
+  InternalServerError,
+  ObjectNotFoundError,
+  PrivateFeatureError,
+  InvalidOperationError,
+  MalformedRequestError,
+  APIMethodNotFoundError,
+  InvalidParametersError,
+  EnvironmentMismatchError,
+  IdempotencyConflictError,
+  InsufficientPermissionsError,
+  IdempotencyUnprocessableError,
+} = Errors;
+
 export import fileFromPath = FileFromPath.fileFromPath;
 
 export namespace Increase {
@@ -142,9 +251,29 @@ export namespace Increase {
   export import AccountNumberUpdateParams = API.AccountNumberUpdateParams;
   export import AccountNumberListParams = API.AccountNumberListParams;
 
+  export import BookkeepingAccount = API.BookkeepingAccount;
+  export import BookkeepingAccountsPage = API.BookkeepingAccountsPage;
+  export import BookkeepingAccountCreateParams = API.BookkeepingAccountCreateParams;
+  export import BookkeepingAccountListParams = API.BookkeepingAccountListParams;
+
+  export import BookkeepingEntrySet = API.BookkeepingEntrySet;
+  export import BookkeepingEntrySetCreateParams = API.BookkeepingEntrySetCreateParams;
+
+  export import BookkeepingEntry = API.BookkeepingEntry;
+  export import BookkeepingEntriesPage = API.BookkeepingEntriesPage;
+  export import BookkeepingEntryListParams = API.BookkeepingEntryListParams;
+
   export import RealTimeDecision = API.RealTimeDecision;
   export import RealTimeDecisionActionParams = API.RealTimeDecisionActionParams;
 
+  export import RealTimePaymentsTransfer = API.RealTimePaymentsTransfer;
+  export import RealTimePaymentsTransfersPage = API.RealTimePaymentsTransfersPage;
+  export import RealTimePaymentsTransferCreateParams = API.RealTimePaymentsTransferCreateParams;
+  export import RealTimePaymentsTransferListParams = API.RealTimePaymentsTransferListParams;
+
+  export import BalanceLookupLookupResponse = API.BalanceLookupLookupResponse;
+  export import BalanceLookupLookupParams = API.BalanceLookupLookupParams;
+
   export import Card = API.Card;
   export import CardDetails = API.CardDetails;
   export import CardsPage = API.CardsPage;
@@ -168,6 +297,11 @@ export namespace Increase {
   export import ExternalAccountUpdateParams = API.ExternalAccountUpdateParams;
   export import ExternalAccountListParams = API.ExternalAccountListParams;
 
+  export import Export = API.Export;
+  export import ExportsPage = API.ExportsPage;
+  export import ExportCreateParams = API.ExportCreateParams;
+  export import ExportListParams = API.ExportListParams;
+
   export import DigitalWalletToken = API.DigitalWalletToken;
   export import DigitalWalletTokensPage = API.DigitalWalletTokensPage;
   export import DigitalWalletTokenListParams = API.DigitalWalletTokenListParams;
@@ -180,6 +314,10 @@ export namespace Increase {
   export import PendingTransactionsPage = API.PendingTransactionsPage;
   export import PendingTransactionListParams = API.PendingTransactionListParams;
 
+  export import Program = API.Program;
+  export import ProgramsPage = API.ProgramsPage;
+  export import ProgramListParams = API.ProgramListParams;
+
   export import DeclinedTransaction = API.DeclinedTransaction;
   export import DeclinedTransactionsPage = API.DeclinedTransactionsPage;
   export import DeclinedTransactionListParams = API.DeclinedTransactionListParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "increase",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Client library for the Increase API",
   "author": "Increase <dev-feedback@increase.com>",
   "types": "dist/cjs/index.d.ts",
@@ -30,12 +30,12 @@
     "qs": "^6.10.3"
   },
   "devDependencies": {
+    "increase": "link:.",
     "@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",

package/pagination.ts

@@ -2,6 +2,9 @@
 
 import { AbstractPage, APIResponse, APIClient, FinalRequestOptions, PageInfo } from './core';
 
+/**
+ * A list of Account objects
+ */
 export interface PageResponse<Item> {
   data: Array<Item>;
 

package/release-please-config.json

@@ -0,0 +1,64 @@
+{
+  "packages": {
+    ".": {}
+  },
+  "$schema": "https://raw.githubusercontent.com/stainless-api/release-please/main/schemas/config.json",
+  "include-v-in-tag": true,
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": true,
+  "pull-request-header": "Automated Release PR",
+  "changelog-sections": [
+    {
+      "type": "feat",
+      "section": "Features"
+    },
+    {
+      "type": "fix",
+      "section": "Bug Fixes"
+    },
+    {
+      "type": "perf",
+      "section": "Performance Improvements"
+    },
+    {
+      "type": "revert",
+      "section": "Reverts"
+    },
+    {
+      "type": "chore",
+      "section": "Miscellaneous Chores",
+      "hidden": true
+    },
+    {
+      "type": "docs",
+      "section": "Documentation",
+      "hidden": true
+    },
+    {
+      "type": "style",
+      "section": "Styles",
+      "hidden": true
+    },
+    {
+      "type": "refactor",
+      "section": "Refactors"
+    },
+    {
+      "type": "test",
+      "section": "Tests",
+      "hidden": true
+    },
+    {
+      "type": "build",
+      "section": "Build System",
+      "hidden": true
+    },
+    {
+      "type": "ci",
+      "section": "Continuous Integration",
+      "hidden": true
+    }
+  ],
+  "release-type": "node",
+  "extra-files": ["version.ts"]
+}