modern-treasury 0.0.1

package/tests/api-resources/incoming-payment-details.test.ts

@@ -0,0 +1,92 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource incoming_payment_details', () => {
+  test('retrieve', async () => {
+    const response = await modernTreasury.incomingPaymentDetails.retrieve('string');
+  });
+
+  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(
+      modernTreasury.incomingPaymentDetails.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await modernTreasury.incomingPaymentDetails.update('string');
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await modernTreasury.incomingPaymentDetails.update('string', { metadata: {} });
+  });
+
+  test('update: 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(
+      modernTreasury.incomingPaymentDetails.update('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: 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(
+      modernTreasury.incomingPaymentDetails.update(
+        'string',
+        { metadata: {} },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.incomingPaymentDetails.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.incomingPaymentDetails.list({
+      after_cursor: 'string',
+      per_page: 0,
+      direction: 'credit',
+      status: 'completed',
+      type: 'ach',
+      as_of_date_start: '2019-12-27',
+      as_of_date_end: '2019-12-27',
+      metadata: {},
+      virtual_account_id: 'string',
+    });
+  });
+
+  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(
+      modernTreasury.incomingPaymentDetails.list({ path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.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(
+      modernTreasury.incomingPaymentDetails.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          direction: 'credit',
+          status: 'completed',
+          type: 'ach',
+          as_of_date_start: '2019-12-27',
+          as_of_date_end: '2019-12-27',
+          metadata: {},
+          virtual_account_id: 'string',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

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

@@ -0,0 +1,103 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource internal_accounts', () => {
+  test('create: only required params', async () => {
+    const response = await modernTreasury.internalAccounts.create({
+      connection_id: 'string',
+      name: 'string',
+      party_name: 'string',
+      currency: 'USD',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await modernTreasury.internalAccounts.create({
+      connection_id: 'string',
+      name: 'string',
+      party_name: 'string',
+      currency: 'USD',
+      entity_id: 'string',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await modernTreasury.internalAccounts.retrieve('string');
+  });
+
+  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(
+      modernTreasury.internalAccounts.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await modernTreasury.internalAccounts.update('string');
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await modernTreasury.internalAccounts.update('string', { name: 'string', metadata: {} });
+  });
+
+  test('update: 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(
+      modernTreasury.internalAccounts.update('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: 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(
+      modernTreasury.internalAccounts.update(
+        'string',
+        { name: 'string', metadata: {} },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.internalAccounts.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.internalAccounts.list({
+      after_cursor: 'string',
+      per_page: 0,
+      currency: 'AED',
+      payment_type: 'ach',
+      payment_direction: 'credit',
+    });
+  });
+
+  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(modernTreasury.internalAccounts.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      ModernTreasury.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(
+      modernTreasury.internalAccounts.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          currency: 'AED',
+          payment_type: 'ach',
+          payment_direction: 'credit',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

package/tests/api-resources/line-items.test.ts

@@ -0,0 +1,85 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource line_items', () => {
+  test('retrieve', async () => {
+    const response = await modernTreasury.lineItems.retrieve('expected_payments', 'string', 'string');
+  });
+
+  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(
+      modernTreasury.lineItems.retrieve('expected_payments', 'string', 'string', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await modernTreasury.lineItems.update('expected_payments', 'string', 'string');
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await modernTreasury.lineItems.update('expected_payments', 'string', 'string', {
+      metadata: {},
+    });
+  });
+
+  test('update: 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(
+      modernTreasury.lineItems.update('expected_payments', 'string', 'string', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: 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(
+      modernTreasury.lineItems.update(
+        'expected_payments',
+        'string',
+        'string',
+        { metadata: {} },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.lineItems.list('expected_payments', 'string');
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.lineItems.list('expected_payments', 'string', {
+      after_cursor: 'string',
+      per_page: 0,
+    });
+  });
+
+  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(
+      modernTreasury.lineItems.list('expected_payments', 'string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.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(
+      modernTreasury.lineItems.list(
+        'expected_payments',
+        'string',
+        { after_cursor: 'string', per_page: 0 },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

package/tests/api-resources/paper-items.test.ts

@@ -0,0 +1,58 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource paper_items', () => {
+  test('retrieve', async () => {
+    const response = await modernTreasury.paperItems.retrieve('string');
+  });
+
+  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(
+      modernTreasury.paperItems.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.paperItems.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.paperItems.list({
+      lockbox_number: 'string',
+      deposit_date_start: '2019-12-27',
+      deposit_date_end: '2019-12-27',
+      after_cursor: 'string',
+      per_page: 0,
+    });
+  });
+
+  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(modernTreasury.paperItems.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      ModernTreasury.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(
+      modernTreasury.paperItems.list(
+        {
+          lockbox_number: 'string',
+          deposit_date_start: '2019-12-27',
+          deposit_date_end: '2019-12-27',
+          after_cursor: 'string',
+          per_page: 0,
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

package/tests/api-resources/payment-orders/payment-orders.test.ts

@@ -0,0 +1,39 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource reversals', () => {
+  test('list: only required params', async () => {
+    const response = await modernTreasury.paymentOrders.reversals.list('string');
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.paymentOrders.reversals.list('string', {
+      after_cursor: 'string',
+      per_page: 0,
+    });
+  });
+
+  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(
+      modernTreasury.paymentOrders.reversals.list('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.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(
+      modernTreasury.paymentOrders.reversals.list(
+        'string',
+        { after_cursor: 'string', per_page: 0 },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

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

@@ -0,0 +1,78 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource returns', () => {
+  test('create: only required params', async () => {
+    const response = await modernTreasury.returns.create({
+      returnable_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      returnable_type: 'incoming_payment_detail',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await modernTreasury.returns.create({
+      returnable_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      code: '901',
+      reason: 'string',
+      date_of_death: '2019-12-27',
+      additional_information: 'string',
+      returnable_type: 'incoming_payment_detail',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await modernTreasury.returns.retrieve('string');
+  });
+
+  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(
+      modernTreasury.returns.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.returns.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.returns.list({
+      after_cursor: 'string',
+      per_page: 0,
+      internal_account_id: 'string',
+      counterparty_id: 'string',
+      returnable_id: 'string',
+      returnable_type: 'incoming_payment_detail',
+    });
+  });
+
+  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(modernTreasury.returns.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      ModernTreasury.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(
+      modernTreasury.returns.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          internal_account_id: 'string',
+          counterparty_id: 'string',
+          returnable_id: 'string',
+          returnable_type: 'incoming_payment_detail',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

package/tests/api-resources/top-level.test.ts

@@ -0,0 +1,21 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource top_level', () => {
+  test('ping', async () => {
+    const response = await modernTreasury.ping();
+  });
+
+  test('ping: 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(modernTreasury.ping({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      ModernTreasury.NotFoundError,
+    );
+  });
+});

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

@@ -0,0 +1,96 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource transactions', () => {
+  test('retrieve', async () => {
+    const response = await modernTreasury.transactions.retrieve('string');
+  });
+
+  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(
+      modernTreasury.transactions.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await modernTreasury.transactions.update('string');
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await modernTreasury.transactions.update('string', { metadata: {} });
+  });
+
+  test('update: 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(
+      modernTreasury.transactions.update('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: 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(
+      modernTreasury.transactions.update('string', { metadata: {} }, { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.transactions.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.transactions.list({
+      after_cursor: 'string',
+      per_page: 0,
+      internal_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      virtual_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      posted: true,
+      as_of_date_start: '2019-12-27',
+      as_of_date_end: '2019-12-27',
+      direction: 'string',
+      counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      payment_type: 'string',
+      transactable_type: 'string',
+      description: 'string',
+      metadata: {},
+    });
+  });
+
+  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(modernTreasury.transactions.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      ModernTreasury.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(
+      modernTreasury.transactions.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          internal_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+          virtual_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+          posted: true,
+          as_of_date_start: '2019-12-27',
+          as_of_date_end: '2019-12-27',
+          direction: 'string',
+          counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+          payment_type: 'string',
+          transactable_type: 'string',
+          description: 'string',
+          metadata: {},
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

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

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import ModernTreasury from '~/index';
+const modernTreasury = new ModernTreasury({
+  apiKey: 'something1234',
+  baseURL: 'http://127.0.0.1:4010',
+  organizationId: 'c40c0b40-11d3-42ee-8f2e-18ee8b8239aa',
+});
+
+describe('resource validations', () => {
+  test('validate_routing_number: only required params', async () => {
+    const response = await modernTreasury.validations.validateRoutingNumber({
+      routing_number: 'string',
+      routing_number_type: 'aba',
+    });
+  });
+
+  test('validate_routing_number: required and optional params', async () => {
+    const response = await modernTreasury.validations.validateRoutingNumber({
+      routing_number: 'string',
+      routing_number_type: 'aba',
+    });
+  });
+});