increase 0.1.0

package/tests/api-resources/account-statements.test.ts

@@ -0,0 +1,64 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource account_statements', () => {
+  test('retrieve', async () => {
+    const response = await increase.accountStatements.retrieve('account_statement_lkc03a4skm2k7f38vj15');
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accountStatements.retrieve('account_statement_lkc03a4skm2k7f38vj15', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.accountStatements.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.accountStatements.list({
+      cursor: 'string',
+      limit: 0,
+      account_id: 'string',
+      statement_period_start: {
+        after: '2019-12-27T18:11:19.117Z',
+        before: '2019-12-27T18:11:19.117Z',
+        on_or_after: '2019-12-27T18:11:19.117Z',
+        on_or_before: '2019-12-27T18:11:19.117Z',
+      },
+    });
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(increase.accountStatements.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accountStatements.list(
+        {
+          cursor: 'string',
+          limit: 0,
+          account_id: 'string',
+          statement_period_start: {
+            after: '2019-12-27T18:11:19.117Z',
+            before: '2019-12-27T18:11:19.117Z',
+            on_or_after: '2019-12-27T18:11:19.117Z',
+            on_or_before: '2019-12-27T18:11:19.117Z',
+          },
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

package/tests/api-resources/account-transfers.test.ts

@@ -0,0 +1,109 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource account_transfers', () => {
+  test('create: only required params', async () => {
+    const response = await increase.accountTransfers.create({
+      account_id: 'account_in71c4amph0vgo2qllky',
+      amount: 100,
+      description: 'Creating liquidity',
+      destination_account_id: 'account_uf16sut2ct5bevmq3eh',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await increase.accountTransfers.create({
+      account_id: 'account_in71c4amph0vgo2qllky',
+      amount: 100,
+      description: 'Creating liquidity',
+      destination_account_id: 'account_uf16sut2ct5bevmq3eh',
+      require_approval: true,
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.accountTransfers.retrieve('account_transfer_7k9qe1ysdgqztnt63l7n');
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accountTransfers.retrieve('account_transfer_7k9qe1ysdgqztnt63l7n', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.accountTransfers.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.accountTransfers.list({
+      cursor: 'string',
+      limit: 0,
+      account_id: 'string',
+      created_at: {
+        after: '2019-12-27T18:11:19.117Z',
+        before: '2019-12-27T18:11:19.117Z',
+        on_or_after: '2019-12-27T18:11:19.117Z',
+        on_or_before: '2019-12-27T18:11:19.117Z',
+      },
+    });
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(increase.accountTransfers.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accountTransfers.list(
+        {
+          cursor: 'string',
+          limit: 0,
+          account_id: 'string',
+          created_at: {
+            after: '2019-12-27T18:11:19.117Z',
+            before: '2019-12-27T18:11:19.117Z',
+            on_or_after: '2019-12-27T18:11:19.117Z',
+            on_or_before: '2019-12-27T18:11:19.117Z',
+          },
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('approve', async () => {
+    const response = await increase.accountTransfers.approve('account_transfer_7k9qe1ysdgqztnt63l7n');
+  });
+
+  test('approve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accountTransfers.approve('account_transfer_7k9qe1ysdgqztnt63l7n', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('cancel', async () => {
+    const response = await increase.accountTransfers.cancel('account_transfer_7k9qe1ysdgqztnt63l7n');
+  });
+
+  test('cancel: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accountTransfers.cancel('account_transfer_7k9qe1ysdgqztnt63l7n', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

package/tests/api-resources/accounts.test.ts

@@ -0,0 +1,82 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource accounts', () => {
+  test('create: only required params', async () => {
+    const response = await increase.accounts.create({ name: 'New Account!' });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await increase.accounts.create({
+      entity_id: 'string',
+      informational_entity_id: 'string',
+      name: 'New Account!',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.accounts.retrieve('account_in71c4amph0vgo2qllky');
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accounts.retrieve('account_in71c4amph0vgo2qllky', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await increase.accounts.update('account_in71c4amph0vgo2qllky', {});
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await increase.accounts.update('account_in71c4amph0vgo2qllky', {
+      name: 'My renamed account',
+    });
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.accounts.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.accounts.list({
+      cursor: 'string',
+      limit: 0,
+      entity_id: 'string',
+      status: 'open',
+    });
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(increase.accounts.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accounts.list(
+        { cursor: 'string', limit: 0, entity_id: 'string', status: 'open' },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  // Prism tests are broken
+  test.skip('close', async () => {
+    const response = await increase.accounts.close('account_in71c4amph0vgo2qllky');
+  });
+
+  // Prism tests are broken
+  test.skip('close: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.accounts.close('account_in71c4amph0vgo2qllky', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

package/tests/api-resources/ach-prenotifications.test.ts

@@ -0,0 +1,86 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource ach_prenotifications', () => {
+  test('create: only required params', async () => {
+    const response = await increase.achPrenotifications.create({
+      account_number: '987654321',
+      routing_number: '101050001',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await increase.achPrenotifications.create({
+      account_number: '987654321',
+      addendum: 'x',
+      company_descriptive_date: 'x',
+      company_discretionary_data: 'x',
+      company_entry_description: 'x',
+      company_name: 'x',
+      credit_debit_indicator: 'credit',
+      effective_date: '2019-12-27',
+      individual_id: 'x',
+      individual_name: 'x',
+      routing_number: '101050001',
+      standard_entry_class_code: 'corporate_credit_or_debit',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.achPrenotifications.retrieve('ach_prenotification_ubjf9qqsxl3obbcn1u34');
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.achPrenotifications.retrieve('ach_prenotification_ubjf9qqsxl3obbcn1u34', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.achPrenotifications.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.achPrenotifications.list({
+      cursor: 'string',
+      limit: 0,
+      created_at: {
+        after: '2019-12-27T18:11:19.117Z',
+        before: '2019-12-27T18:11:19.117Z',
+        on_or_after: '2019-12-27T18:11:19.117Z',
+        on_or_before: '2019-12-27T18:11:19.117Z',
+      },
+    });
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(increase.achPrenotifications.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.achPrenotifications.list(
+        {
+          cursor: 'string',
+          limit: 0,
+          created_at: {
+            after: '2019-12-27T18:11:19.117Z',
+            before: '2019-12-27T18:11:19.117Z',
+            on_or_after: '2019-12-27T18:11:19.117Z',
+            on_or_before: '2019-12-27T18:11:19.117Z',
+          },
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

package/tests/api-resources/ach-transfers.test.ts

@@ -0,0 +1,120 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource ach_transfers', () => {
+  test('create: only required params', async () => {
+    const response = await increase.achTransfers.create({
+      account_id: 'account_in71c4amph0vgo2qllky',
+      amount: 100,
+      statement_descriptor: 'New ACH transfer',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await increase.achTransfers.create({
+      account_id: 'account_in71c4amph0vgo2qllky',
+      account_number: '987654321',
+      addendum: 'x',
+      amount: 100,
+      company_descriptive_date: 'x',
+      company_discretionary_data: 'x',
+      company_entry_description: 'x',
+      company_name: 'x',
+      effective_date: '2019-12-27',
+      external_account_id: 'string',
+      funding: 'checking',
+      individual_id: 'x',
+      individual_name: 'x',
+      require_approval: true,
+      routing_number: '101050001',
+      standard_entry_class_code: 'corporate_credit_or_debit',
+      statement_descriptor: 'New ACH transfer',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.achTransfers.retrieve('ach_transfer_uoxatyh3lt5evrsdvo7q');
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.achTransfers.retrieve('ach_transfer_uoxatyh3lt5evrsdvo7q', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.achTransfers.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.achTransfers.list({
+      cursor: 'string',
+      limit: 0,
+      account_id: 'string',
+      external_account_id: 'string',
+      created_at: {
+        after: '2019-12-27T18:11:19.117Z',
+        before: '2019-12-27T18:11:19.117Z',
+        on_or_after: '2019-12-27T18:11:19.117Z',
+        on_or_before: '2019-12-27T18:11:19.117Z',
+      },
+    });
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(increase.achTransfers.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.achTransfers.list(
+        {
+          cursor: 'string',
+          limit: 0,
+          account_id: 'string',
+          external_account_id: 'string',
+          created_at: {
+            after: '2019-12-27T18:11:19.117Z',
+            before: '2019-12-27T18:11:19.117Z',
+            on_or_after: '2019-12-27T18:11:19.117Z',
+            on_or_before: '2019-12-27T18:11:19.117Z',
+          },
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('approve', async () => {
+    const response = await increase.achTransfers.approve('ach_transfer_uoxatyh3lt5evrsdvo7q');
+  });
+
+  test('approve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.achTransfers.approve('ach_transfer_uoxatyh3lt5evrsdvo7q', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('cancel', async () => {
+    const response = await increase.achTransfers.cancel('ach_transfer_uoxatyh3lt5evrsdvo7q');
+  });
+
+  test('cancel: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.achTransfers.cancel('ach_transfer_uoxatyh3lt5evrsdvo7q', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

package/tests/api-resources/card-disputes.test.ts

@@ -0,0 +1,71 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource card_disputes', () => {
+  test('create', async () => {
+    const response = await increase.cardDisputes.create({
+      disputed_transaction_id: 'transaction_uyrp7fld2ium70oa7oi',
+      explanation: 'Unauthorized recurring transaction.',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.cardDisputes.retrieve('card_dispute_h9sc95nbl1cgltpp7men');
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.cardDisputes.retrieve('card_dispute_h9sc95nbl1cgltpp7men', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.cardDisputes.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.cardDisputes.list({
+      cursor: 'string',
+      limit: 0,
+      created_at: {
+        after: '2019-12-27T18:11:19.117Z',
+        before: '2019-12-27T18:11:19.117Z',
+        on_or_after: '2019-12-27T18:11:19.117Z',
+        on_or_before: '2019-12-27T18:11:19.117Z',
+      },
+      status: { in: ['pending_reviewing', 'pending_reviewing', 'pending_reviewing'] },
+    });
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(increase.cardDisputes.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.cardDisputes.list(
+        {
+          cursor: 'string',
+          limit: 0,
+          created_at: {
+            after: '2019-12-27T18:11:19.117Z',
+            before: '2019-12-27T18:11:19.117Z',
+            on_or_after: '2019-12-27T18:11:19.117Z',
+            on_or_before: '2019-12-27T18:11:19.117Z',
+          },
+          status: { in: ['pending_reviewing', 'pending_reviewing', 'pending_reviewing'] },
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

package/tests/api-resources/card-profiles.test.ts

@@ -0,0 +1,60 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource card_profiles', () => {
+  test('create', async () => {
+    const response = await increase.cardProfiles.create({
+      description: 'My Card Profile',
+      digital_wallets: {
+        issuer_name: 'MyBank',
+        card_description: 'MyBank Signature Card',
+        background_image_file_id: 'file_1ai913suu1zfn1pdetru',
+        app_icon_file_id: 'file_8zxqkwlh43wo144u8yec',
+      },
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.cardProfiles.retrieve('card_profile_cox5y73lob2eqly18piy');
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.cardProfiles.retrieve('card_profile_cox5y73lob2eqly18piy', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.cardProfiles.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.cardProfiles.list({
+      cursor: 'string',
+      limit: 0,
+      status: { in: ['pending', 'pending', 'pending'] },
+    });
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(increase.cardProfiles.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      increase.cardProfiles.list(
+        { cursor: 'string', limit: 0, status: { in: ['pending', 'pending', 'pending'] } },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});