increase 0.59.1 → 0.61.0

package/src/resources/{intrafi/exclusions.ts → intrafi-exclusions.ts}

@@ -1,16 +1,19 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../resource';
-import { isRequestOptions } from '../../core';
-import * as Core from '../../core';
-import * as ExclusionsAPI from './exclusions';
-import { Page, type PageParams } from '../../pagination';
+import { APIResource } from '../resource';
+import { isRequestOptions } from '../core';
+import * as Core from '../core';
+import * as IntrafiExclusionsAPI from './intrafi-exclusions';
+import { Page, type PageParams } from '../pagination';
 
-export class Exclusions extends APIResource {
+export class IntrafiExclusions extends APIResource {
   /**
    * Create an IntraFi Exclusion
    */
-  create(body: ExclusionCreateParams, options?: Core.RequestOptions): Core.APIPromise<IntrafiExclusion> {
+  create(
+    body: IntrafiExclusionCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<IntrafiExclusion> {
     return this._client.post('/intrafi_exclusions', { body, ...options });
   }
 
@@ -25,12 +28,12 @@ export class Exclusions extends APIResource {
    * List IntraFi Exclusions.
    */
   list(
-    query?: ExclusionListParams,
+    query?: IntrafiExclusionListParams,
     options?: Core.RequestOptions,
   ): Core.PagePromise<IntrafiExclusionsPage, IntrafiExclusion>;
   list(options?: Core.RequestOptions): Core.PagePromise<IntrafiExclusionsPage, IntrafiExclusion>;
   list(
-    query: ExclusionListParams | Core.RequestOptions = {},
+    query: IntrafiExclusionListParams | Core.RequestOptions = {},
     options?: Core.RequestOptions,
   ): Core.PagePromise<IntrafiExclusionsPage, IntrafiExclusion> {
     if (isRequestOptions(query)) {
@@ -110,7 +113,7 @@ export interface IntrafiExclusion {
   type: 'intrafi_exclusion';
 }
 
-export interface ExclusionCreateParams {
+export interface IntrafiExclusionCreateParams {
   /**
    * The name of the financial institution to be excluded.
    */
@@ -122,7 +125,7 @@ export interface ExclusionCreateParams {
   entity_id: string;
 }
 
-export interface ExclusionListParams extends PageParams {
+export interface IntrafiExclusionListParams extends PageParams {
   /**
    * Filter IntraFi Exclusions for those belonging to the specified Entity.
    */
@@ -137,9 +140,9 @@ export interface ExclusionListParams extends PageParams {
   idempotency_key?: string;
 }
 
-export namespace Exclusions {
-  export import IntrafiExclusion = ExclusionsAPI.IntrafiExclusion;
-  export import IntrafiExclusionsPage = ExclusionsAPI.IntrafiExclusionsPage;
-  export import ExclusionCreateParams = ExclusionsAPI.ExclusionCreateParams;
-  export import ExclusionListParams = ExclusionsAPI.ExclusionListParams;
+export namespace IntrafiExclusions {
+  export import IntrafiExclusion = IntrafiExclusionsAPI.IntrafiExclusion;
+  export import IntrafiExclusionsPage = IntrafiExclusionsAPI.IntrafiExclusionsPage;
+  export import IntrafiExclusionCreateParams = IntrafiExclusionsAPI.IntrafiExclusionCreateParams;
+  export import IntrafiExclusionListParams = IntrafiExclusionsAPI.IntrafiExclusionListParams;
 }

package/src/resources/lockboxes.ts

@@ -139,21 +139,6 @@ export namespace Lockbox {
   }
 }
 
-/**
- * A list of Lockbox objects.
- */
-export interface LockboxList {
-  /**
-   * The contents of the list.
-   */
-  data: Array<Lockbox>;
-
-  /**
-   * A pointer to a place in the list.
-   */
-  next_cursor: string | null;
-}
-
 export interface LockboxCreateParams {
   /**
    * The Account checks sent to this Lockbox should be deposited into.
@@ -230,7 +215,6 @@ export namespace LockboxListParams {
 
 export namespace Lockboxes {
   export import Lockbox = LockboxesAPI.Lockbox;
-  export import LockboxList = LockboxesAPI.LockboxList;
   export import LockboxesPage = LockboxesAPI.LockboxesPage;
   export import LockboxCreateParams = LockboxesAPI.LockboxCreateParams;
   export import LockboxUpdateParams = LockboxesAPI.LockboxUpdateParams;

package/src/resources/routing-numbers.ts

@@ -15,17 +15,17 @@ export class RoutingNumbers extends APIResource {
   list(
     query: RoutingNumberListParams,
     options?: Core.RequestOptions,
-  ): Core.PagePromise<RoutingNumbersPage, RoutingNumber> {
-    return this._client.getAPIList('/routing_numbers', RoutingNumbersPage, { query, ...options });
+  ): Core.PagePromise<RoutingNumberListResponsesPage, RoutingNumberListResponse> {
+    return this._client.getAPIList('/routing_numbers', RoutingNumberListResponsesPage, { query, ...options });
   }
 }
 
-export class RoutingNumbersPage extends Page<RoutingNumber> {}
+export class RoutingNumberListResponsesPage extends Page<RoutingNumberListResponse> {}
 
 /**
  * Routing numbers are used to identify your bank in a financial transaction.
  */
-export interface RoutingNumber {
+export interface RoutingNumberListResponse {
   /**
    * This routing number's support for ACH Transfers.
    *
@@ -75,7 +75,7 @@ export interface RoutingNumberListParams extends PageParams {
 }
 
 export namespace RoutingNumbers {
-  export import RoutingNumber = RoutingNumbersAPI.RoutingNumber;
-  export import RoutingNumbersPage = RoutingNumbersAPI.RoutingNumbersPage;
+  export import RoutingNumberListResponse = RoutingNumbersAPI.RoutingNumberListResponse;
+  export import RoutingNumberListResponsesPage = RoutingNumbersAPI.RoutingNumberListResponsesPage;
   export import RoutingNumberListParams = RoutingNumbersAPI.RoutingNumberListParams;
 }

package/src/resources/simulations/ach-transfers.ts

@@ -4,38 +4,33 @@ import { APIResource } from '../../resource';
 import * as Core from '../../core';
 import * as SimulationsACHTransfersAPI from './ach-transfers';
 import * as ACHTransfersAPI from '../ach-transfers';
-import * as InboundACHTransfersAPI from '../inbound-ach-transfers';
 
 export class ACHTransfers extends APIResource {
   /**
-   * Simulates an inbound ACH transfer to your account. This imitates initiating a
-   * transfer to an Increase account from a different financial institution. The
-   * transfer may be either a credit or a debit depending on if the `amount` is
-   * positive or negative. The result of calling this API will contain the created
-   * transfer. You can pass a `resolve_at` parameter to allow for a window to
-   * [action on the Inbound ACH Transfer](https://increase.com/documentation/receiving-ach-transfers).
-   * Alternatively, if you don't pass the `resolve_at` parameter the result will
-   * contain either a [Transaction](#transactions) or a
-   * [Declined Transaction](#declined-transactions) depending on whether or not the
-   * transfer is allowed.
+   * Simulates the acknowledgement of an [ACH Transfer](#ach-transfers) by the
+   * Federal Reserve. This transfer must first have a `status` of `submitted` . In
+   * production, the Federal Reserve generally acknowledges submitted ACH files
+   * within 30 minutes. Since sandbox ACH Transfers are not submitted to the Federal
+   * Reserve, this endpoint allows you to skip that delay and add the acknowledgment
+   * subresource to the ACH Transfer.
    */
-  createInbound(
-    body: ACHTransferCreateInboundParams,
+  acknowledge(
+    achTransferId: string,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<InboundACHTransfersAPI.InboundACHTransfer> {
-    return this._client.post('/simulations/inbound_ach_transfers', { body, ...options });
+  ): Core.APIPromise<ACHTransfersAPI.ACHTransfer> {
+    return this._client.post(`/simulations/ach_transfers/${achTransferId}/acknowledge`, options);
   }
 
   /**
    * Simulates receiving a Notification of Change for an
    * [ACH Transfer](#ach-transfers).
    */
-  notificationOfChange(
+  createNotificationOfChange(
     achTransferId: string,
-    body: ACHTransferNotificationOfChangeParams,
+    body: ACHTransferCreateNotificationOfChangeParams,
     options?: Core.RequestOptions,
   ): Core.APIPromise<ACHTransfersAPI.ACHTransfer> {
-    return this._client.post(`/simulations/ach_transfers/${achTransferId}/notification_of_change`, {
+    return this._client.post(`/simulations/ach_transfers/${achTransferId}/create_notification_of_change`, {
       body,
       ...options,
     });
@@ -67,62 +62,7 @@ export class ACHTransfers extends APIResource {
   }
 }
 
-export interface ACHTransferCreateInboundParams {
-  /**
-   * The identifier of the Account Number the inbound ACH Transfer is for.
-   */
-  account_number_id: string;
-
-  /**
-   * The transfer amount in cents. A positive amount originates a credit transfer
-   * pushing funds to the receiving account. A negative amount originates a debit
-   * transfer pulling funds from the receiving account.
-   */
-  amount: number;
-
-  /**
-   * The description of the date of the transfer.
-   */
-  company_descriptive_date?: string;
-
-  /**
-   * Data associated with the transfer set by the sender.
-   */
-  company_discretionary_data?: string;
-
-  /**
-   * The description of the transfer set by the sender.
-   */
-  company_entry_description?: string;
-
-  /**
-   * The sender's company ID.
-   */
-  company_id?: string;
-
-  /**
-   * The name of the sender.
-   */
-  company_name?: string;
-
-  /**
-   * The ID of the receiver of the transfer.
-   */
-  receiver_id_number?: string;
-
-  /**
-   * The name of the receiver of the transfer.
-   */
-  receiver_name?: string;
-
-  /**
-   * The time at which the transfer should be resolved. If not provided will resolve
-   * immediately.
-   */
-  resolve_at?: string;
-}
-
-export interface ACHTransferNotificationOfChangeParams {
+export interface ACHTransferCreateNotificationOfChangeParams {
   /**
    * The reason for the notification of change.
    *
@@ -415,7 +355,6 @@ export interface ACHTransferReturnParams {
 }
 
 export namespace ACHTransfers {
-  export import ACHTransferCreateInboundParams = SimulationsACHTransfersAPI.ACHTransferCreateInboundParams;
-  export import ACHTransferNotificationOfChangeParams = SimulationsACHTransfersAPI.ACHTransferNotificationOfChangeParams;
+  export import ACHTransferCreateNotificationOfChangeParams = SimulationsACHTransfersAPI.ACHTransferCreateNotificationOfChangeParams;
   export import ACHTransferReturnParams = SimulationsACHTransfersAPI.ACHTransferReturnParams;
 }

package/src/resources/simulations/card-authorization-expirations.ts

@@ -0,0 +1,29 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as CardAuthorizationExpirationsAPI from './card-authorization-expirations';
+import * as CardPaymentsAPI from '../card-payments';
+
+export class CardAuthorizationExpirations extends APIResource {
+  /**
+   * Simulates expiring a card authorization immediately.
+   */
+  create(
+    body: CardAuthorizationExpirationCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<CardPaymentsAPI.CardPayment> {
+    return this._client.post('/simulations/card_authorization_expirations', { body, ...options });
+  }
+}
+
+export interface CardAuthorizationExpirationCreateParams {
+  /**
+   * The identifier of the Card Payment to expire.
+   */
+  card_payment_id: string;
+}
+
+export namespace CardAuthorizationExpirations {
+  export import CardAuthorizationExpirationCreateParams = CardAuthorizationExpirationsAPI.CardAuthorizationExpirationCreateParams;
+}

package/src/resources/simulations/card-authorizations.ts

@@ -0,0 +1,112 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as CardAuthorizationsAPI from './card-authorizations';
+import * as DeclinedTransactionsAPI from '../declined-transactions';
+import * as PendingTransactionsAPI from '../pending-transactions';
+
+export class CardAuthorizations extends APIResource {
+  /**
+   * Simulates a purchase authorization on a [Card](#cards). Depending on the balance
+   * available to the card and the `amount` submitted, the authorization activity
+   * will result in a [Pending Transaction](#pending-transactions) of type
+   * `card_authorization` or a [Declined Transaction](#declined-transactions) of type
+   * `card_decline`. You can pass either a Card id or a
+   * [Digital Wallet Token](#digital-wallet-tokens) id to simulate the two different
+   * ways purchases can be made.
+   */
+  create(
+    body: CardAuthorizationCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<CardAuthorizationCreateResponse> {
+    return this._client.post('/simulations/card_authorizations', { body, ...options });
+  }
+}
+
+/**
+ * The results of a Card Authorization simulation.
+ */
+export interface CardAuthorizationCreateResponse {
+  /**
+   * If the authorization attempt fails, this will contain the resulting
+   * [Declined Transaction](#declined-transactions) object. The Declined
+   * Transaction's `source` will be of `category: card_decline`.
+   */
+  declined_transaction: DeclinedTransactionsAPI.DeclinedTransaction | null;
+
+  /**
+   * If the authorization attempt succeeds, this will contain the resulting Pending
+   * Transaction object. The Pending Transaction's `source` will be of
+   * `category: card_authorization`.
+   */
+  pending_transaction: PendingTransactionsAPI.PendingTransaction | null;
+
+  /**
+   * A constant representing the object's type. For this resource it will always be
+   * `inbound_card_authorization_simulation_result`.
+   */
+  type: 'inbound_card_authorization_simulation_result';
+}
+
+export interface CardAuthorizationCreateParams {
+  /**
+   * The authorization amount in cents.
+   */
+  amount: number;
+
+  /**
+   * The identifier of the Card to be authorized.
+   */
+  card_id?: string;
+
+  /**
+   * The identifier of the Digital Wallet Token to be authorized.
+   */
+  digital_wallet_token_id?: string;
+
+  /**
+   * The identifier of the Event Subscription to use. If provided, will override the
+   * default real time event subscription. Because you can only create one real time
+   * decision event subscription, you can use this field to route events to any
+   * specified event subscription for testing purposes.
+   */
+  event_subscription_id?: string;
+
+  /**
+   * The merchant identifier (commonly abbreviated as MID) of the merchant the card
+   * is transacting with.
+   */
+  merchant_acceptor_id?: string;
+
+  /**
+   * The Merchant Category Code (commonly abbreviated as MCC) of the merchant the
+   * card is transacting with.
+   */
+  merchant_category_code?: string;
+
+  /**
+   * The city the merchant resides in.
+   */
+  merchant_city?: string;
+
+  /**
+   * The country the merchant resides in.
+   */
+  merchant_country?: string;
+
+  /**
+   * The merchant descriptor of the merchant the card is transacting with.
+   */
+  merchant_descriptor?: string;
+
+  /**
+   * The identifier of the Physical Card to be authorized.
+   */
+  physical_card_id?: string;
+}
+
+export namespace CardAuthorizations {
+  export import CardAuthorizationCreateResponse = CardAuthorizationsAPI.CardAuthorizationCreateResponse;
+  export import CardAuthorizationCreateParams = CardAuthorizationsAPI.CardAuthorizationCreateParams;
+}

package/src/resources/simulations/card-fuel-confirmations.ts

@@ -0,0 +1,37 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as CardFuelConfirmationsAPI from './card-fuel-confirmations';
+import * as CardPaymentsAPI from '../card-payments';
+
+export class CardFuelConfirmations extends APIResource {
+  /**
+   * Simulates the fuel confirmation of an authorization by a card acquirer. This
+   * happens asynchronously right after a fuel pump transaction is completed. A fuel
+   * confirmation can only happen once per authorization.
+   */
+  create(
+    body: CardFuelConfirmationCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<CardPaymentsAPI.CardPayment> {
+    return this._client.post('/simulations/card_fuel_confirmations', { body, ...options });
+  }
+}
+
+export interface CardFuelConfirmationCreateParams {
+  /**
+   * The amount of the fuel_confirmation in minor units in the card authorization's
+   * currency.
+   */
+  amount: number;
+
+  /**
+   * The identifier of the Card Payment to create a fuel_confirmation on.
+   */
+  card_payment_id: string;
+}
+
+export namespace CardFuelConfirmations {
+  export import CardFuelConfirmationCreateParams = CardFuelConfirmationsAPI.CardFuelConfirmationCreateParams;
+}

package/src/resources/simulations/card-increments.ts

@@ -0,0 +1,43 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as CardIncrementsAPI from './card-increments';
+import * as CardPaymentsAPI from '../card-payments';
+
+export class CardIncrements extends APIResource {
+  /**
+   * Simulates the increment of an authorization by a card acquirer. An authorization
+   * can be incremented multiple times.
+   */
+  create(
+    body: CardIncrementCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<CardPaymentsAPI.CardPayment> {
+    return this._client.post('/simulations/card_increments', { body, ...options });
+  }
+}
+
+export interface CardIncrementCreateParams {
+  /**
+   * The amount of the increment in minor units in the card authorization's currency.
+   */
+  amount: number;
+
+  /**
+   * The identifier of the Card Payment to create a increment on.
+   */
+  card_payment_id: string;
+
+  /**
+   * The identifier of the Event Subscription to use. If provided, will override the
+   * default real time event subscription. Because you can only create one real time
+   * decision event subscription, you can use this field to route events to any
+   * specified event subscription for testing purposes.
+   */
+  event_subscription_id?: string;
+}
+
+export namespace CardIncrements {
+  export import CardIncrementCreateParams = CardIncrementsAPI.CardIncrementCreateParams;
+}

package/src/resources/simulations/card-reversals.ts

@@ -0,0 +1,38 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as CardReversalsAPI from './card-reversals';
+import * as CardPaymentsAPI from '../card-payments';
+
+export class CardReversals extends APIResource {
+  /**
+   * Simulates the reversal of an authorization by a card acquirer. An authorization
+   * can be partially reversed multiple times, up until the total authorized amount.
+   * Marks the pending transaction as complete if the authorization is fully
+   * reversed.
+   */
+  create(
+    body: CardReversalCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<CardPaymentsAPI.CardPayment> {
+    return this._client.post('/simulations/card_reversals', { body, ...options });
+  }
+}
+
+export interface CardReversalCreateParams {
+  /**
+   * The identifier of the Card Payment to create a reversal on.
+   */
+  card_payment_id: string;
+
+  /**
+   * The amount of the reversal in minor units in the card authorization's currency.
+   * This defaults to the authorization amount.
+   */
+  amount?: number;
+}
+
+export namespace CardReversals {
+  export import CardReversalCreateParams = CardReversalsAPI.CardReversalCreateParams;
+}

package/src/resources/simulations/card-settlements.ts

@@ -0,0 +1,45 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import * as CardSettlementsAPI from './card-settlements';
+import * as TransactionsAPI from '../transactions';
+
+export class CardSettlements extends APIResource {
+  /**
+   * Simulates the settlement of an authorization by a card acquirer. After a card
+   * authorization is created, the merchant will eventually send a settlement. This
+   * simulates that event, which may occur many days after the purchase in
+   * production. The amount settled can be different from the amount originally
+   * authorized, for example, when adding a tip to a restaurant bill.
+   */
+  create(
+    body: CardSettlementCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<TransactionsAPI.Transaction> {
+    return this._client.post('/simulations/card_settlements', { body, ...options });
+  }
+}
+
+export interface CardSettlementCreateParams {
+  /**
+   * The identifier of the Card to create a settlement on.
+   */
+  card_id: string;
+
+  /**
+   * The identifier of the Pending Transaction for the Card Authorization you wish to
+   * settle.
+   */
+  pending_transaction_id: string;
+
+  /**
+   * The amount to be settled. This defaults to the amount of the Pending Transaction
+   * being settled.
+   */
+  amount?: number;
+}
+
+export namespace CardSettlements {
+  export import CardSettlementCreateParams = CardSettlementsAPI.CardSettlementCreateParams;
+}