conductor-node 3.2.0 → 3.2.1

package/dist/BaseClient.d.ts

@@ -0,0 +1,5 @@
+import type Client from "@conductor/client/Client";
+export default class BaseClient {
+    protected readonly root: Client;
+    constructor(client: Client);
+}

package/dist/BaseClient.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BaseClient {
+    root;
+    constructor(client) {
+        this.root = client;
+    }
+}
+exports.default = BaseClient;

package/dist/Client.d.ts

@@ -0,0 +1,21 @@
+import type { Environment } from "@conductor/client/environment";
+import ClientQbd from "@conductor/client/qbd/ClientQbd";
+export interface ClientOptions {
+    /** Log the each request and response. */
+    verbose?: boolean;
+    environment?: Environment;
+}
+export interface IntegrationRequestParams {
+    integrationUserConnectionId: string;
+    requestObject: object;
+}
+export default class Client {
+    /** QuickBooks Desktop integration. */
+    readonly qbd: ClientQbd;
+    private readonly serverURL;
+    private readonly gqlClient;
+    private readonly verbose;
+    constructor(apiKey: string, { verbose, environment }?: ClientOptions);
+    integrationUserConnections(): Promise<object[]>;
+    integrationRequest(integrationRequestParams: IntegrationRequestParams): Promise<object>;
+}

package/dist/Client.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const environment_1 = require("@conductor/client/environment");
+const ClientQbd_1 = __importDefault(require("@conductor/client/qbd/ClientQbd"));
+const graphql_request_1 = require("graphql-request");
+class Client {
+    /** QuickBooks Desktop integration. */
+    qbd;
+    serverURL;
+    gqlClient;
+    verbose;
+    constructor(apiKey, { verbose = false, environment = "staging" } = {}) {
+        this.verbose = verbose;
+        this.serverURL = (0, environment_1.envToBaseServerURL)(environment);
+        this.gqlClient = new graphql_request_1.GraphQLClient(`${this.serverURL}/graphql`, {
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+            },
+        });
+        this.qbd = new ClientQbd_1.default(this);
+    }
+    async integrationUserConnections() {
+        const data = await this.gqlClient.request(`#graphql
+        query {
+          integrationUserConnections {
+            id
+            integration {
+              id
+              name
+            }
+            username
+          }
+        }
+      `);
+        // @ts-expect-error - This will pass after we integrate GQL codegen.
+        return data.integrationUserConnections;
+    }
+    // TODO: Hide this method from the dev user while still allowing the
+    // integration clients to access it.
+    async integrationRequest(integrationRequestParams) {
+        if (this.verbose) {
+            console.log(`Client sent request to ${this.serverURL}:`, JSON.stringify(integrationRequestParams, null, 2));
+            console.time("Request time");
+        }
+        const response = await this.gqlClient.request(`#graphql
+        query IntegrationRequest($integrationRequestParams: IntegrationRequestParams!) {
+          integrationRequest(integrationRequestParams: $integrationRequestParams)
+        }
+      `, { integrationRequestParams });
+        // @ts-expect-error - This will pass after we integrate GQL codegen.
+        const responseBody = response.integrationRequest;
+        if (this.verbose) {
+            console.timeEnd("Request time");
+            console.log(`Client received response from ${this.serverURL}:`, JSON.stringify(responseBody, null, 2));
+        }
+        return responseBody;
+    }
+}
+exports.default = Client;

package/dist/__tests__/Client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/Client.test.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Client_1 = __importDefault(require("@conductor/client/Client"));
+describe("Client", () => {
+    test("Create a new Client", () => {
+        const client = new Client_1.default("mock_api_key");
+        expect(client).toBeInstanceOf(Client_1.default);
+    });
+    test("Create a new Client with options", () => {
+        const client = new Client_1.default("mock_api_key", { environment: "staging" });
+        expect(client).toBeInstanceOf(Client_1.default);
+    });
+});

package/dist/environment.d.ts

@@ -0,0 +1,2 @@
+export declare type Environment = "development" | "staging";
+export declare function envToBaseServerURL(environment: Environment): string;

package/dist/environment.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envToBaseServerURL = void 0;
+const STAGING_BASE_URL = "https://staging.api.conductor.is";
+const DEVELOPMENT_BASE_URL = "https://conductor.ngrok.io";
+function envToBaseServerURL(environment) {
+    switch (environment) {
+        case "staging":
+            return STAGING_BASE_URL;
+        case "development":
+            return DEVELOPMENT_BASE_URL;
+        default:
+            throw new Error("Invalid environment");
+    }
+}
+exports.envToBaseServerURL = envToBaseServerURL;

package/dist/qbd/ClientQbd.d.ts

@@ -0,0 +1,376 @@
+import BaseClient from "@conductor/client/BaseClient";
+import type * as qbd from "@conductor/client/qbd/qbdTypes";
+export default class ClientQbd extends BaseClient {
+    account: {
+        /**
+         * Perform the same activities as a user does in the QB New Account form,
+         * which can be accessed in QB by selecting "Lists" → "Chart of Accounts" →
+         * "Accounts" → "New".
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/AccountAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.AccountAddRq["AccountAdd"]) => Promise<NonNullable<qbd.AccountAddRs["AccountRet"]>>;
+        /**
+         * Modifies an account.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/AccountMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.AccountModRq["AccountMod"]) => Promise<NonNullable<qbd.AccountModRs["AccountRet"]>>;
+        /**
+         * `AccountQuery` is a list query that returns data for all accounts that
+         * match the provided filter criteria. Notice that it returns only data
+         * internal to the account itself. It does not return any data about
+         * transactions involving the account. It does, however, return the parent
+         * account, if there is one. You can search across all accounts or you can
+         * specify an account type and search only those.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/AccountQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.AccountQueryRq) => Promise<NonNullable<qbd.AccountQueryRs["AccountRet"]>>;
+    };
+    check: {
+        /**
+         * The amount of a check is the total of the amounts assigned to expense
+         * lines and item lines. You can write a check for:
+         * - Any expense that you track through expense accounts.
+         * - The following types of items: fixed asset, non-inventory part, service,
+         *   and other charge.
+         * - Putting money into your petty cash account.
+         * - Inventory part items (if you use the inventory/purchase order feature).
+         *
+         * You cannot use a `CheckAdd` for any of the following:
+         * - Paying a bill by check; instead, use a `BillPaymentCheckAdd`.
+         * - Paying employees or create paychecks.
+         * - Paying payroll taxes and liabilities.
+         * - Paying sales tax.
+         * - Paying for received items.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/CheckAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.CheckAddRq["CheckAdd"]) => Promise<NonNullable<qbd.CheckAddRs["CheckRet"]>>;
+        /**
+         * Modifies an existing Check. Notice that you cannot use this to modify BillPaymentChecks.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/CheckMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.CheckModRq["CheckMod"]) => Promise<NonNullable<qbd.CheckModRs["CheckRet"]>>;
+        /**
+         * Returns certain types of checks based on the supplied query criteria.
+         * Note that `BillPaymentChecks`, payroll checks, and liability checks are
+         * not returned.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/CheckQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.CheckQueryRq) => Promise<NonNullable<qbd.CheckQueryRs["CheckRet"]>>;
+    };
+    class: {
+        /**
+         * Classes can be used to separate transactions into meaningful categories.
+         * (For example, transactions could be classified according to department,
+         * business location, or type of work.) In QuickBooks, class tracking is off
+         * by default.
+         *
+         * A `ClassRef` aggregate refers to one of these named classes. For example,
+         * in a `TimeTracking` message, `ClassRef` refers to the QuickBooks class
+         * into which the timed activity falls. If a `ClassRef` aggregate includes
+         * both `FullName` and `ListID`, `FullName` will be ignored.
+         *
+         * In an `InvoiceAdd` request, if you specify a `ClassRef` for the whole
+         * invoice, that same `ClassRef` is automatically used in the line items. If
+         * you want to clear that (that is, have NO `ClassRef` for the line item,
+         * you can clear it in the line item by simply not specifying it in the line
+         * item.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/ClassAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.ClassAddRq["ClassAdd"]) => Promise<NonNullable<qbd.ClassAddRs["ClassRet"]>>;
+        /**
+         * Modifies the specified class.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/ClassMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.ClassModRq["ClassMod"]) => Promise<NonNullable<qbd.ClassModRs["ClassRet"]>>;
+        /**
+         * Queries for existing classes.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/ClassQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.ClassQueryRq) => Promise<NonNullable<qbd.ClassQueryRs["ClassRet"]>>;
+    };
+    customer: {
+        /**
+         * The customer list includes information about the QuickBooks user’s
+         * customers and the individual jobs that are being performed for them. A
+         * `CustomerRef` aggregate refers to one of the customers (or customer jobs)
+         * on the list. In a request, if a `CustomerRef` aggregate includes both
+         * `FullName` and `ListID`, `FullName` will be ignored. Special cases to
+         * note:
+         *
+         * - In `SalesReceipt` and `ReceivePayment` requests, `CustomerRef` refers
+         *   to the customer or customer job to which the payment is credited.
+         *
+         * - In a `TimeTracking` request, CustomerRef refers to the customer or
+         *   customer job to which this time could be billed. If `IsBillable` is set
+         *   to true, `CustomerRef` is required in `TimeTrackingAdd`.
+         *
+         * - In an `ExpenseLineAdd` request, if `AccountRef` refers to an A/P
+         *   account, `CustomerRef` must refer to a vendor (not to a customer). If
+         *   `AccountRef` refers to any other type of account, the `CustomerRef`
+         *   must refer to a customer.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/CustomerAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.CustomerAddRq["CustomerAdd"]) => Promise<NonNullable<qbd.CustomerAddRs["CustomerRet"]>>;
+        /**
+         * Modifies the customer record.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/CustomerMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.CustomerModRq["CustomerMod"]) => Promise<NonNullable<qbd.CustomerModRs["CustomerRet"]>>;
+        /**
+         * Returns data for the specified customers.
+         *
+         * Important: We highly recommend that you use the `IncludeRetElement` tag
+         * in your `CustomerQuery` to include any data you want but do NOT include
+         * the `ShipAddress` data in the `Response`, unless you need to get the
+         * shipping address for a particular customer. Excluding the shipping
+         * address data will significantly improve the performance of the
+         * `CustomerQuery`.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/CustomerQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.CustomerQueryRq) => Promise<NonNullable<qbd.CustomerQueryRs["CustomerRet"]>>;
+    };
+    employee: {
+        /**
+         * Adds an employee with personal data about the employee as well as certain
+         * payroll-related data.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/EmployeeAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.EmployeeAddRq["EmployeeAdd"]) => Promise<NonNullable<qbd.EmployeeAddRs["EmployeeRet"]>>;
+        /**
+         * Modifies an existing employee.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/EmployeeMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.EmployeeModRq["EmployeeMod"]) => Promise<NonNullable<qbd.EmployeeModRs["EmployeeRet"]>>;
+        /**
+         * Returns employee data.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/EmployeeQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.EmployeeQueryRq) => Promise<NonNullable<qbd.EmployeeQueryRs["EmployeeRet"]>>;
+    };
+    itemService: {
+        /**
+         * Adds a service item, which is an item that refers to services that a
+         * business charges for or purchases. Examples include specialized labor,
+         * consulting hours, and professional fees. An `ItemServiceRef` aggregate
+         * refers to an item on the ItemService list. In a request, if an
+         * `ItemServiceRef` aggregate includes both `FullName` and `ListID`,
+         * `FullName` will be ignored.
+         *
+         * In a `TimeTracking` message, `ItemServiceRef` refers to the type of work.
+         * If no `CustomerRef` is specified, then `ItemServiceRef` is not needed. If
+         * `IsBillable` is set to true, then `TimeTrackingAdd` must include both
+         * `ItemServiceRef` and `CustomerRef`.
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/ItemServiceAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.ItemServiceAddRq["ItemServiceAdd"]) => Promise<NonNullable<qbd.ItemServiceAddRs["ItemServiceRet"]>>;
+        /**
+         * Modifies an existing service item.
+         *
+         * About `SalesOrPurchaseMod` versus `SalesAndPurchaseMod` in an
+         * `ItemServiceMod` request:
+         * - You cannot change the reimbursable status of a service item through the
+         *   SDK. For example, if a service item is marked as non-reimbursable in
+         *   QuickBooks, you cannot send a modify request that includes a
+         *   `SalesAndPurchaseMod` aggregate. Similarly, if you send an
+         *   `ItemServiceAdd` request that includes a `SalesOrPurchase` aggregate,
+         *   you cannot later modify that item using a `SalesAndPurchaseMod`
+         *   aggregate.
+         * - You can modify the various account references using the appropriate
+         *   account reference aggregate and the matching `RefToExistingTxns`
+         *   boolean. You need to use the boolean when you change an account ref
+         *   because the QuickBooks UI displays a prompt asking whether the change
+         *   should apply to existing transactions or not.
+         *   - Specifying `False` means that the mod will not take affect if there
+         *     are existing transactions.
+         *   - Specifying `True` for the boolean basically dismisses this with a
+         *     “Yes” answer, allowing your changes to be made and changes any
+         *     existing transactions that use the item with that `AccountRef`.
+         *     Setting this to `True` should be used with caution and normally only
+         *     after some user has indicated that they want those changes made to
+         *     all those existing transactions! If any affected transactions are
+         *     protected by a closing date and password, the `AccountRef` changes
+         *     will not be made and so the `Mod` request will return an error
+         *     without making the requested `Mod`.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/ItemServiceMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.ItemServiceModRq["ItemServiceMod"]) => Promise<NonNullable<qbd.ItemServiceModRs["ItemServiceRet"]>>;
+        /**
+         * Queries for the specified service item or set of items.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/ItemServiceQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.ItemServiceQueryRq) => Promise<NonNullable<qbd.ItemServiceQueryRs["ItemServiceRet"]>>;
+    };
+    journalEntry: {
+        /**
+         * The debit and credit lines can be intermingled. A credit line can legally
+         * come first in the journal entry add.
+         *
+         * In traditional accounting, transactions are entered into the general
+         * journal and categorized exclusively by account. In QuickBooks, most
+         * transactions can be categorized either by account or by type (invoice,
+         * check, and so on). For a few activities in QuickBooks, you must use the
+         * general journal directly, for example for recording depreciation. Notice
+         * that you must supply the credit line and a corresponding debit line in
+         * the same request. It will not work to supply them in two distinct
+         * requests. You can supply as many credit lines and debit lines in one
+         * single request as you want so long as the total monetary amount from the
+         * credits equals the total monetary amount from the debits in that request.
+         *
+         * Finally, DO NOT supply negative sign for the monetary amounts. QuickBooks
+         * does that for you. If you do supply the negative sign, amounts will add
+         * instead of cancel and you’ll get a runtime error.
+         *
+         * Querying for Condensed Transactions: If you need the query to return
+         * condensed transactions, you can do this by using either an `Entity` or
+         * `Account` filter in the journal query request. Alternatively, you could
+         * use the The generic `TransactionQuery`, which can return condensed
+         * transactions.
+         *
+         * If the transaction is a home currency adjustment, QuickBooks will ignore
+         * the `IsAmountsEnteredInHomeCurrency`, `CurrencyRef`, and `ExchangeRate`
+         * elements.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/JournalEntryAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.JournalEntryAddRq["JournalEntryAdd"]) => Promise<NonNullable<qbd.JournalEntryAddRs["JournalEntryRet"]>>;
+        /**
+         * Modifies a journal entry.
+         *
+         * If the transaction is a home currency adjustment, QuickBooks will ignore
+         * the `IsAmountsEnteredInHomeCurrency`, `CurrencyRef`, and `ExchangeRate`
+         * elements.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/JournalEntryMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.JournalEntryModRq["JournalEntryMod"]) => Promise<NonNullable<qbd.JournalEntryModRs["JournalEntryRet"]>>;
+        /**
+         * In traditional accounting, transactions are entered into the general
+         * journal and categorized exclusively by account. In QuickBooks, most
+         * transactions can be categorized either by account or by type (invoice,
+         * check, and so on). For a few activities in QuickBooks, you must use the
+         * general journal directly, for example for recording depreciation. Notice
+         * that you must supply the credit line and a corresponding debit line in
+         * the same request. It will not work to supply them in two distinct
+         * requests. You can supply as many credit lines and debit lines in one
+         * single request as you want so long as the total monetary amount from the
+         * credits equals the total monetary amount from the debits in that request.
+         *
+         * Finally, DO NOT supply negative sign for the monetary amounts. QuickBooks
+         * does that for you. If you do supply the negative sign, amounts will add
+         * instead of cancel and you’ll get a runtime error.
+         *
+         * Querying for Condensed Transactions: If you need the query to return
+         * condensed transactions, you can do this by using either an `Entity` or
+         * `Account` filter in the journal query request. Alternatively, you could
+         * use the The generic `TransactionQuery`, which can return condensed
+         * transactions.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/JournalEntryQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.JournalEntryQueryRq) => Promise<NonNullable<qbd.JournalEntryQueryRs["JournalEntryRet"]>>;
+    };
+    timeTracking: {
+        /**
+         * The time-tracking transactions that are returned in this query include
+         * time tracking information that was entered into QuickBooks manually or
+         * gathered using the QuickBooks “Timer” or “Stopwatch.” Note that the
+         * QuickBooks Timer application can run on its own without QuickBooks, but
+         * the QuickBooks SDK cannot access the Timer data directly. The Timer data
+         * must be imported into QuickBooks before it is accessible via the SDK.)
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/TimeTrackingQuery
+         */
+        add: (integrationUserConnectionId: string, params: qbd.TimeTrackingAddRq["TimeTrackingAdd"]) => Promise<NonNullable<qbd.TimeTrackingAddRs["TimeTrackingRet"]>>;
+        /**
+         * Modifies a time tracking transaction.
+         *
+         * This allows you to modify time entry and mark time entered as billed.
+         * Applications using qbXML spec levels less than 6.0 aren’t able to Modify
+         * a time tracking transaction. However, those applications can achieve the
+         * results of a modify operation by deleting the time tracking transaction
+         * (using `TxnDelRq`) and then re-adding it with the desired values. You can
+         * do this only if no other downstream transactions have used that
+         * particular time tracking transaction. (Otherwise, the `TxnDel` request
+         * will fail.) This differs slightly from the UI, which allows these
+         * transactions to be edited directly. However, even in the UI, modifying a
+         * time tracking transaction does not result in changes to any downstream
+         * transactions that use it. There is no link between an invoice and the
+         * time entries. However when you do the invoicing from QuickBooks,
+         * QuickBooks does mark the time entries as “billed.” If you don’t record
+         * the time entries as billed properly, then you get into a user workflow
+         * issue where every time the user creates an invoice for a customer, QB
+         * pops up a dialog asking if they want to bill the un-billed time (which
+         * you already billed from your app). That’s why beginning with QB2007 and
+         * qbXML spec 6.0 we added support for the “BillableStatus” field *and* add
+         * `TimeTrackingMod` so that you can mark the time as billed when you create
+         * an invoice for it.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/TimeTrackingMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.TimeTrackingModRq["TimeTrackingMod"]) => Promise<NonNullable<qbd.TimeTrackingModRs["TimeTrackingRet"]>>;
+        /**
+         * The time-tracking transactions that are returned in this query include
+         * time tracking information that was entered into QuickBooks manually or
+         * gathered using the QuickBooks “Timer” or “Stopwatch.” Note that the
+         * QuickBooks Timer application can run on its own without QuickBooks, but
+         * the QuickBooks SDK cannot access the Timer data directly. The Timer data
+         * must be imported into QuickBooks before it is accessible via the SDK.)
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/TimeTrackingQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.TimeTrackingQueryRq) => Promise<NonNullable<qbd.TimeTrackingQueryRs["TimeTrackingRet"]>>;
+    };
+    vendor: {
+        /**
+         * Adds a vendor.
+         *
+         * A vendor is any person or company from whom a small business owner buys
+         * goods and services. (Banks and tax agencies usually are included on the
+         * vendor list.) A company’s vendor list contains information such as
+         * account balance and contact information about each vendor. A `VendorRef`
+         * aggregate refers to one of the vendors on the list. In a request, if a
+         * `VendorRef` aggregate includes both `FullName` and `ListID`, `FullName`
+         * will be ignored.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/VendorAdd
+         */
+        add: (integrationUserConnectionId: string, params: qbd.VendorAddRq["VendorAdd"]) => Promise<NonNullable<qbd.VendorAddRs["VendorRet"]>>;
+        /**
+         * Modifies a vendor.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/VendorMod
+         */
+        mod: (integrationUserConnectionId: string, params: qbd.VendorModRq["VendorMod"]) => Promise<NonNullable<qbd.VendorModRs["VendorRet"]>>;
+        /**
+         * Queries for the specified vendor or set of vendors.
+         *
+         * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop/VendorQuery
+         */
+        query: (integrationUserConnectionId: string, params: qbd.VendorQueryRq) => Promise<NonNullable<qbd.VendorQueryRs["VendorRet"]>>;
+    };
+    /**
+     * Send any QBXML request to QuickBooks Desktop.
+     *
+     * Available APIs:
+     * https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop
+     */
+    sendRequest(integrationUserConnectionId: string, requestObject: object): Promise<object>;
+    private sendRequestBase;
+}