modern-treasury 0.0.1

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

@@ -0,0 +1,237 @@
+// 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 counterparties', () => {
+  test('create: only required params', async () => {
+    const response = await modernTreasury.counterparties.create({ name: 'string' });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await modernTreasury.counterparties.create({
+      name: 'string',
+      accounts: [
+        {
+          account_type: 'checking',
+          party_type: 'business',
+          party_address: {
+            line1: 'string',
+            line2: 'string',
+            locality: 'string',
+            region: 'string',
+            postal_code: 'string',
+            country: 'string',
+          },
+          name: 'string',
+          account_details: [
+            { account_number: 'string', account_number_type: 'iban' },
+            { account_number: 'string', account_number_type: 'iban' },
+            { account_number: 'string', account_number_type: 'iban' },
+          ],
+          routing_details: [
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+          ],
+          metadata: {},
+          party_name: 'string',
+          party_identifier: 'string',
+          plaid_processor_token: 'string',
+          contact_details: [
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+          ],
+        },
+        {
+          account_type: 'checking',
+          party_type: 'business',
+          party_address: {
+            line1: 'string',
+            line2: 'string',
+            locality: 'string',
+            region: 'string',
+            postal_code: 'string',
+            country: 'string',
+          },
+          name: 'string',
+          account_details: [
+            { account_number: 'string', account_number_type: 'iban' },
+            { account_number: 'string', account_number_type: 'iban' },
+            { account_number: 'string', account_number_type: 'iban' },
+          ],
+          routing_details: [
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+          ],
+          metadata: {},
+          party_name: 'string',
+          party_identifier: 'string',
+          plaid_processor_token: 'string',
+          contact_details: [
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+          ],
+        },
+        {
+          account_type: 'checking',
+          party_type: 'business',
+          party_address: {
+            line1: 'string',
+            line2: 'string',
+            locality: 'string',
+            region: 'string',
+            postal_code: 'string',
+            country: 'string',
+          },
+          name: 'string',
+          account_details: [
+            { account_number: 'string', account_number_type: 'iban' },
+            { account_number: 'string', account_number_type: 'iban' },
+            { account_number: 'string', account_number_type: 'iban' },
+          ],
+          routing_details: [
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+            { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+          ],
+          metadata: {},
+          party_name: 'string',
+          party_identifier: 'string',
+          plaid_processor_token: 'string',
+          contact_details: [
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+            { contact_identifier: 'string', contact_identifier_type: 'email' },
+          ],
+        },
+      ],
+      email: 'dev@stainlessapi.com',
+      metadata: {},
+      send_remittance_advice: true,
+      ledger_type: 'customer',
+      taxpayer_identifier: 'string',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await modernTreasury.counterparties.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.counterparties.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await modernTreasury.counterparties.update('string');
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await modernTreasury.counterparties.update('string', {
+      name: 'string',
+      email: 'dev@stainlessapi.com',
+      metadata: {},
+      send_remittance_advice: true,
+      taxpayer_identifier: 'string',
+    });
+  });
+
+  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.counterparties.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.counterparties.update(
+        'string',
+        {
+          name: 'string',
+          email: 'dev@stainlessapi.com',
+          metadata: {},
+          send_remittance_advice: true,
+          taxpayer_identifier: 'string',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.counterparties.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.counterparties.list({
+      after_cursor: 'string',
+      per_page: 0,
+      name: 'string',
+      email: 'dev@stainlessapi.com',
+      metadata: {},
+      created_at_lower_bound: '2019-12-27T18:11:19.117Z',
+      created_at_upper_bound: '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(modernTreasury.counterparties.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.counterparties.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          name: 'string',
+          email: 'dev@stainlessapi.com',
+          metadata: {},
+          created_at_lower_bound: '2019-12-27T18:11:19.117Z',
+          created_at_upper_bound: '2019-12-27T18:11:19.117Z',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('delete', async () => {
+    const response = await modernTreasury.counterparties.del('string');
+  });
+
+  test('delete: 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.counterparties.del('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('collect_account: only required params', async () => {
+    const response = await modernTreasury.counterparties.collectAccount('string', { direction: 'credit' });
+  });
+
+  test('collect_account: required and optional params', async () => {
+    const response = await modernTreasury.counterparties.collectAccount('string', {
+      direction: 'credit',
+      send_email: true,
+      fields: ['name', 'name', 'name'],
+      custom_redirect: 'https://example.com',
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+// 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 documents', () => {
+  test('list: only required params', async () => {
+    const response = await modernTreasury.documents.list('cases', 'string');
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.documents.list('cases', '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.documents.list('cases', '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.documents.list(
+        'cases',
+        'string',
+        { after_cursor: 'string', per_page: 0 },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

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

@@ -0,0 +1,62 @@
+// 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 events', () => {
+  test('retrieve', async () => {
+    const response = await modernTreasury.events.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.events.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.events.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.events.list({
+      after_cursor: 'string',
+      per_page: 0,
+      event_time_start: '2019-12-27T18:11:19.117Z',
+      event_time_end: '2019-12-27T18:11:19.117Z',
+      resource: 'string',
+      entity_id: 'string',
+      event_name: '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.events.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.events.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          event_time_start: '2019-12-27T18:11:19.117Z',
+          event_time_end: '2019-12-27T18:11:19.117Z',
+          resource: 'string',
+          entity_id: 'string',
+          event_name: 'string',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

package/tests/api-resources/expected-payments.test.ts

@@ -0,0 +1,138 @@
+// 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 expected_payments', () => {
+  test('create: only required params', async () => {
+    const response = await modernTreasury.expectedPayments.create({
+      amount_upper_bound: 0,
+      amount_lower_bound: 0,
+      direction: 'credit',
+      internal_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await modernTreasury.expectedPayments.create({
+      amount_upper_bound: 0,
+      amount_lower_bound: 0,
+      direction: 'credit',
+      internal_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      type: 'ach',
+      currency: 'AED',
+      date_upper_bound: '2019-12-27',
+      date_lower_bound: '2019-12-27',
+      description: 'string',
+      statement_descriptor: 'string',
+      metadata: {},
+      counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      remittance_information: 'string',
+      line_items: [
+        { amount: 0, metadata: {}, description: 'string', accounting_category_id: 'string' },
+        { amount: 0, metadata: {}, description: 'string', accounting_category_id: 'string' },
+        { amount: 0, metadata: {}, description: 'string', accounting_category_id: 'string' },
+      ],
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await modernTreasury.expectedPayments.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.expectedPayments.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await modernTreasury.expectedPayments.update('string', {
+      amount_upper_bound: 0,
+      amount_lower_bound: 0,
+      direction: 'credit',
+      internal_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+    });
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await modernTreasury.expectedPayments.update('string', {
+      amount_upper_bound: 0,
+      amount_lower_bound: 0,
+      direction: 'credit',
+      internal_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      type: 'ach',
+      currency: 'AED',
+      date_upper_bound: '2019-12-27',
+      date_lower_bound: '2019-12-27',
+      description: 'string',
+      statement_descriptor: 'string',
+      metadata: {},
+      counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      remittance_information: 'string',
+    });
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.expectedPayments.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.expectedPayments.list({
+      after_cursor: 'string',
+      per_page: 0,
+      status: 'archived',
+      internal_account_id: 'string',
+      direction: 'credit',
+      type: 'ach',
+      counterparty_id: 'string',
+      metadata: {},
+      created_at_lower_bound: '2019-12-27T18:11:19.117Z',
+      created_at_upper_bound: '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(modernTreasury.expectedPayments.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.expectedPayments.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          status: 'archived',
+          internal_account_id: 'string',
+          direction: 'credit',
+          type: 'ach',
+          counterparty_id: 'string',
+          metadata: {},
+          created_at_lower_bound: '2019-12-27T18:11:19.117Z',
+          created_at_upper_bound: '2019-12-27T18:11:19.117Z',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('delete', async () => {
+    const response = await modernTreasury.expectedPayments.del('string');
+  });
+
+  test('delete: 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.expectedPayments.del('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+});

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

@@ -0,0 +1,210 @@
+// 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 external_accounts', () => {
+  test('create: only required params', async () => {
+    const response = await modernTreasury.externalAccounts.create({
+      counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await modernTreasury.externalAccounts.create({
+      account_type: 'checking',
+      party_type: 'business',
+      party_address: {
+        line1: 'string',
+        line2: 'string',
+        locality: 'string',
+        region: 'string',
+        postal_code: 'string',
+        country: 'string',
+      },
+      name: 'string',
+      counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      account_details: [
+        { account_number: 'string', account_number_type: 'iban' },
+        { account_number: 'string', account_number_type: 'iban' },
+        { account_number: 'string', account_number_type: 'iban' },
+      ],
+      routing_details: [
+        { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+        { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+        { routing_number: 'string', routing_number_type: 'aba', payment_type: 'ach' },
+      ],
+      metadata: {},
+      party_name: 'string',
+      party_identifier: 'string',
+      plaid_processor_token: 'string',
+      contact_details: [
+        { contact_identifier: 'string', contact_identifier_type: 'email' },
+        { contact_identifier: 'string', contact_identifier_type: 'email' },
+        { contact_identifier: 'string', contact_identifier_type: 'email' },
+      ],
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await modernTreasury.externalAccounts.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.externalAccounts.retrieve('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const response = await modernTreasury.externalAccounts.update('string');
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await modernTreasury.externalAccounts.update('string', {
+      party_type: 'business',
+      account_type: 'checking',
+      counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      name: 'string',
+      party_name: 'string',
+      party_address: {
+        line1: 'string',
+        line2: 'string',
+        locality: 'string',
+        region: 'string',
+        postal_code: 'string',
+        country: '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.externalAccounts.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.externalAccounts.update(
+        'string',
+        {
+          party_type: 'business',
+          account_type: 'checking',
+          counterparty_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+          name: 'string',
+          party_name: 'string',
+          party_address: {
+            line1: 'string',
+            line2: 'string',
+            locality: 'string',
+            region: 'string',
+            postal_code: 'string',
+            country: 'string',
+          },
+          metadata: {},
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await modernTreasury.externalAccounts.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await modernTreasury.externalAccounts.list({
+      after_cursor: 'string',
+      per_page: 0,
+      party_name: 'string',
+      counterparty_id: '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.externalAccounts.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.externalAccounts.list(
+        {
+          after_cursor: 'string',
+          per_page: 0,
+          party_name: 'string',
+          counterparty_id: 'string',
+          metadata: {},
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('delete', async () => {
+    const response = await modernTreasury.externalAccounts.del('string');
+  });
+
+  test('delete: 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.externalAccounts.del('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('complete_verification: only required params', async () => {
+    const response = await modernTreasury.externalAccounts.completeVerification('string');
+  });
+
+  test('complete_verification: required and optional params', async () => {
+    const response = await modernTreasury.externalAccounts.completeVerification('string', {
+      amounts: [0, 0],
+    });
+  });
+
+  test('complete_verification: 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.externalAccounts.completeVerification('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('complete_verification: 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.externalAccounts.completeVerification(
+        'string',
+        { amounts: [0, 0] },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(ModernTreasury.NotFoundError);
+  });
+
+  test('verify: only required params', async () => {
+    const response = await modernTreasury.externalAccounts.verify('string', {
+      originating_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      payment_type: 'ach',
+    });
+  });
+
+  test('verify: required and optional params', async () => {
+    const response = await modernTreasury.externalAccounts.verify('string', {
+      originating_account_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+      payment_type: 'ach',
+      currency: 'AED',
+    });
+  });
+});