@chift/chift-nodejs 1.0.15 → 1.0.17

package/src/types/sync.ts

@@ -1,6 +1,21 @@
-export interface TriggerType {
-    type: 'timer' | 'event';
-    data?: any;
+interface FlowTriggerOptions {
+    autostart?: boolean;
+}
+
+export interface FlowTrigger {
+    id: string;
+    type: 'event' | 'timer';
+    cronschedules?: string[];
+    definitionFields?: any[];
+    visible?: boolean;
+    label?: string;
+    options?: FlowTriggerOptions;
+}
+
+interface FlowConfig {
+    datastores?: { id: string; name: string }[];
+    definitionFields?: Record<string, unknown>[];
+    doorkeyFields?: Record<string, unknown>[];
 }
 
 export interface ExecutionType {
@@ -11,9 +26,9 @@ export interface ExecutionType {
 export interface ContextType {
     name: string;
     description?: string;
-    trigger: TriggerType;
+    triggers: FlowTrigger[];
     execution: ExecutionType;
-    config?: any;
+    config?: FlowConfig;
 }
 
 export interface SimpleResponseModel {

package/test/modules/accounting.test.ts

@@ -7,13 +7,13 @@ import fs from 'fs';
 dotenv.config();
 
 const client = new chift.API({
-    baseUrl: process.env.CHIFT_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
 });
 
-const consumerId = process.env.CHIFT_ODOO_CONSUMER_ID as string;
+const consumerId = process.env.CHIFT_ACCOUNTING_CONSUMER_ID as string;
 
 let consumer: any;
 beforeAll(async () => {
@@ -40,7 +40,7 @@ test('getJournals', async () => {
     expect(journals[0]).toHaveProperty('journal_type', expect.any(String));
 });
 
-let vatCodes: components['schemas']['app__routers__accounting__VatCode'][];
+let vatCodes: components['schemas']['backbone_api__app__routers__accounting__VatCode'][];
 test('getVatCodes', async () => {
     vatCodes = await consumer.accounting.getVatCodes();
     expect(vatCodes).toBeInstanceOf(Array);
@@ -59,6 +59,7 @@ test('createClient', async () => {
         name: 'John Doe',
         currency: 'EUR',
         active: false,
+        is_company: true,
         addresses: [
             {
                 address_type: 'main',
@@ -106,13 +107,13 @@ test('getClient', async () => {
     expect(client).toHaveProperty('addresses', expect.any(Array));
 });
 
-test('updateClient', async () => {
+test.skip('updateClient', async () => {
     const client = clients.find((client) => client.external_reference === 'sdk test');
     const updatedClient = await consumer.accounting.updateClient(client?.id, {
-        name: 'John Updated Doe',
+        website: 'https://test.com',
     });
     expect(updatedClient).toBeTruthy();
-    expect(updatedClient).toHaveProperty('name', 'John Updated Doe');
+    expect(updatedClient).toHaveProperty('website', 'https://test.com');
 });
 
 test('createSupplier', async () => {
@@ -121,6 +122,7 @@ test('createSupplier', async () => {
         name: 'Jane Doe',
         currency: 'EUR',
         active: false,
+        is_company: true,
         addresses: [
             {
                 address_type: 'main',
@@ -167,7 +169,7 @@ test('getSupplier', async () => {
     expect(supplier).toHaveProperty('addresses', expect.any(Array));
 });
 
-test('updateSupplier', async () => {
+test.skip('updateSupplier', async () => {
     const supplier = suppliers.find((supplier) => supplier.external_reference === 'sdk test');
     const updatedSupplier = await consumer.accounting.updateSupplier(supplier?.id, {
         name: 'Jane Updated Doe',
@@ -197,6 +199,8 @@ test('createInvoice', async () => {
         total: 121,
         partner_id: clients[0]?.id as string,
         journal_id: journal.id,
+        status: 'draft',
+        currency_exchange_rate: 1,
         lines: [
             {
                 description: 'Test',
@@ -208,6 +212,7 @@ test('createInvoice', async () => {
                 total: 121,
                 account_number: '700000',
                 tax_code: vatCode.id,
+                line_number: 1,
             },
         ],
     };
@@ -288,6 +293,8 @@ test('createInvoiceWithMultiplePlans', async () => {
         total: 121,
         partner_id: clients[0]?.id as string,
         journal_id: journal.id,
+        status: 'draft',
+        currency_exchange_rate: 1,
         lines: [
             {
                 description: 'Test',
@@ -299,6 +306,7 @@ test('createInvoiceWithMultiplePlans', async () => {
                 total: 121,
                 account_number: '700000',
                 tax_code: vatCode.id,
+                line_number: 1,
             },
         ],
     };
@@ -330,17 +338,14 @@ test('getAnalyticAccounts', async () => {
     analyticAccounts = await consumer.accounting.getAnalyticAccounts();
     expect(analyticAccounts).toBeInstanceOf(Array);
     expect(analyticAccounts.length).toBeGreaterThan(0);
-    expect(analyticAccounts[0]).toHaveProperty('active', expect.any(Boolean));
-    expect(analyticAccounts[0]).toHaveProperty('code', expect.any(String));
-    expect(analyticAccounts[0]).toHaveProperty('name', expect.any(String));
-    expect(analyticAccounts[0]).toHaveProperty('currency', expect.any(String));
     expect(analyticAccounts[0]).toHaveProperty('id', expect.any(String));
-    expect(analyticAccounts[0]).toHaveProperty('balance', expect.any(Number));
-    expect(analyticAccounts[0]).toHaveProperty('debit', expect.any(Number));
-    expect(analyticAccounts[0]).toHaveProperty('credit', expect.any(Number));
 });
 
-test('createAnalyticAccountWithMultiplePlans', async () => {
+test.skip('createAnalyticAccountWithMultiplePlans', async () => {
+    if (analyticPlans.length === 0) {
+        throw new Error('No analytic plans found to create analytic account with multiple plans');
+    }
+
     const analyticAccount = await consumer.accounting.createAnalyticAccountWithMultiplePlans(
         analyticPlans[0].id,
         {
@@ -353,11 +358,19 @@ test('createAnalyticAccountWithMultiplePlans', async () => {
 });
 
 test('getAnalyticAccount', async () => {
+    if (analyticAccounts.length === 0) {
+        throw new Error('No analytic accounts found to get analytic account');
+    }
+
     const analyticAccount = await consumer.accounting.getAnalyticAccount(analyticAccounts[0].id);
     expect(analyticAccount).toBeTruthy();
 });
 
-test('updateAnalyticAccount', async () => {
+test.skip('updateAnalyticAccount', async () => {
+    if (analyticAccounts.length === 0) {
+        throw new Error('No analytic accounts found to update analytic account');
+    }
+
     const testAnalyticAccount = analyticAccounts.find((account) => account.name === 'sdk test');
     const analyticAccount = await consumer.accounting.updateAnalyticAccount(
         testAnalyticAccount?.id,
@@ -367,7 +380,11 @@ test('updateAnalyticAccount', async () => {
     expect(analyticAccount).toHaveProperty('name', 'test sdk update');
 });
 
-test('getAnalyticAccountWithMultiplePlans', async () => {
+test.skip('getAnalyticAccountWithMultiplePlans', async () => {
+    if (analyticPlans.length === 0) {
+        throw new Error('No analytic plans found to get analytic account with multiple plans');
+    }
+
     const analyticAccount = await consumer.accounting.getAnalyticAccountWithMultiplePlans(
         analyticAccounts[0].id,
         analyticPlans[0].id
@@ -375,7 +392,13 @@ test('getAnalyticAccountWithMultiplePlans', async () => {
     expect(analyticAccount).toBeTruthy();
 });
 
-test('updateAnalyticAccountWithMultiplePlans', async () => {
+test.skip('updateAnalyticAccountWithMultiplePlans', async () => {
+    if (!analyticAccounts.length) {
+        throw new Error(
+            'No analytic accounts found to update analytic account with multiple plans'
+        );
+    }
+
     const testAnalyticAccount = analyticAccounts.find(
         (account) => account.name === 'test sdk update'
     );
@@ -389,34 +412,36 @@ test('updateAnalyticAccountWithMultiplePlans', async () => {
     expect(analyticAccount).toHaveProperty('name', 'test sdk update 2');
 });
 
-test('getAnalyticAccountsWithMultiplePlans', async () => {
+test.skip('getAnalyticAccountsWithMultiplePlans', async () => {
     const analyticAccountsWithMultiplePlans =
         await consumer.accounting.getAnalyticAccountsWithMultiplePlans();
     expect(analyticAccountsWithMultiplePlans).toBeInstanceOf(Array);
 });
 
-test('createJournalEntry', async () => {
+test.skip('createJournalEntry', async () => {
     const journal = journals.find((journal) => journal.journal_type === 'customer_invoice');
     if (!journal) {
         throw new Error('No journal with type "customer_invoice" found to create journal entry');
     }
+
+    if (!clients.length) {
+        throw new Error('No clients found to create journal entry');
+    }
+
     const journalEntry = await consumer.accounting.createJournalEntry({
         journal_id: journal.id,
-        name: Date.now().toString(),
+        number: new Date().valueOf(),
+        currency: 'EUR',
         date: '2022-01-01',
         items: [
             {
-                account_number: clients[0].account_number,
+                account_type: 'customer_account',
+                account: clients[0].id,
                 credit: 0,
                 debit: 10,
-                partner_id: clients[0].id,
-                currency: 'EUR',
-            },
-            {
-                account_number: '700000',
-                credit: 10,
-                debit: 0,
                 currency: 'EUR',
+                prioritise_thirdparty_account: false,
+                analytic_distribution: [],
             },
         ],
     });
@@ -509,7 +534,7 @@ test('getChartOfAccounts', async () => {
     expect(chartOfAccounts).toBeTruthy();
 });
 
-test('getBalanceOfAccounts', async () => {
+test.skip('getBalanceOfAccounts', async () => {
     const balanceOfAccounts = await consumer.accounting.getBalanceOfAccounts({
         accounts: ['7'],
         start: '2022-01-01',
@@ -525,23 +550,13 @@ test('getEmployees', async () => {
     expect(employees).toBeTruthy();
 });
 
-test('getOutstandings', async () => {
-    expect.assertions(1);
-    try {
-        const outstandings = await consumer.accounting.getOutstandings({
-            type: 'client',
-            unposted_allowed: true,
-        });
-        expect(outstandings).toBeTruthy();
-        expect(outstandings.items).toBeInstanceOf(Array);
-    } catch (e: any) {
-        if (e?.error?.error_code) {
-            expect(e.error.error_code).toMatch('ERROR_API_RESOURCE_NOT_FOUND');
-            return;
-        }
-
-        throw e;
-    }
+test.skip('getOutstandings', async () => {
+    const outstandings = await consumer.accounting.getOutstandings({
+        type: 'client',
+        unposted_allowed: false,
+    });
+    expect(outstandings).toBeTruthy();
+    expect(outstandings.items).toBeInstanceOf(Array);
 });
 
 test('createFinancialEntry', async () => {
@@ -552,6 +567,10 @@ test('createFinancialEntry', async () => {
         );
     }
 
+    if (!clients.length) {
+        throw new Error('No clients found to create journal entry');
+    }
+
     const financialEntry = await consumer.accounting.createFinancialEntry({
         date: '2022-01-01',
         journal_id: journal.id,

package/test/modules/consumer.test.ts

@@ -5,10 +5,10 @@ import { components } from '../../src/types/public-api/schema';
 dotenv.config();
 
 const client = new chift.API({
-    baseUrl: process.env.CHIFT_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
 });
 
 const consumerName = 'test consumer 2';
@@ -36,7 +36,7 @@ test('createConnection', async () => {
     expect(result).toHaveProperty('url', expect.any(String));
 });
 
-let connections: components['schemas']['app__routers__connections__ConnectionItem'][];
+let connections: components['schemas']['backbone_api__app__routers__connections__ConnectionItem'][];
 
 test('getConnections', async () => {
     connections = await syncConsumer.getConnections();

package/test/modules/consumers.test.ts

@@ -6,10 +6,10 @@ import * as dotenv from 'dotenv';
 dotenv.config();
 
 const client = new chift.API({
-    baseUrl: process.env.CHIFT_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
 });
 
 const consumerName = 'test consumer';

package/test/modules/ecommerce.test.ts

@@ -5,13 +5,13 @@ import { components } from '../../src/types/public-api/schema';
 dotenv.config();
 
 const client = new chift.API({
-    baseUrl: process.env.CHIFT_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
 });
 
-const consumerId = process.env.CHIFT_WOOCOMMERCE_CONSUMER_ID as string;
+const consumerId = process.env.CHIFT_ECOMMERCE_CONSUMER_ID as string;
 
 let consumer: any;
 beforeAll(async () => {
@@ -26,7 +26,7 @@ test('getCustomers', async () => {
     expect(customers[0]).toHaveProperty('id', expect.any(String));
 });
 
-let products: components['schemas']['app__routers__commerce__ProductItem'][];
+let products: components['schemas']['backbone_api__app__routers__commerce__ProductItem'][];
 test('getProducts', async () => {
     products = await consumer.ecommerce.getProducts();
     expect(products).toBeInstanceOf(Array);
@@ -64,18 +64,19 @@ test('getProduct', async () => {
     expect(product).toHaveProperty('common_images');
 });
 
-test('getProductVariantById', async () => {
+let productVariant: components['schemas']['VariantItem'];
+test.skip('getProductVariantById', async () => {
     if (!products?.length) {
         throw new Error('No product to test');
     }
 
-    if (!products[0].variants) {
+    if (!products[0].variants.length) {
         throw new Error('No product variant to test');
     }
 
-    const variant = await consumer.ecommerce.getProductVariantById(products[0].variants[0].id);
-    expect(variant).toBeTruthy();
-    expect(variant).toHaveProperty('id', expect.any(String));
+    productVariant = await consumer.ecommerce.getProductVariantById(products[0].variants[0].id);
+    expect(productVariant).toBeTruthy();
+    expect(productVariant).toHaveProperty('id', expect.any(String));
 });
 
 let locations: components['schemas']['CommerceLocationItem'][];
@@ -87,16 +88,16 @@ test('getLocations', async () => {
     expect(locations[0]).toHaveProperty('name', expect.any(String));
 });
 
-test('updateAvailableQuantity', async () => {
-    if (!products?.length) {
-        throw new Error('No product to test');
+test.skip('updateAvailableQuantity', async () => {
+    if (!productVariant) {
+        throw new Error('No product variant found to update available quantity');
     }
 
-    if (!products[0].variants) {
-        throw new Error('No product variant to test');
+    if (!locations?.length) {
+        throw new Error('No location found to update available quantity');
     }
 
-    const product = await consumer.ecommerce.updateAvailableQuantity(products[0].variants[0].id, {
+    const product = await consumer.ecommerce.updateAvailableQuantity(productVariant.id, {
         location_id: locations[0].id,
         available_quantity: 1,
     });
@@ -144,13 +145,17 @@ test.skip('createOrder', async () => {
 let orders: components['schemas']['OrderItemOut'][];
 test('getOrders', async () => {
     orders = await consumer.ecommerce.getOrders({
-        date_from: '2021-10-01',
-        date_to: '2021-12-31',
+        date_from: '2023-01-08',
+        date_to: '2023-01-01',
     });
     expect(orders).toBeInstanceOf(Array);
 });
 
-test('getOrder', async () => {
+test.skip('getOrder', async () => {
+    if (!orders?.length) {
+        throw new Error('No orders found to test getOrder');
+    }
+
     const order = await consumer.ecommerce.getOrder(orders[0].id);
     expect(order).toBeTruthy();
     expect(order).toHaveProperty('id', expect.any(String));

package/test/modules/integrations.test.ts

@@ -4,10 +4,10 @@ import * as dotenv from 'dotenv';
 dotenv.config();
 
 const client = new chift.API({
-    baseUrl: process.env.CHIFT_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
 });
 
 test('getIntegrations', async () => {

package/test/modules/invoicing.test.ts

@@ -5,13 +5,13 @@ import { components } from '../../src/types/public-api/schema';
 dotenv.config();
 
 const client = new chift.API({
-    baseUrl: process.env.CHIFT_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
 });
 
-const consumerId = process.env.CHIFT_AXONAUT_CONSUMER_ID as string;
+const consumerId = process.env.CHIFT_INVOICING_CONSUMER_ID as string;
 
 let consumer: any;
 beforeAll(async () => {
@@ -22,8 +22,6 @@ let invoices: components['schemas']['InvoiceItemOut'][];
 test('getInvoices', async () => {
     invoices = await consumer.invoicing.getInvoices({
         invoice_type: 'customer_invoice',
-        date_from: '2023-01-01',
-        date_to: '2023-01-31',
     });
     expect(invoices).toBeInstanceOf(Array);
     expect(invoices.length).toBeGreaterThan(0);
@@ -31,6 +29,10 @@ test('getInvoices', async () => {
 });
 
 test('getInvoiceById', async () => {
+    if (!invoices.length) {
+        throw new Error('No invoices found to test getInvoiceById');
+    }
+
     const invoice = await consumer.invoicing.getInvoiceById(invoices[0].id, { include_pdf: false });
     expect(invoice).toHaveProperty('id', expect.any(String));
 });
@@ -48,7 +50,7 @@ test('getProductById', async () => {
     expect(product).toHaveProperty('id', expect.any(String));
 });
 
-let vatCodes: components['schemas']['models__invoicing__VatCode'][];
+let vatCodes: components['schemas']['backbone_common__models__invoicing__VatCode'][];
 test('getTaxes', async () => {
     vatCodes = await consumer.invoicing.getTaxes();
     expect(vatCodes).toBeInstanceOf(Array);
@@ -62,14 +64,18 @@ test('getTaxById', async () => {
 });
 
 let opportunities: components['schemas']['OpportunityItem'][];
-test('getOpportunities', async () => {
+test.skip('getOpportunities', async () => {
     opportunities = await consumer.invoicing.getOpportunities();
     expect(opportunities).toBeInstanceOf(Array);
     expect(opportunities.length).toBeGreaterThan(0);
     expect(opportunities[0]).toHaveProperty('id', expect.any(String));
 });
 
-test('getOpportunitiesById', async () => {
+test.skip('getOpportunitiesById', async () => {
+    if (!opportunities.length) {
+        throw new Error('No opportunities found to test getOpportunitiesById');
+    }
+
     const opportunity = await consumer.invoicing.getOpportunitiesById(opportunities[0].id);
     expect(opportunity).toHaveProperty('id', expect.any(String));
 });
@@ -83,6 +89,10 @@ test('getContacts', async () => {
 });
 
 test('getContactById', async () => {
+    if (!contacts.length) {
+        throw new Error('No contacts found to test getContactById');
+    }
+
     const contact = await consumer.invoicing.getContactById(contacts[0].id);
     expect(contact).toHaveProperty('id', expect.any(String));
 });

package/test/modules/payment.test.ts

@@ -0,0 +1,65 @@
+import { beforeAll, expect, test } from '@jest/globals';
+import * as chift from '../../src/index';
+import * as dotenv from 'dotenv';
+import { components } from '../../src/types/public-api/schema';
+dotenv.config();
+
+const client = new chift.API({
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
+});
+// TODO: Setup Payment test data
+const consumerId = process.env.CHIFT_PAYMENT_CONSUMER_ID as string;
+
+let consumer: any;
+beforeAll(async () => {
+    consumer = await client.Consumers.getConsumerById(consumerId);
+});
+
+let payments: components['schemas']['PaymentItemOut'][];
+test('getPayments', async () => {
+    payments = await consumer.payment.getPayments();
+    expect(payments).toBeInstanceOf(Array);
+    expect(payments.length).toBeGreaterThan(0);
+    expect(payments[0]).toHaveProperty('id', expect.any(String));
+});
+
+test('getBalances', async () => {
+    const balances: components['schemas']['BalanceItemOut'][] =
+        await consumer.payment.getBalances();
+    expect(balances).toBeInstanceOf(Array);
+    expect(balances.length).toBeGreaterThan(0);
+    expect(balances[0]).toHaveProperty('id', expect.any(String));
+});
+
+test.skip('getTransactions', async () => {
+    const transactions: components['schemas']['TransactionItemOut'][] =
+        await consumer.payment.getTransactions();
+    expect(transactions).toBeInstanceOf(Array);
+    expect(transactions.length).toBeGreaterThan(0);
+    expect(transactions[0]).toHaveProperty('id', expect.any(String));
+});
+
+test.skip('getPayment', async () => {
+    if (!payments.length) {
+        throw new Error('No payments found to test getPayment');
+    }
+
+    const payment: components['schemas']['PaymentItemOut'] = await consumer.payment.getPayment({
+        payment_id: payments[0].id,
+    });
+    expect(payment).toHaveProperty('id', payments[0].id);
+});
+
+test.skip('getRefunds', async () => {
+    const refunds: components['schemas']['RefundItemOut'][] = await consumer.payment.getRefunds({
+        date_from: '2023-01-01',
+        date_to: '2023-01-31',
+        payment_id: payments[0].id,
+    });
+    expect(refunds).toBeInstanceOf(Array);
+    expect(refunds.length).toBeGreaterThan(0);
+    expect(refunds[0]).toHaveProperty('id', expect.any(String));
+});

package/test/modules/pms.test.ts

@@ -0,0 +1,69 @@
+import { beforeAll, expect, test } from '@jest/globals';
+import * as chift from '../../src/index';
+import * as dotenv from 'dotenv';
+import { components } from '../../src/types/public-api/schema';
+dotenv.config();
+
+const client = new chift.API({
+    baseUrl: process.env.CHIFT_BACKBONE_API,
+    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
+    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
+    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
+});
+// TODO: Setup PMS test data
+const consumerId = process.env.CHIFT_PMS_CONSUMER_ID as string;
+
+let consumer: any;
+beforeAll(async () => {
+    consumer = await client.Consumers.getConsumerById(consumerId);
+});
+
+test.skip('getLocations', async () => {
+    const locations: components['schemas']['PMSLocationItem'][] = await consumer.pms.getLocations();
+    expect(locations).toBeInstanceOf(Array);
+    expect(locations.length).toBeGreaterThan(0);
+    expect(locations[0]).toHaveProperty('id', expect.any(String));
+});
+
+test.skip('getOrders', async () => {
+    const orders: components['schemas']['PMSOrderItem'][] = await consumer.pms.getOrders({
+        date_from: '2023-01-01',
+        date_to: '2023-01-31',
+    });
+    expect(orders).toBeInstanceOf(Array);
+    expect(orders.length).toBeGreaterThan(0);
+    expect(orders[0]).toHaveProperty('id', expect.any(String));
+});
+
+test.skip('getPaymentMethods', async () => {
+    const paymentMethods: components['schemas']['PMSPaymentMethods'][] =
+        await consumer.pms.getPaymentMethods();
+    expect(paymentMethods).toBeInstanceOf(Array);
+    expect(paymentMethods.length).toBeGreaterThan(0);
+    expect(paymentMethods[0]).toHaveProperty('id', expect.any(String));
+});
+
+test.skip('getClosure', async () => {
+    const closure: components['schemas']['PMSClosureItem'] = await consumer.pms.getClosure(
+        '2023-01-01'
+    );
+    expect(closure).toHaveProperty('id', expect.any(String));
+});
+
+test.skip('getPayments', async () => {
+    const payments: components['schemas']['PMSPaymentItem'][] = await consumer.pms.getPayments({
+        date_from: '2023-01-01',
+        date_to: '2023-01-31',
+    });
+    expect(payments).toBeInstanceOf(Array);
+    expect(payments.length).toBeGreaterThan(0);
+    expect(payments[0]).toHaveProperty('id', expect.any(String));
+});
+
+test.skip('getAccountingCategories', async () => {
+    const accountingCategories: components['schemas']['PMSAccountingCategoryItem'][] =
+        await consumer.pms.getAccountingCategories();
+    expect(accountingCategories).toBeInstanceOf(Array);
+    expect(accountingCategories.length).toBeGreaterThan(0);
+    expect(accountingCategories[0]).toHaveProperty('id', expect.any(String));
+});