conductor-node 10.5.5 → 11.0.1

package/README.md

@@ -32,11 +32,11 @@ import Conductor from "conductor-node";
 // Instantiate `Conductor` with your account's secret key.
 const conductor = new Conductor("sk_test_...");
 
-// Fetch all authorized integration-connections.
-const qbdConnections = await conductor.integrationConnection.list();
+// Fetch all authorized end-users.
+const endUsers = await conductor.endUsers.list();
 
-// Execute any QBD API against your QBD connection id.
-const newAccount = await conductor.qbd.account.add(qbdConnections[0].id, {
+// Execute any QBD API against your end-user.
+const newAccount = await conductor.qbd.account.add(endUsers[0].id, {
   Name: "Test Account",
   AccountType: "Bank",
   OpenBalance: "100",
@@ -45,29 +45,31 @@ const newAccount = await conductor.qbd.account.add(qbdConnections[0].id, {
 
 ## APIs
 
-### `integrationConnections.list()`
+### `qbd.*`
 
-Returns a of list all integration-connections associated with your Conductor account.
+Executes any QuickBooks Desktop (QBD) API against the specified end-user. See the official [QuickBooks Desktop API Reference](https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop) for a complete list of available APIs.
 
 ```ts
-const qbdConnections = await conductor.integrationConnections.list();
+const qbdAccount = await conductor.qbd.account.add(endUserId, {
+  Name: "Test Account",
+  AccountType: "Bank",
+  OpenBalance: "100",
+});
 ```
 
-### `integrationConnections.create(input: CreateIntegrationConnectionInput)`
+### `endUsers.create(input: EndUserCreateInput)`
 
-Creates a new integration-connection.
+Creates a new end-user.
 
 ```ts
-const newQbdConnection = await conductor.integrationConnections.create({
-  // The identifier of the third-party platform to integrate.
-  integrationSlug: "quickbooks-desktop",
-  // Your end-user's unique ID in your product's database. Must be
-  // distinct from your other connections for the same integration.
-  endUserSourceId: "1234-abcd",
+const newEndUser = await conductor.endUsers.create({
+  // Your end-user's unique ID in *your* database. Must be
+  // distinct from your other end-users.
+  sourceId: "1234-abcd",
   // Your end-user's email address.
-  endUserEmail: "danny@constructionco.com",
+  email: "danny@constructionco.com",
   // Your end-user's company name shown elsewhere in Conductor.
-  endUserCompanyName: "Construction Corp",
+  name: "Construction Corp",
 });
 ```
 
@@ -76,25 +78,31 @@ The response looks like the following:
 ```ts
 {
   // ❗ Save this `id` to your database for executing requests to this
-  // end-user's integration in the future.
-  id: 'int_conn_1234abcd',
-  integrationSlug: 'quickbooks-desktop',
-  endUserSourceId: "1234-abcd",
-  endUserEmail: 'danny@constructionco.com',
-  endUserCompanyName: 'Construction Corp',
+  // end-user's integration(s) in the future.
+  id: 'end_usr_1234abcd',
+  sourceId: "1234-abcd",
+  email: 'danny@construction.com',
+  name: 'Construction Corp',
 }
 ```
 
-### `integrationConnections.retrieve(id: string)`
+### `endUsers.list()`
+
+Returns a list of all end-users associated with your Conductor account.
+
+```ts
+const endUsers = await conductor.endUsers.list();
+```
+
+### `endUsers.retrieve(id: string)`
 
-Retrieves the specified integration-connection.
+Retrieves the specified end-User.
 
 ```ts
-const qbdConnection =
-  await conductor.integrationConnections.retrieve(qbdConnectionId);
+const endUser = await conductor.endUsers.retrieve(endUserId);
 ```
 
-### `integrationConnections.ping(id: string)`
+### `endUsers.ping(id: string, integrationSlug: string)`
 
 Checks whether the specified integration-connection can connect and process requests end-to-end.
 
@@ -104,7 +112,7 @@ Using `async`/`await`:
 
 ```ts
 try {
-  await conductor.integrationConnections.ping(qbdConnectionId);
+  await conductor.endUsers.ping(endUserId, "quickbooks-desktop");
 } catch (error) {
   if (error instanceof ConductorError) {
     // Update your app's UI to display `error.userFacingMessage`.
@@ -116,7 +124,7 @@ try {
 Or in the form of a rejected promise:
 
 ```ts
-conductor.integrationConnections.ping(qbdConnectionId).catch((error) => {
+conductor.endUsers.ping(endUserId, "quickbooks-desktop").catch((error) => {
   if (error instanceof ConductorError) {
     // Update your app's UI to display `error.userFacingMessage`.
   }
@@ -124,23 +132,11 @@ conductor.integrationConnections.ping(qbdConnectionId).catch((error) => {
 });
 ```
 
-### `qbd.*`
-
-Executes any QuickBooks Desktop (QBD) API against a specific integration-connection id. See the official [QuickBooks Desktop API Reference](https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop) for a complete list of available APIs.
-
-```ts
-const newAccount = await conductor.qbd.account.add(qbdConnectionId, {
-  Name: "Test Account",
-  AccountType: "Bank",
-  OpenBalance: "100",
-});
-```
-
 ## TypeScript
 
 Access the entire QuickBooks Desktop API through TypeScript. The `qbd.*` APIs are fully typed with inline documentation and will autocomplete in your editor.
 
-To manually access the QBD types, import them from `conductor-node` like so:
+To access the QBD types directly, import them from `conductor-node` like so:
 
 ```ts
 import { QbdTypes } from "conductor-node";
@@ -173,15 +169,15 @@ All errors thrown by the Conductor API are instances of `ConductorError` or its
 
 The error object you receive will have one of the following error types:
 
-| Name                                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ConductorIntegrationError`           | Raised when the third-party integration encounters an error while processing the end-user's request. This often results from an issue with the request or data handling that requires your attention to resolve.<br><br>E.g., a `ListID` you provided was not found in QuickBooks Desktop, or an accounting value you supplied did not adhere to the integration's accounting rules.<br><br>Refer to `error.integrationCode` for the error code returned by the integration, if available.                                                                                                                                                                                                               |
-| `ConductorIntegrationConnectionError` | Raised when a connection error occurs with the third-party integration on the end-user's side. This typically indicates an issue with the end-user's integration-connection or configuration, which they must resolve. In other words, you cannot take action to fix these errors.<br><br>E.g., QuickBooks Web Connector (QBWC) failed to connect to QuickBooks Desktop on the end-user's computer.<br><br>Refer to `error.integrationCode` for the error code returned by the integration connector, if available.<br><br>❗ We recommend _not_ alerting your team for these errors because only the end-user can fix them. See [Global Error Handling](#global-error-handling) for an example of this. |
-| `ConductorInvalidRequestError`        | Raised when you make an API call with the wrong parameters, in the wrong state, or in an invalid way.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `ConductorAuthenticationError`        | Raised when Conductor cannot authenticate you with the credentials you provided. E.g., an incorrect API key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `ConductorPermissionError`            | Raised when you attempt to access a resource that is not allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `ConductorConnectionError`            | Raised when there was a network problem between the client (on your server) and Conductor's servers. E.g., a downed network or a bad TLS certificate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `ConductorInternalError`              | Raised when something went wrong on Conductor's end. (These are rare.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| Name                                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ConductorIntegrationError`           | Raised when the third-party integration encounters an error while processing the end-user's request. This often results from an issue with the request or data handling that requires your attention to resolve.<br><br>E.g., a `ListID` you provided was not found in QuickBooks Desktop, or an accounting value you supplied did not adhere to the integration's accounting rules.<br><br>Refer to `error.integrationCode` for the error code returned by the integration, if available.                                                                                                                                                                                                              |
+| `ConductorIntegrationConnectionError` | Raised when a connection error occurs with the third-party integration on the end-user's side. This typically indicates an issue with the end-user's integration-connection or configuration, which they must resolve. In other words, you cannot take action to fix these errors.<br><br>E.g., QuickBooks Web Connector (QBWC) failed to connect to QuickBooks Desktop on the end-user's computer.<br><br>Refer to `error.integrationCode` for the error code returned by the integration connector, if available.<br><br>❗ We recommend _not_ triggering alerts for these errors because only the end-user can fix them. See [Global Error Handling](#global-error-handling) for an example of this. |
+| `ConductorInvalidRequestError`        | Raised when you make an API call with the wrong parameters, in the wrong state, or in an invalid way.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `ConductorAuthenticationError`        | Raised when Conductor cannot authenticate you with the credentials you provided. E.g., an incorrect API key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `ConductorPermissionError`            | Raised when you attempt to access a resource that is not allowed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `ConductorConnectionError`            | Raised when there was a network problem between the client (on your server) and Conductor's servers. E.g., a downed network or a bad TLS certificate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `ConductorInternalError`              | Raised when something went wrong on Conductor's end. (These are rare.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 
 ### Specific Error Handling
 
@@ -191,7 +187,7 @@ Using `async`/`await`:
 
 ```ts
 try {
-  const newAccount = await conductor.qbd.account.add(qbdConnectionId, {
+  const newAccount = await conductor.qbd.account.add(endUserId, {
     Name: "Test Account",
     AccountType: "Bank",
     OpenBalance: "100",
@@ -209,7 +205,7 @@ Or in the form of a rejected promise:
 
 ```ts
 conductor.qbd.account
-  .add(qbdConnectionId, {
+  .add(endUserId, {
     Name: "Test Account",
     AccountType: "Bank",
     OpenBalance: "100",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "conductor-node",
-    "version": "10.5.5",
+    "version": "11.0.1",
     "description": "Easily integrate the entire QuickBooks Desktop API using fully-typed async TypeScript",
     "keywords": [
         "QuickBooks Desktop",

package/dist/src/Client.d.ts

@@ -12,7 +12,12 @@ export interface ClientOptions {
 export default class Client {
     readonly endUsers: EndUsersResource;
     readonly integrationConnections: IntegrationConnectionsResource;
-    /** QuickBooks Desktop integration. */
+    /**
+     * Executes any QuickBooks Desktop (QBD) API against the specified end-user.
+     * See the official [QuickBooks Desktop API
+     * Reference](https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop)
+     * for a complete list of available APIs.
+     */
     readonly qbd: QbdIntegration;
     private readonly httpClient;
     constructor(apiKey: string, { verbose, serverEnvironment }?: ClientOptions);

package/dist/src/Client.js

@@ -15,14 +15,19 @@ const axios_1 = __importDefault(require("axios"));
 class Client {
     endUsers;
     integrationConnections;
-    /** QuickBooks Desktop integration. */
+    /**
+     * Executes any QuickBooks Desktop (QBD) API against the specified end-user.
+     * See the official [QuickBooks Desktop API
+     * Reference](https://developer.intuit.com/app/developer/qbdesktop/docs/api-reference/qbdesktop)
+     * for a complete list of available APIs.
+     */
     qbd;
     httpClient;
     constructor(apiKey, { verbose = false, serverEnvironment = "production" } = {}) {
         (0, checkForUpdates_1.checkForUpdates)();
         this.httpClient = this.createHttpClient(apiKey, verbose, serverEnvironment);
         this.endUsers = new EndUsersResource_1.default(this.httpClient);
-        this.integrationConnections = new IntegrationConnectionsResource_1.default(this);
+        this.integrationConnections = new IntegrationConnectionsResource_1.default(this.httpClient);
         this.qbd = new QbdIntegration_1.default(this.httpClient);
     }
     createHttpClient(apiKey, verbose, serverEnvironment) {

package/dist/src/integrations/BaseIntegration.d.ts

@@ -1,14 +1,9 @@
 import type { EndUser } from "../resources/EndUsersResource";
-import type { IntegrationConnection, IntegrationSlug } from "../resources/IntegrationConnectionsResource";
+import type { IntegrationSlug } from "../resources/IntegrationConnectionsResource";
 import type { AxiosInstance } from "axios";
 export default abstract class BaseIntegration {
     protected readonly httpClient: AxiosInstance;
     constructor(httpClient: AxiosInstance);
-    /**
-     * @deprecated Instead use `sendRequest` after migrating to the end-user
-     * model.
-     */
-    protected sendRequestDeprecated(id: IntegrationConnection["id"], payload: Record<string, unknown>): Promise<object>;
     /** Not intended for public use. */
     protected sendRequest(endUserId: EndUser["id"], integrationSlug: IntegrationSlug, payload: Record<string, unknown>): Promise<object>;
 }

package/dist/src/integrations/BaseIntegration.js

@@ -5,14 +5,6 @@ class BaseIntegration {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
-    /**
-     * @deprecated Instead use `sendRequest` after migrating to the end-user
-     * model.
-     */
-    async sendRequestDeprecated(id, payload) {
-        const { data } = await this.httpClient.post(`/integration-connections/${id}/send-request`, payload);
-        return data;
-    }
     /** Not intended for public use. */
     async sendRequest(endUserId, integrationSlug, payload) {
         const { data } = await this.httpClient.post(`/end-users/${endUserId}/send-request/${integrationSlug}`, payload);

package/dist/src/integrations/qbd/QbdIntegration.js

@@ -2443,12 +2443,7 @@ class QbdIntegration extends BaseIntegration_1.default {
         query: async (endUserId, params) => this.sendRequestWrapper(endUserId, { WorkersCompCodeQueryRq: params }, "WorkersCompCodeQueryRs", "WorkersCompCodeRet"),
     };
     async sendRequestWrapper(endUserId, params, responseWrapperKey, responseBodyKey) {
-        if (endUserId.startsWith("int_conn")) {
-            console.warn("Deprecation warning: `int_conn` Conductor ID format used. Support for this format will be removed in a future release. Please use the new `end_usr` format.");
-        }
-        const response = (endUserId.startsWith("int_conn")
-            ? await this.sendRequestDeprecated(endUserId, params)
-            : await this.sendRequest(endUserId, "quickbooks-desktop", params));
+        const response = (await this.sendRequest(endUserId, "quickbooks-desktop", params));
         const responseBody = response[responseWrapperKey]?.[responseBodyKey];
         if (responseBody === undefined) {
             throw new error_1.ConductorIntegrationError({

package/dist/src/resources/EndUsersResource.d.ts

@@ -4,28 +4,28 @@ export interface EndUser {
     /**
      * The unique identifier for the object.
      */
-    id: string;
+    readonly id: string;
     /**
-     * Your end-user's unique ID in your database. Must be distinct from your
+     * Your end-user's unique ID in *your* database. Must be distinct from your
      * other end-users.
      */
-    sourceId: string;
+    readonly sourceId: string;
     /**
      * Your end-user's email address.
      */
-    email: string;
+    readonly email: string;
     /**
      * Your end-user's company name that will be shown elsewhere in Conductor.
      */
-    name: string;
+    readonly name: string;
     /**
      * The time at which the object was created.
      */
-    createdAt: string;
+    readonly createdAt: string;
 }
 export type EndUserCreateInput = Pick<EndUser, "email" | "name" | "sourceId">;
 export interface EndUserPingOutput {
-    duration: number;
+    readonly duration: number;
 }
 export default class EndUsersResource extends BaseResource {
     protected readonly ROUTE = "/end-users";
@@ -51,10 +51,10 @@ export default class EndUsersResource extends BaseResource {
      * strongly recommend displaying the property `error.userFacingMessage` to
      * your end-user in your app's UI.
      *
-     * @param endUserId The ID of the end-user to ping.
+     * @param id The ID of the end-user to ping.
      * @param integrationSlug The integration identifier for the
      * integration-connection to ping.
      * @returns The ping result with the duration in milliseconds.
      */
-    ping(endUserId: EndUser["id"], integrationSlug: IntegrationSlug): Promise<EndUserPingOutput>;
+    ping(id: EndUser["id"], integrationSlug: IntegrationSlug): Promise<EndUserPingOutput>;
 }

package/dist/src/resources/EndUsersResource.js

@@ -37,13 +37,13 @@ class EndUsersResource extends BaseResource_1.default {
      * strongly recommend displaying the property `error.userFacingMessage` to
      * your end-user in your app's UI.
      *
-     * @param endUserId The ID of the end-user to ping.
+     * @param id The ID of the end-user to ping.
      * @param integrationSlug The integration identifier for the
      * integration-connection to ping.
      * @returns The ping result with the duration in milliseconds.
      */
-    async ping(endUserId, integrationSlug) {
-        const { data } = await this.httpClient.get(`${this.ROUTE}/${endUserId}/ping/${integrationSlug}`);
+    async ping(id, integrationSlug) {
+        const { data } = await this.httpClient.get(`${this.ROUTE}/${id}/ping/${integrationSlug}`);
         return data;
     }
 }

package/dist/src/resources/IntegrationConnectionAuthSessionsResource.d.ts

@@ -3,37 +3,37 @@ export interface IntegrationConnectionAuthSession {
     /**
      * The unique identifier for the object.
      */
-    id: string;
+    readonly id: string;
     /**
      * The ID of the end-user for whom to create an integration-connection in this
      * auth session.
      */
-    endUserId: string;
+    readonly endUserId: string;
     /**
      * The value that you will pass to the client to launch the authentication flow.
      */
-    clientSecret: string;
+    readonly clientSecret: string;
     /**
      * The URL to which to redirect the end-user to return to your app after
      * completing the authentication flow.
      */
-    returnUrl: string;
+    readonly returnUrl: string;
     /**
      * The time at which the auth-session expires.
      */
-    expiresAt: string;
+    readonly expiresAt: string;
 }
 export interface IntegrationConnectionAuthSessionCreateInput {
     /**
      * The ID of the end-user for whom to create an integration-connection in this
      * auth session.
      */
-    endUserId: string;
+    readonly endUserId: string;
     /**
      * The URL to which to redirect the end-user to return to your app after
      * completing the authentication flow.
      */
-    returnUrl: string;
+    readonly returnUrl: string;
 }
 export default class IntegrationConnectionAuthSessionsResource extends BaseResource {
     protected readonly ROUTE = "/integration-connection-auth-sessions";

package/dist/src/resources/IntegrationConnectionsResource.d.ts

@@ -1,71 +1,39 @@
-import type Client from "../Client";
 import BaseResource from "../resources/BaseResource";
 import IntegrationConnectionAuthSessionsResource from "../resources/IntegrationConnectionAuthSessionsResource";
+import type { AxiosInstance } from "axios";
 export type IntegrationSlug = "quickbooks-desktop";
 export interface IntegrationConnection {
     /**
      * The unique identifier for the object.
      */
-    id: string;
+    readonly id: string;
     /**
      * The ID of the end-user who owns this integration-connection.
      */
-    endUserId: string;
+    readonly endUserId: string;
     /**
      * The identifier of the third-party platform to integrate (e.g.,
      * "quickbooks-desktop").
      */
-    integrationSlug: IntegrationSlug;
+    readonly integrationSlug: IntegrationSlug;
     /**
      * The time at which the object was created.
      */
-    createdAt: string;
-}
-/**
- * @deprecated Use `conductor.endUsers.create()` instead.
- */
-export interface IntegrationConnectionCreateOldInput {
-    /**
-     * The identifier of the third-party platform to integrate (e.g.,
-     * "quickbooks-desktop").
-     */
-    integrationSlug: IntegrationSlug;
-    /**
-     * Your end-user's unique ID in your product's database. Must be distinct from
-     * your other connections for the same integration.
-     */
-    endUserSourceId: string;
-    /**
-     * Your end-user's email address.
-     */
-    endUserEmail: string;
-    /**
-     * Your end-user's company name that will be shown elsewhere in Conductor.
-     */
-    endUserCompanyName: string;
+    readonly createdAt: string;
 }
 export interface IntegrationConnectionPingOutput {
-    duration: number;
+    readonly duration: number;
 }
 export default class IntegrationConnectionsResource extends BaseResource {
     readonly authSessions: IntegrationConnectionAuthSessionsResource;
     protected readonly ROUTE = "/integration-connections";
-    private readonly client;
-    constructor(client: Client);
+    constructor(httpClient: AxiosInstance);
     /**
      * Returns a list of all integration-connections of all your end-users.
      */
     list(): Promise<IntegrationConnection[]>;
-    /**
-     * @deprecated Use `conductor.endUsers.create({ ... })` instead.
-     */
-    create(input: IntegrationConnectionCreateOldInput): Promise<IntegrationConnection>;
     /**
      * Retrieves the specified integration-connection.
      */
     retrieve(id: IntegrationConnection["id"]): Promise<IntegrationConnection>;
-    /**
-     * @deprecated Use `conductor.endUsers.ping(id, "quickbooks-desktop")` instead.
-     */
-    ping(id: IntegrationConnection["id"]): Promise<IntegrationConnectionPingOutput>;
 }

package/dist/src/resources/IntegrationConnectionsResource.js

@@ -8,11 +8,8 @@ const IntegrationConnectionAuthSessionsResource_1 = __importDefault(require("../
 class IntegrationConnectionsResource extends BaseResource_1.default {
     authSessions;
     ROUTE = "/integration-connections";
-    client;
-    constructor(client) {
-        // @ts-expect-error -- Temporary hack.
-        super(client.httpClient);
-        this.client = client;
+    constructor(httpClient) {
+        super(httpClient);
         this.authSessions = new IntegrationConnectionAuthSessionsResource_1.default(this.httpClient);
     }
     /**
@@ -22,22 +19,6 @@ class IntegrationConnectionsResource extends BaseResource_1.default {
         const { data } = await this.httpClient.get(this.ROUTE);
         return data;
     }
-    /**
-     * @deprecated Use `conductor.endUsers.create({ ... })` instead.
-     */
-    async create(input) {
-        const endUser = await this.client.endUsers.create({
-            sourceId: input.endUserSourceId,
-            email: input.endUserEmail,
-            name: input.endUserCompanyName,
-        });
-        return {
-            id: endUser.id,
-            endUserId: endUser.id,
-            integrationSlug: input.integrationSlug,
-            createdAt: endUser.createdAt,
-        };
-    }
     /**
      * Retrieves the specified integration-connection.
      */
@@ -45,16 +26,5 @@ class IntegrationConnectionsResource extends BaseResource_1.default {
         const { data } = await this.httpClient.get(`${this.ROUTE}/${id}`);
         return data;
     }
-    /**
-     * @deprecated Use `conductor.endUsers.ping(id, "quickbooks-desktop")` instead.
-     */
-    async ping(id) {
-        if (id.startsWith("int_conn")) {
-            console.warn("Deprecation warning: `int_conn` Conductor ID format used. Support for this format will be removed in a future release. Please use the new `end_usr` format.");
-            const { data } = await this.httpClient.get(`${this.ROUTE}/${id}/ping`);
-            return data;
-        }
-        return this.client.endUsers.ping(id, "quickbooks-desktop");
-    }
 }
 exports.default = IntegrationConnectionsResource;

package/dist/src/utils/error.d.ts

@@ -122,6 +122,9 @@ export declare class ConductorIntegrationError extends ConductorError {
  *
  * Refer to `error.integrationCode` for the error code returned by the
  * integration connector, if available.
+ *
+ * ❗ We recommend _not_ triggering alerts for these errors because only the
+ * end-user can fix them.
  */
 export declare class ConductorIntegrationConnectionError extends ConductorError {
     static readonly rawType = "INTEGRATION_CONNECTION_ERROR";

package/dist/src/utils/error.js

@@ -139,6 +139,9 @@ exports.ConductorIntegrationError = ConductorIntegrationError;
  *
  * Refer to `error.integrationCode` for the error code returned by the
  * integration connector, if available.
+ *
+ * ❗ We recommend _not_ triggering alerts for these errors because only the
+ * end-user can fix them.
  */
 class ConductorIntegrationConnectionError extends ConductorError {
     static rawType = "INTEGRATION_CONNECTION_ERROR";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conductor-node",
-  "version": "10.5.5",
+  "version": "11.0.1",
   "description": "Easily integrate the entire QuickBooks Desktop API using fully-typed async TypeScript",
   "keywords": [
     "QuickBooks Desktop",