@major-tech/resource-client 0.2.40 → 0.2.44

package/dist/index.cjs

@@ -15,54 +15,1961 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  BaseResourceClient: () => import_base.BaseResourceClient,
-  BigQueryResourceClient: () => import_bigquery.BigQueryResourceClient,
-  CosmosDBResourceClient: () => import_cosmosdb.CosmosDBResourceClient,
-  CustomApiResourceClient: () => import_api_custom.CustomApiResourceClient,
-  DynamoDBResourceClient: () => import_dynamodb.DynamoDBResourceClient,
-  GoogleAnalyticsResourceClient: () => import_google_analytics.GoogleAnalyticsResourceClient,
-  GoogleSheetsResourceClient: () => import_googlesheets.GoogleSheetsResourceClient,
-  GraphQLResourceClient: () => import_api_graphql.GraphQLResourceClient,
-  HubSpotResourceClient: () => import_hubspot.HubSpotResourceClient,
-  LambdaResourceClient: () => import_lambda.LambdaResourceClient,
-  MajorAuthResourceClient: () => import_auth.MajorAuthResourceClient,
-  MssqlResourceClient: () => import_mssql.MssqlResourceClient,
-  Neo4jResourceClient: () => import_neo4j.Neo4jResourceClient,
-  OutreachResourceClient: () => import_outreach.OutreachResourceClient,
-  PostgresResourceClient: () => import_postgres.PostgresResourceClient,
-  QuickBooksResourceClient: () => import_quickbooks.QuickBooksResourceClient,
-  ResourceInvokeError: () => import_errors.ResourceInvokeError,
-  S3ResourceClient: () => import_s3.S3ResourceClient,
-  SalesforceResourceClient: () => import_salesforce.SalesforceResourceClient,
-  SlackResourceClient: () => import_slack.SlackResourceClient,
-  SnowflakeResourceClient: () => import_snowflake.SnowflakeResourceClient
+  BaseResourceClient: () => BaseResourceClient,
+  BigQueryResourceClient: () => BigQueryResourceClient,
+  CosmosDBResourceClient: () => CosmosDBResourceClient,
+  CustomApiResourceClient: () => CustomApiResourceClient,
+  DynamoDBResourceClient: () => DynamoDBResourceClient,
+  GoogleAnalyticsResourceClient: () => GoogleAnalyticsResourceClient,
+  GoogleSheetsResourceClient: () => GoogleSheetsResourceClient,
+  GraphQLResourceClient: () => GraphQLResourceClient,
+  HubSpotResourceClient: () => HubSpotResourceClient,
+  LambdaResourceClient: () => LambdaResourceClient,
+  MajorAuthResourceClient: () => MajorAuthResourceClient,
+  MssqlResourceClient: () => MssqlResourceClient,
+  Neo4jResourceClient: () => Neo4jResourceClient,
+  OutreachResourceClient: () => OutreachResourceClient,
+  PostgresResourceClient: () => PostgresResourceClient,
+  QuickBooksResourceClient: () => QuickBooksResourceClient,
+  ResourceInvokeError: () => ResourceInvokeError,
+  S3ResourceClient: () => S3ResourceClient,
+  SalesforceResourceClient: () => SalesforceResourceClient,
+  SlackResourceClient: () => SlackResourceClient,
+  SnowflakeResourceClient: () => SnowflakeResourceClient,
+  buildAuthRevokeAccessPayload: () => buildAuthRevokeAccessPayload,
+  buildAuthShareAccessPayload: () => buildAuthShareAccessPayload,
+  buildBigQueryCreateTablePayload: () => buildBigQueryCreateTablePayload,
+  buildBigQueryGetTablePayload: () => buildBigQueryGetTablePayload,
+  buildBigQueryInsertRowsPayload: () => buildBigQueryInsertRowsPayload,
+  buildBigQueryInvokePayload: () => buildBigQueryInvokePayload,
+  buildBigQueryListDatasetsPayload: () => buildBigQueryListDatasetsPayload,
+  buildBigQueryListTablesPayload: () => buildBigQueryListTablesPayload,
+  buildBigQueryQueryPayload: () => buildBigQueryQueryPayload,
+  buildCosmosDBCreatePayload: () => buildCosmosDBCreatePayload,
+  buildCosmosDBDeletePayload: () => buildCosmosDBDeletePayload,
+  buildCosmosDBInvokePayload: () => buildCosmosDBInvokePayload,
+  buildCosmosDBPatchPayload: () => buildCosmosDBPatchPayload,
+  buildCosmosDBQueryPayload: () => buildCosmosDBQueryPayload,
+  buildCosmosDBReadPayload: () => buildCosmosDBReadPayload,
+  buildCosmosDBReplacePayload: () => buildCosmosDBReplacePayload,
+  buildCosmosDBUpsertPayload: () => buildCosmosDBUpsertPayload,
+  buildCustomApiInvokePayload: () => buildCustomApiInvokePayload,
+  buildDynamoDBInvokePayload: () => buildDynamoDBInvokePayload,
+  buildGoogleAnalyticsGetMetadataPayload: () => buildGoogleAnalyticsGetMetadataPayload,
+  buildGoogleAnalyticsInvokePayload: () => buildGoogleAnalyticsInvokePayload,
+  buildGoogleAnalyticsListAccountsPayload: () => buildGoogleAnalyticsListAccountsPayload,
+  buildGoogleAnalyticsListDataStreamsPayload: () => buildGoogleAnalyticsListDataStreamsPayload,
+  buildGoogleAnalyticsListPropertiesPayload: () => buildGoogleAnalyticsListPropertiesPayload,
+  buildGoogleAnalyticsRunRealtimeReportPayload: () => buildGoogleAnalyticsRunRealtimeReportPayload,
+  buildGoogleAnalyticsRunReportPayload: () => buildGoogleAnalyticsRunReportPayload,
+  buildGoogleSheetsAppendValuesPayload: () => buildGoogleSheetsAppendValuesPayload,
+  buildGoogleSheetsBatchGetValuesPayload: () => buildGoogleSheetsBatchGetValuesPayload,
+  buildGoogleSheetsBatchUpdatePayload: () => buildGoogleSheetsBatchUpdatePayload,
+  buildGoogleSheetsBatchUpdateValuesPayload: () => buildGoogleSheetsBatchUpdateValuesPayload,
+  buildGoogleSheetsClearValuesPayload: () => buildGoogleSheetsClearValuesPayload,
+  buildGoogleSheetsGetSpreadsheetPayload: () => buildGoogleSheetsGetSpreadsheetPayload,
+  buildGoogleSheetsGetValuesPayload: () => buildGoogleSheetsGetValuesPayload,
+  buildGoogleSheetsInvokePayload: () => buildGoogleSheetsInvokePayload,
+  buildGoogleSheetsUpdateValuesPayload: () => buildGoogleSheetsUpdateValuesPayload,
+  buildGraphQLInvokePayload: () => buildGraphQLInvokePayload,
+  buildHubSpotInvokePayload: () => buildHubSpotInvokePayload,
+  buildLambdaInvokePayload: () => buildLambdaInvokePayload,
+  buildMssqlInvokePayload: () => buildMssqlInvokePayload,
+  buildNeo4jInvokePayload: () => buildNeo4jInvokePayload,
+  buildOutreachInvokePayload: () => buildOutreachInvokePayload,
+  buildPayloadFromExtractedParams: () => buildPayloadFromExtractedParams,
+  buildPostgresInvokePayload: () => buildPostgresInvokePayload,
+  buildQuickBooksInvokePayload: () => buildQuickBooksInvokePayload,
+  buildQuickBooksQueryPayload: () => buildQuickBooksQueryPayload,
+  buildS3InvokePayload: () => buildS3InvokePayload,
+  buildSalesforceCreateRecordPayload: () => buildSalesforceCreateRecordPayload,
+  buildSalesforceDeleteRecordPayload: () => buildSalesforceDeleteRecordPayload,
+  buildSalesforceDescribeObjectPayload: () => buildSalesforceDescribeObjectPayload,
+  buildSalesforceGetRecordPayload: () => buildSalesforceGetRecordPayload,
+  buildSalesforceInvokePayload: () => buildSalesforceInvokePayload,
+  buildSalesforceQueryPayload: () => buildSalesforceQueryPayload,
+  buildSalesforceUpdateRecordPayload: () => buildSalesforceUpdateRecordPayload,
+  buildSlackInvokePayload: () => buildSlackInvokePayload,
+  buildSnowflakeCancelPayload: () => buildSnowflakeCancelPayload,
+  buildSnowflakeExecutePayload: () => buildSnowflakeExecutePayload,
+  buildSnowflakeInvokePayload: () => buildSnowflakeInvokePayload,
+  buildSnowflakeStatusPayload: () => buildSnowflakeStatusPayload
 });
 module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require("./schemas"), module.exports);
-var import_base = require("./base");
-var import_errors = require("./errors");
-var import_postgres = require("./clients/postgres");
-var import_mssql = require("./clients/mssql");
-var import_dynamodb = require("./clients/dynamodb");
-var import_cosmosdb = require("./clients/cosmosdb");
-var import_snowflake = require("./clients/snowflake");
-var import_api_custom = require("./clients/api-custom");
-var import_hubspot = require("./clients/hubspot");
-var import_salesforce = require("./clients/salesforce");
-var import_googlesheets = require("./clients/googlesheets");
-var import_s3 = require("./clients/s3");
-var import_lambda = require("./clients/lambda");
-var import_bigquery = require("./clients/bigquery");
-var import_outreach = require("./clients/outreach");
-var import_neo4j = require("./clients/neo4j");
-var import_slack = require("./clients/slack");
-var import_quickbooks = require("./clients/quickbooks");
-var import_auth = require("./clients/auth");
-var import_google_analytics = require("./clients/google-analytics");
-var import_api_graphql = require("./clients/api-graphql");
-__reExport(index_exports, require("./payload-builders"), module.exports);
+
+// src/errors.ts
+var ResourceInvokeError = class extends Error {
+  httpStatus;
+  requestId;
+  constructor(message, httpStatus, requestId) {
+    super(message);
+    this.name = "ResourceInvokeError";
+    this.httpStatus = httpStatus;
+    this.requestId = requestId;
+  }
+};
+
+// src/base.ts
+var BaseResourceClient = class {
+  config;
+  constructor(config) {
+    if (!config.applicationId && !config.toolId) {
+      throw new Error("BaseResourceClient requires either applicationId or toolId");
+    }
+    this.config = {
+      baseUrl: config.baseUrl.replace(/\/$/, ""),
+      majorJwtToken: config.majorJwtToken,
+      applicationId: config.applicationId,
+      toolId: config.toolId,
+      resourceId: config.resourceId,
+      fetch: config.fetch || globalThis.fetch,
+      getHeaders: config.getHeaders
+    };
+  }
+  async invokeRaw(payload, invocationKey) {
+    const entityType = this.config.toolId ? "tools" : "apps";
+    const entityId = this.config.toolId || this.config.applicationId;
+    const url = `${this.config.baseUrl}/internal/${entityType}/v1/${entityId}/resource/${this.config.resourceId}/invoke`;
+    const body = {
+      payload,
+      invocationKey
+    };
+    let headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.majorJwtToken) {
+      headers["x-major-jwt"] = this.config.majorJwtToken;
+    }
+    if (this.config.getHeaders) {
+      const extraHeaders = await this.config.getHeaders();
+      headers = { ...headers, ...extraHeaders };
+    }
+    try {
+      const response = await this.config.fetch(url, {
+        method: "POST",
+        headers,
+        credentials: "include",
+        body: JSON.stringify(body)
+      });
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ResourceInvokeError(`Failed to invoke resource: ${message}`);
+    }
+  }
+};
+
+// src/payload-builders/postgres.ts
+function buildPostgresInvokePayload(sql, params, timeoutMs) {
+  return {
+    type: "database",
+    subtype: "postgresql",
+    sql,
+    params,
+    timeoutMs
+  };
+}
+
+// src/clients/postgres.ts
+var PostgresResourceClient = class extends BaseResourceClient {
+  /**
+   * Execute a SQL query against PostgreSQL
+   * @param sql The SQL query to execute
+   * @param params Optional positional parameters ($1, $2, etc.)
+   * @param invocationKey Unique key for tracking this invocation
+   * @param timeoutMs Optional timeout in milliseconds
+   * @returns Typed response with rows of type T
+   *
+   * @example
+   * ```ts
+   * interface User { id: number; name: string; email: string }
+   *
+   * const response = await client.invoke<User>(
+   *   "SELECT id, name, email FROM users WHERE id = $1",
+   *   [123],
+   *   "get-user-123"
+   * );
+   *
+   * if (response.ok) {
+   *   const users: User[] = response.result.rows;
+   * }
+   * ```
+   */
+  async invoke(sql, params, invocationKey, timeoutMs) {
+    const payload = buildPostgresInvokePayload(sql, params, timeoutMs);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/mssql.ts
+function buildMssqlInvokePayload(sql, params, timeoutMs) {
+  return {
+    type: "database",
+    subtype: "mssql",
+    sql,
+    params,
+    timeoutMs
+  };
+}
+
+// src/clients/mssql.ts
+var MssqlResourceClient = class extends BaseResourceClient {
+  /**
+   * Execute a SQL query against MSSQL
+   * @param sql The SQL query to execute
+   * @param params Optional named parameters (e.g., { id: 123 } for @id in the query)
+   * @param invocationKey Unique key for tracking this invocation
+   * @param timeoutMs Optional timeout in milliseconds
+   * @returns Typed response with rows of type T
+   *
+   * @example
+   * ```ts
+   * interface User { id: number; name: string; email: string }
+   *
+   * const response = await client.invoke<User>(
+   *   "SELECT id, name, email FROM users WHERE id = @id",
+   *   { id: 123 },
+   *   "get-user-123"
+   * );
+   *
+   * if (response.ok) {
+   *   const users: User[] = response.result.rows;
+   * }
+   * ```
+   */
+  async invoke(sql, params, invocationKey, timeoutMs) {
+    const payload = buildMssqlInvokePayload(sql, params, timeoutMs);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/dynamodb.ts
+function buildDynamoDBInvokePayload(command, params) {
+  return {
+    type: "database",
+    subtype: "dynamodb",
+    command,
+    params
+  };
+}
+
+// src/clients/dynamodb.ts
+var DynamoDBResourceClient = class extends BaseResourceClient {
+  async invoke(command, params, invocationKey) {
+    const payload = buildDynamoDBInvokePayload(command, params);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/cosmosdb.ts
+function buildCosmosDBInvokePayload(payload) {
+  return payload;
+}
+function buildCosmosDBQueryPayload(container, query, options) {
+  return {
+    type: "database",
+    subtype: "cosmosdb",
+    operation: "query",
+    container,
+    query,
+    parameters: options?.parameters,
+    partitionKey: options?.partitionKey,
+    maxItemCount: options?.maxItemCount,
+    continuationToken: options?.continuationToken,
+    timeoutMs: options?.timeoutMs
+  };
+}
+function buildCosmosDBReadPayload(container, id, options) {
+  return {
+    type: "database",
+    subtype: "cosmosdb",
+    operation: "read",
+    container,
+    id,
+    partitionKey: options?.partitionKey,
+    timeoutMs: options?.timeoutMs
+  };
+}
+function buildCosmosDBCreatePayload(container, body, options) {
+  return {
+    type: "database",
+    subtype: "cosmosdb",
+    operation: "create",
+    container,
+    body,
+    partitionKey: options?.partitionKey,
+    timeoutMs: options?.timeoutMs
+  };
+}
+function buildCosmosDBReplacePayload(container, id, body, options) {
+  return {
+    type: "database",
+    subtype: "cosmosdb",
+    operation: "replace",
+    container,
+    id,
+    body,
+    partitionKey: options?.partitionKey,
+    timeoutMs: options?.timeoutMs
+  };
+}
+function buildCosmosDBUpsertPayload(container, body, options) {
+  return {
+    type: "database",
+    subtype: "cosmosdb",
+    operation: "upsert",
+    container,
+    body,
+    partitionKey: options?.partitionKey,
+    timeoutMs: options?.timeoutMs
+  };
+}
+function buildCosmosDBDeletePayload(container, id, options) {
+  return {
+    type: "database",
+    subtype: "cosmosdb",
+    operation: "delete",
+    container,
+    id,
+    partitionKey: options?.partitionKey,
+    timeoutMs: options?.timeoutMs
+  };
+}
+function buildCosmosDBPatchPayload(container, id, patchOperations, options) {
+  return {
+    type: "database",
+    subtype: "cosmosdb",
+    operation: "patch",
+    container,
+    id,
+    patchOperations,
+    partitionKey: options?.partitionKey,
+    condition: options?.condition,
+    timeoutMs: options?.timeoutMs
+  };
+}
+
+// src/clients/cosmosdb.ts
+var CosmosDBResourceClient = class extends BaseResourceClient {
+  /**
+   * Invoke a CosmosDB operation with a raw payload
+   * @param payload The complete operation payload
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async invoke(payload, invocationKey) {
+    return this.invokeRaw(buildCosmosDBInvokePayload(payload), invocationKey);
+  }
+  /**
+   * Execute a SQL query against a container
+   * @param container The container name
+   * @param query The SQL query string
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Query options (parameters, partitionKey, pagination)
+   */
+  async query(container, query, invocationKey, options) {
+    const payload = buildCosmosDBQueryPayload(container, query, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Read a single document by ID
+   * @param container The container name
+   * @param id The document ID
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Additional options (partitionKey, timeoutMs)
+   */
+  async read(container, id, invocationKey, options) {
+    const payload = buildCosmosDBReadPayload(container, id, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Create a new document
+   * @param container The container name
+   * @param body The document body (must include id and partition key properties)
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Additional options (partitionKey, timeoutMs)
+   */
+  async create(container, body, invocationKey, options) {
+    const payload = buildCosmosDBCreatePayload(container, body, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Replace an existing document
+   * @param container The container name
+   * @param id The document ID
+   * @param body The new document body
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Additional options (partitionKey, timeoutMs)
+   */
+  async replace(container, id, body, invocationKey, options) {
+    const payload = buildCosmosDBReplacePayload(container, id, body, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Upsert a document (insert or replace)
+   * @param container The container name
+   * @param body The document body (must include id and partition key properties)
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Additional options (partitionKey, timeoutMs)
+   */
+  async upsert(container, body, invocationKey, options) {
+    const payload = buildCosmosDBUpsertPayload(container, body, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Delete a document
+   * @param container The container name
+   * @param id The document ID
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Additional options (partitionKey, timeoutMs)
+   */
+  async delete(container, id, invocationKey, options) {
+    const payload = buildCosmosDBDeletePayload(container, id, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Patch a document with partial updates
+   * @param container The container name
+   * @param id The document ID
+   * @param patchOperations Array of patch operations
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Additional options (partitionKey, condition, timeoutMs)
+   */
+  async patch(container, id, patchOperations, invocationKey, options) {
+    const payload = buildCosmosDBPatchPayload(container, id, patchOperations, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/snowflake.ts
+function buildSnowflakeInvokePayload(payload) {
+  return payload;
+}
+function buildSnowflakeExecutePayload(statement, options) {
+  return {
+    type: "database",
+    subtype: "snowflake",
+    operation: "execute",
+    statement,
+    bindings: options?.bindings,
+    database: options?.database,
+    schema: options?.schema,
+    warehouse: options?.warehouse,
+    role: options?.role,
+    timeout: options?.timeout,
+    async: options?.async,
+    parameters: options?.parameters,
+    nullable: options?.nullable,
+    requestId: options?.requestId
+  };
+}
+function buildSnowflakeStatusPayload(statementHandle, options) {
+  return {
+    type: "database",
+    subtype: "snowflake",
+    operation: "status",
+    statementHandle,
+    partition: options?.partition
+  };
+}
+function buildSnowflakeCancelPayload(statementHandle) {
+  return {
+    type: "database",
+    subtype: "snowflake",
+    operation: "cancel",
+    statementHandle
+  };
+}
+
+// src/clients/snowflake.ts
+var SnowflakeResourceClient = class extends BaseResourceClient {
+  /**
+   * Invoke a Snowflake operation with a raw payload
+   * @param payload The complete operation payload
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async invoke(payload, invocationKey) {
+    return this.invokeRaw(buildSnowflakeInvokePayload(payload), invocationKey);
+  }
+  /**
+   * Execute a SQL statement
+   * @param statement The SQL statement to execute
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Execution options (bindings, database overrides, async, etc.)
+   */
+  async execute(statement, invocationKey, options = {}) {
+    const payload = buildSnowflakeExecutePayload(statement, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Get status or results of a statement
+   * @param statementHandle The statement handle from execute operation
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Status options (partition for paginated results)
+   */
+  async status(statementHandle, invocationKey, options = {}) {
+    const payload = buildSnowflakeStatusPayload(statementHandle, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Cancel a running statement
+   * @param statementHandle The statement handle to cancel
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async cancel(statementHandle, invocationKey) {
+    const payload = buildSnowflakeCancelPayload(statementHandle);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/custom.ts
+function buildCustomApiInvokePayload(method, path, options) {
+  return {
+    type: "api",
+    subtype: "custom",
+    method,
+    path,
+    query: options?.query,
+    headers: options?.headers,
+    body: options?.body,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+
+// src/clients/api-custom.ts
+var CustomApiResourceClient = class extends BaseResourceClient {
+  async invoke(method, path, invocationKey, options = {}) {
+    const payload = buildCustomApiInvokePayload(method, path, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/hubspot.ts
+function buildHubSpotInvokePayload(method, path, options) {
+  return {
+    type: "api",
+    subtype: "hubspot",
+    method,
+    path,
+    query: options?.query,
+    body: options?.body,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+
+// src/clients/hubspot.ts
+var HubSpotResourceClient = class extends BaseResourceClient {
+  async invoke(method, path, invocationKey, options = {}) {
+    const payload = buildHubSpotInvokePayload(method, path, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/salesforce.ts
+function buildSalesforceInvokePayload(method, path, options) {
+  return {
+    type: "api",
+    subtype: "salesforce",
+    method,
+    path,
+    query: options?.query,
+    body: options?.body,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+function buildSalesforceQueryPayload(query, options) {
+  return buildSalesforceInvokePayload("GET", "/services/data/v63.0/query", {
+    query: { q: [query] },
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildSalesforceGetRecordPayload(objectType, recordId, options) {
+  const query = {};
+  if (options?.fields && options.fields.length > 0) {
+    query.fields = [options.fields.join(",")];
+  }
+  return buildSalesforceInvokePayload(
+    "GET",
+    `/services/data/v63.0/sobjects/${objectType}/${recordId}`,
+    {
+      query: Object.keys(query).length > 0 ? query : void 0,
+      timeoutMs: options?.timeoutMs
+    }
+  );
+}
+function buildSalesforceCreateRecordPayload(objectType, data, options) {
+  return buildSalesforceInvokePayload(
+    "POST",
+    `/services/data/v63.0/sobjects/${objectType}`,
+    {
+      body: { type: "json", value: data },
+      timeoutMs: options?.timeoutMs
+    }
+  );
+}
+function buildSalesforceUpdateRecordPayload(objectType, recordId, data, options) {
+  return buildSalesforceInvokePayload(
+    "PATCH",
+    `/services/data/v63.0/sobjects/${objectType}/${recordId}`,
+    {
+      body: { type: "json", value: data },
+      timeoutMs: options?.timeoutMs
+    }
+  );
+}
+function buildSalesforceDeleteRecordPayload(objectType, recordId, options) {
+  return buildSalesforceInvokePayload(
+    "DELETE",
+    `/services/data/v63.0/sobjects/${objectType}/${recordId}`,
+    {
+      timeoutMs: options?.timeoutMs
+    }
+  );
+}
+function buildSalesforceDescribeObjectPayload(objectType, options) {
+  return buildSalesforceInvokePayload(
+    "GET",
+    `/services/data/v63.0/sobjects/${objectType}/describe`,
+    {
+      timeoutMs: options?.timeoutMs
+    }
+  );
+}
+
+// src/clients/salesforce.ts
+var SalesforceResourceClient = class extends BaseResourceClient {
+  /**
+   * Invoke a Salesforce API request
+   *
+   * @param method - HTTP method (GET, POST, PATCH, DELETE)
+   * @param path - Salesforce API path (e.g., "/services/data/v63.0/query")
+   * @param invocationKey - Unique key for this invocation (for tracking)
+   * @param options - Optional query params, body, and timeout
+   * @returns The API response with status and body
+   */
+  async invoke(method, path, invocationKey, options = {}) {
+    const payload = buildSalesforceInvokePayload(method, path, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Execute a SOQL query
+   *
+   * @param query - SOQL query string
+   * @param invocationKey - Unique key for this invocation
+   * @param options - Optional timeout
+   * @returns Query results
+   *
+   * @example
+   * ```typescript
+   * const result = await client.query(
+   *   "SELECT Id, Name, CreatedDate FROM Account WHERE CreatedDate > 2024-01-01T00:00:00Z",
+   *   "recent-accounts"
+   * );
+   * ```
+   */
+  async query(query, invocationKey, options = {}) {
+    return this.invoke("GET", "/services/data/v63.0/query", invocationKey, {
+      query: { q: [query] },
+      timeoutMs: options.timeoutMs
+    });
+  }
+  /**
+   * Get a single record by ID
+   *
+   * @param objectType - Salesforce object type (e.g., "Account", "Contact")
+   * @param recordId - The record ID
+   * @param invocationKey - Unique key for this invocation
+   * @param options - Optional fields to retrieve and timeout
+   * @returns The record data
+   */
+  async getRecord(objectType, recordId, invocationKey, options = {}) {
+    const query = {};
+    if (options.fields && options.fields.length > 0) {
+      query.fields = [options.fields.join(",")];
+    }
+    return this.invoke(
+      "GET",
+      `/services/data/v63.0/sobjects/${objectType}/${recordId}`,
+      invocationKey,
+      { query: Object.keys(query).length > 0 ? query : void 0, timeoutMs: options.timeoutMs }
+    );
+  }
+  /**
+   * Create a new record
+   *
+   * @param objectType - Salesforce object type (e.g., "Account", "Contact")
+   * @param data - Record data
+   * @param invocationKey - Unique key for this invocation
+   * @param options - Optional timeout
+   * @returns The created record ID
+   */
+  async createRecord(objectType, data, invocationKey, options = {}) {
+    return this.invoke(
+      "POST",
+      `/services/data/v63.0/sobjects/${objectType}`,
+      invocationKey,
+      { body: { type: "json", value: data }, timeoutMs: options.timeoutMs }
+    );
+  }
+  /**
+   * Update an existing record
+   *
+   * @param objectType - Salesforce object type (e.g., "Account", "Contact")
+   * @param recordId - The record ID to update
+   * @param data - Fields to update
+   * @param invocationKey - Unique key for this invocation
+   * @param options - Optional timeout
+   * @returns Empty response on success
+   */
+  async updateRecord(objectType, recordId, data, invocationKey, options = {}) {
+    return this.invoke(
+      "PATCH",
+      `/services/data/v63.0/sobjects/${objectType}/${recordId}`,
+      invocationKey,
+      { body: { type: "json", value: data }, timeoutMs: options.timeoutMs }
+    );
+  }
+  /**
+   * Delete a record
+   *
+   * @param objectType - Salesforce object type (e.g., "Account", "Contact")
+   * @param recordId - The record ID to delete
+   * @param invocationKey - Unique key for this invocation
+   * @param options - Optional timeout
+   * @returns Empty response on success
+   */
+  async deleteRecord(objectType, recordId, invocationKey, options = {}) {
+    return this.invoke(
+      "DELETE",
+      `/services/data/v63.0/sobjects/${objectType}/${recordId}`,
+      invocationKey,
+      { timeoutMs: options.timeoutMs }
+    );
+  }
+  /**
+   * Describe an object to get its metadata
+   *
+   * @param objectType - Salesforce object type (e.g., "Account", "Contact")
+   * @param invocationKey - Unique key for this invocation
+   * @param options - Optional timeout
+   * @returns Object metadata including fields, relationships, etc.
+   */
+  async describeObject(objectType, invocationKey, options = {}) {
+    return this.invoke(
+      "GET",
+      `/services/data/v63.0/sobjects/${objectType}/describe`,
+      invocationKey,
+      { timeoutMs: options.timeoutMs }
+    );
+  }
+};
+
+// src/payload-builders/googlesheets.ts
+function buildGoogleSheetsInvokePayload(method, path, options) {
+  return {
+    type: "api",
+    subtype: "googlesheets",
+    method,
+    path,
+    query: options?.query,
+    body: options?.body,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+function buildGoogleSheetsGetValuesPayload(range, options) {
+  return buildGoogleSheetsInvokePayload("GET", `/values/${range}`, {
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildGoogleSheetsUpdateValuesPayload(range, values, valueInputOption = "USER_ENTERED", options) {
+  return buildGoogleSheetsInvokePayload("PUT", `/values/${range}`, {
+    query: { valueInputOption: [valueInputOption] },
+    body: { type: "json", value: { values } },
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildGoogleSheetsAppendValuesPayload(range, values, valueInputOption = "USER_ENTERED", options) {
+  return buildGoogleSheetsInvokePayload("POST", `/values/${range}:append`, {
+    query: { valueInputOption: [valueInputOption] },
+    body: { type: "json", value: { values } },
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildGoogleSheetsClearValuesPayload(range, options) {
+  return buildGoogleSheetsInvokePayload("POST", `/values/${range}:clear`, {
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildGoogleSheetsBatchGetValuesPayload(ranges, options) {
+  return buildGoogleSheetsInvokePayload("GET", "/values:batchGet", {
+    query: { ranges },
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildGoogleSheetsBatchUpdateValuesPayload(data, valueInputOption = "USER_ENTERED", options) {
+  return buildGoogleSheetsInvokePayload("POST", "/values:batchUpdate", {
+    body: {
+      type: "json",
+      value: {
+        valueInputOption,
+        data
+      }
+    },
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildGoogleSheetsGetSpreadsheetPayload(options) {
+  return buildGoogleSheetsInvokePayload("GET", "/", {
+    timeoutMs: options?.timeoutMs
+  });
+}
+function buildGoogleSheetsBatchUpdatePayload(requests, options) {
+  return buildGoogleSheetsInvokePayload("POST", "/:batchUpdate", {
+    body: { type: "json", value: { requests } },
+    timeoutMs: options?.timeoutMs
+  });
+}
+
+// src/clients/googlesheets.ts
+var GoogleSheetsResourceClient = class extends BaseResourceClient {
+  async invoke(method, path, invocationKey, options = {}) {
+    const payload = buildGoogleSheetsInvokePayload(method, path, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Get values from a range in the spreadsheet
+   * @param range A1 notation range (e.g., "Sheet1!A1:D5")
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async getValues(range, invocationKey) {
+    return this.invoke("GET", `/values/${range}`, invocationKey);
+  }
+  /**
+   * Update values in a range in the spreadsheet
+   * @param range A1 notation range (e.g., "Sheet1!A1:D5")
+   * @param values 2D array of values to write
+   * @param invocationKey Unique key for tracking this invocation
+   * @param valueInputOption How to interpret input values ("RAW" or "USER_ENTERED")
+   */
+  async updateValues(range, values, invocationKey, valueInputOption = "USER_ENTERED") {
+    return this.invoke(
+      "PUT",
+      `/values/${range}`,
+      invocationKey,
+      {
+        query: { valueInputOption },
+        body: { type: "json", value: { values } }
+      }
+    );
+  }
+  /**
+   * Append values to a sheet
+   * @param range A1 notation range (e.g., "Sheet1!A1:D1")
+   * @param values 2D array of values to append
+   * @param invocationKey Unique key for tracking this invocation
+   * @param valueInputOption How to interpret input values ("RAW" or "USER_ENTERED")
+   */
+  async appendValues(range, values, invocationKey, valueInputOption = "USER_ENTERED") {
+    return this.invoke(
+      "POST",
+      `/values/${range}:append`,
+      invocationKey,
+      {
+        query: { valueInputOption },
+        body: { type: "json", value: { values } }
+      }
+    );
+  }
+  /**
+   * Clear values in a range
+   * @param range A1 notation range (e.g., "Sheet1!A1:D5")
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async clearValues(range, invocationKey) {
+    return this.invoke("POST", `/values/${range}:clear`, invocationKey);
+  }
+  /**
+   * Batch get multiple ranges
+   * @param ranges Array of A1 notation ranges
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async batchGetValues(ranges, invocationKey) {
+    return this.invoke("GET", "/values:batchGet", invocationKey, {
+      query: { ranges }
+    });
+  }
+  /**
+   * Batch update multiple ranges
+   * @param data Array of range updates
+   * @param invocationKey Unique key for tracking this invocation
+   * @param valueInputOption How to interpret input values ("RAW" or "USER_ENTERED")
+   */
+  async batchUpdateValues(data, invocationKey, valueInputOption = "USER_ENTERED") {
+    return this.invoke("POST", "/values:batchUpdate", invocationKey, {
+      body: {
+        type: "json",
+        value: {
+          valueInputOption,
+          data
+        }
+      }
+    });
+  }
+  /**
+   * Get spreadsheet metadata
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async getSpreadsheet(invocationKey) {
+    return this.invoke("GET", "/", invocationKey);
+  }
+  /**
+   * Batch update spreadsheet (for formatting, creating sheets, etc.)
+   * @param requests Array of update requests
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async batchUpdate(requests, invocationKey) {
+    return this.invoke("POST", "/:batchUpdate", invocationKey, {
+      body: { type: "json", value: { requests } }
+    });
+  }
+};
+
+// src/payload-builders/s3.ts
+function buildS3InvokePayload(command, params, options) {
+  return {
+    type: "storage",
+    subtype: "s3",
+    command,
+    params,
+    timeoutMs: options?.timeoutMs
+  };
+}
+
+// src/clients/s3.ts
+var S3ResourceClient = class extends BaseResourceClient {
+  async invoke(command, params, invocationKey, options = {}) {
+    const payload = buildS3InvokePayload(command, params, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/lambda.ts
+function buildLambdaInvokePayload(functionName, payload, options) {
+  return {
+    type: "api",
+    subtype: "lambda",
+    FunctionName: functionName,
+    Payload: payload,
+    ...options
+  };
+}
+
+// src/clients/lambda.ts
+var LambdaResourceClient = class extends BaseResourceClient {
+  /**
+   * Invoke a Lambda function
+   *
+   * @param functionName - The name, ARN, or partial ARN of the Lambda function
+   * @param payload - The JSON input for the Lambda function (optional)
+   * @param invocationKey - A unique key for tracking this invocation
+   * @param options - Additional invocation options
+   * @returns The Lambda invocation result
+   *
+   * @example
+   * ```typescript
+   * // Simple synchronous invocation
+   * const result = await lambdaClient.invoke(
+   *   "my-function",
+   *   { key: "value" },
+   *   "process-data"
+   * );
+   *
+   * if (result.ok) {
+   *   console.log("Response:", result.result.Payload);
+   * }
+   *
+   * // Asynchronous invocation
+   * const asyncResult = await lambdaClient.invoke(
+   *   "my-function",
+   *   { key: "value" },
+   *   "async-process",
+   *   { InvocationType: "Event" }
+   * );
+   *
+   * // With execution logs
+   * const debugResult = await lambdaClient.invoke(
+   *   "my-function",
+   *   { key: "value" },
+   *   "debug-invocation",
+   *   { LogType: "Tail" }
+   * );
+   *
+   * if (debugResult.ok) {
+   *   // LogResult is base64 encoded
+   *   const logs = atob(debugResult.result.LogResult || "");
+   *   console.log("Execution logs:", logs);
+   * }
+   * ```
+   */
+  async invoke(functionName, payload, invocationKey, options = {}) {
+    const invokePayload = buildLambdaInvokePayload(functionName, payload, options);
+    return this.invokeRaw(invokePayload, invocationKey);
+  }
+};
+
+// src/payload-builders/bigquery.ts
+function buildBigQueryQueryPayload(sql, params, options) {
+  return {
+    type: "database",
+    subtype: "bigquery",
+    operation: "query",
+    sql,
+    params,
+    timeoutMs: options?.timeoutMs,
+    maxResults: options?.maxResults
+  };
+}
+function buildBigQueryListDatasetsPayload(options) {
+  return {
+    type: "database",
+    subtype: "bigquery",
+    operation: "listDatasets",
+    maxResults: options?.maxResults
+  };
+}
+function buildBigQueryListTablesPayload(datasetId, options) {
+  return {
+    type: "database",
+    subtype: "bigquery",
+    operation: "listTables",
+    datasetId,
+    maxResults: options?.maxResults
+  };
+}
+function buildBigQueryGetTablePayload(datasetId, tableId) {
+  return {
+    type: "database",
+    subtype: "bigquery",
+    operation: "getTable",
+    datasetId,
+    tableId
+  };
+}
+function buildBigQueryInsertRowsPayload(datasetId, tableId, rows) {
+  return {
+    type: "database",
+    subtype: "bigquery",
+    operation: "insertRows",
+    datasetId,
+    tableId,
+    rows
+  };
+}
+function buildBigQueryCreateTablePayload(datasetId, tableId, schema, options) {
+  return {
+    type: "database",
+    subtype: "bigquery",
+    operation: "createTable",
+    datasetId,
+    tableId,
+    schema,
+    timeoutMs: options?.timeoutMs
+  };
+}
+function buildBigQueryInvokePayload(payload) {
+  return {
+    type: "database",
+    subtype: "bigquery",
+    ...payload
+  };
+}
+
+// src/clients/bigquery.ts
+var BigQueryResourceClient = class extends BaseResourceClient {
+  /**
+   * Execute a SQL query
+   * @param sql The SQL query to execute
+   * @param params Optional query parameters (named parameters)
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Query options
+   */
+  async query(sql, params, invocationKey, options) {
+    const payload = buildBigQueryQueryPayload(sql, params, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * List all datasets in the project
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options List options
+   */
+  async listDatasets(invocationKey, options) {
+    const payload = buildBigQueryListDatasetsPayload(options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * List all tables in a dataset
+   * @param datasetId The dataset ID
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options List options
+   */
+  async listTables(datasetId, invocationKey, options) {
+    const payload = buildBigQueryListTablesPayload(datasetId, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Get table metadata and schema
+   * @param datasetId The dataset ID
+   * @param tableId The table ID
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async getTable(datasetId, tableId, invocationKey) {
+    const payload = buildBigQueryGetTablePayload(datasetId, tableId);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Insert rows into a table (streaming insert)
+   * @param datasetId The dataset ID
+   * @param tableId The table ID
+   * @param rows Array of rows to insert
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async insertRows(datasetId, tableId, rows, invocationKey) {
+    const payload = buildBigQueryInsertRowsPayload(datasetId, tableId, rows);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Create a new table
+   * @param datasetId The dataset ID
+   * @param tableId The table ID
+   * @param schema Table schema definition
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Table creation options
+   */
+  async createTable(datasetId, tableId, schema, invocationKey, options) {
+    const payload = buildBigQueryCreateTablePayload(datasetId, tableId, schema, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Raw invoke with a custom payload
+   * @param payload The BigQuery payload
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async invoke(payload, invocationKey) {
+    const fullPayload = buildBigQueryInvokePayload(payload);
+    return this.invokeRaw(fullPayload, invocationKey);
+  }
+};
+
+// src/clients/outreach.ts
+var OutreachResourceClient = class extends BaseResourceClient {
+  /**
+   * Invoke an Outreach API endpoint
+   *
+   * @param method - HTTP method (GET, POST, PUT, PATCH, DELETE)
+   * @param path - Outreach API path (e.g., "/api/v2/prospects")
+   * @param invocationKey - Unique key for this invocation (for idempotency/tracking)
+   * @param options - Optional query params, body, and timeout
+   */
+  async invoke(method, path, invocationKey, options = {}) {
+    const payload = {
+      type: "api",
+      subtype: "outreach",
+      method,
+      path,
+      queryParams: options.queryParams,
+      body: options.body,
+      timeoutMs: options.timeoutMs || 3e4
+    };
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/neo4j.ts
+function buildNeo4jInvokePayload(cypher, params, timeoutMs) {
+  return {
+    type: "database",
+    subtype: "neo4j",
+    cypher,
+    params,
+    timeoutMs
+  };
+}
+
+// src/clients/neo4j.ts
+var Neo4jResourceClient = class extends BaseResourceClient {
+  /**
+   * Execute a Cypher query against Neo4j
+   * @param cypher The Cypher query to execute
+   * @param params Optional named parameters for the query
+   * @param invocationKey Unique key for tracking this invocation
+   * @param timeoutMs Optional timeout in milliseconds
+   * @returns Response with records and keys
+   *
+   * @example
+   * ```ts
+   * const response = await client.invoke(
+   *   "MATCH (n:Person {name: $name}) RETURN n",
+   *   { name: "Alice" },
+   *   "find-alice"
+   * );
+   *
+   * if (response.ok) {
+   *   const records = response.result.records;
+   * }
+   * ```
+   */
+  async invoke(cypher, params, invocationKey, timeoutMs) {
+    const payload = buildNeo4jInvokePayload(cypher, params, timeoutMs);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/slack.ts
+function buildSlackInvokePayload(method, options) {
+  return {
+    type: "api",
+    subtype: "slack",
+    method,
+    body: options?.body,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+function buildSlackGetUploadURLPayload(filename, length, options) {
+  return buildSlackInvokePayload("files.getUploadURLExternal", {
+    body: {
+      filename,
+      length,
+      alt_txt: options?.altText,
+      snippet_type: options?.snippetType
+    }
+  });
+}
+function buildSlackCompleteUploadPayload(files, channelId, options) {
+  return buildSlackInvokePayload("files.completeUploadExternal", {
+    body: {
+      files,
+      channel_id: channelId,
+      initial_comment: options?.initialComment,
+      thread_ts: options?.threadTs
+    }
+  });
+}
+
+// src/clients/slack.ts
+var SlackResourceClient = class extends BaseResourceClient {
+  async invoke(method, invocationKey, options = {}) {
+    const payload = buildSlackInvokePayload(method, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Get a pre-signed upload URL for uploading a file to Slack.
+   * Step 1 of the file upload flow.
+   * @see https://docs.slack.dev/reference/methods/files.getUploadURLExternal
+   */
+  async getUploadURL(filename, length, invocationKey, options) {
+    return this.invoke("files.getUploadURLExternal", invocationKey, {
+      body: {
+        filename,
+        length,
+        alt_txt: options?.altText,
+        snippet_type: options?.snippetType
+      }
+    });
+  }
+  /**
+   * Complete a file upload and optionally share it to a channel.
+   * Step 3 of the file upload flow (step 2 is uploading binary data to the URL from getUploadURL).
+   * @see https://docs.slack.dev/reference/methods/files.completeUploadExternal
+   */
+  async completeUpload(files, channelId, invocationKey, options) {
+    return this.invoke("files.completeUploadExternal", invocationKey, {
+      body: {
+        files,
+        channel_id: channelId,
+        initial_comment: options?.initialComment,
+        thread_ts: options?.threadTs
+      }
+    });
+  }
+};
+
+// src/payload-builders/quickbooks.ts
+function buildQuickBooksInvokePayload(method, path, options) {
+  return {
+    type: "api",
+    subtype: "quickbooks",
+    method,
+    path,
+    query: options?.query,
+    body: options?.body,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+function buildQuickBooksQueryPayload(query, options) {
+  return buildQuickBooksInvokePayload("GET", "/query", {
+    query: { query: [query] },
+    timeoutMs: options?.timeoutMs
+  });
+}
+
+// src/clients/quickbooks.ts
+var QuickBooksResourceClient = class extends BaseResourceClient {
+  /**
+   * Invoke a QuickBooks API request
+   *
+   * @param method - HTTP method (GET, POST, PUT, DELETE)
+   * @param path - QuickBooks API path relative to /v3/company/{realmId}
+   * @param invocationKey - Unique key for this invocation (for tracking)
+   * @param options - Optional query params, body, and timeout
+   * @returns The API response with status and body
+   */
+  async invoke(method, path, invocationKey, options = {}) {
+    const payload = buildQuickBooksInvokePayload(method, path, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Execute a QuickBooks query using SQL-like syntax
+   *
+   * @param query - QuickBooks query string (e.g., "SELECT * FROM Customer WHERE DisplayName LIKE 'A%'")
+   * @param invocationKey - Unique key for this invocation
+   * @param options - Optional timeout
+   * @returns Query results
+   *
+   * @example
+   * ```typescript
+   * const result = await client.query(
+   *   "SELECT * FROM Invoice WHERE TotalAmt > '100.00'",
+   *   "recent-invoices"
+   * );
+   * ```
+   */
+  async query(query, invocationKey, options = {}) {
+    const payload = buildQuickBooksQueryPayload(query, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/auth.ts
+function buildAuthShareAccessPayload(email) {
+  return {
+    type: "auth",
+    subtype: "majorauth",
+    action: "share",
+    email
+  };
+}
+function buildAuthRevokeAccessPayload(email) {
+  return {
+    type: "auth",
+    subtype: "majorauth",
+    action: "revoke",
+    email
+  };
+}
+
+// src/clients/auth.ts
+var MajorAuthResourceClient = class extends BaseResourceClient {
+  /**
+   * Grant a user view access to this application by email.
+   * If the user doesn't have an account, one will be created.
+   * If the user isn't a member of the organization, they will be invited.
+   */
+  async shareAccess(email, invocationKey) {
+    const payload = buildAuthShareAccessPayload(email);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Revoke a user's view access to this application by email.
+   * Only removes app-level access; does not affect org membership or roles.
+   */
+  async revokeAccess(email, invocationKey) {
+    const payload = buildAuthRevokeAccessPayload(email);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/google-analytics.ts
+function buildGoogleAnalyticsRunReportPayload(dimensions, metrics, dateRanges, options) {
+  return {
+    type: "api",
+    subtype: "googleanalytics",
+    operation: "runReport",
+    dimensions,
+    metrics,
+    dateRanges,
+    dimensionFilter: options?.dimensionFilter,
+    metricFilter: options?.metricFilter,
+    orderBys: options?.orderBys,
+    limit: options?.limit,
+    offset: options?.offset
+  };
+}
+function buildGoogleAnalyticsGetMetadataPayload() {
+  return {
+    type: "api",
+    subtype: "googleanalytics",
+    operation: "getMetadata"
+  };
+}
+function buildGoogleAnalyticsRunRealtimeReportPayload(metrics, dimensions, limit) {
+  return {
+    type: "api",
+    subtype: "googleanalytics",
+    operation: "runRealtimeReport",
+    metrics,
+    dimensions,
+    limit
+  };
+}
+function buildGoogleAnalyticsListAccountsPayload(options) {
+  return {
+    type: "api",
+    subtype: "googleanalytics",
+    operation: "listAccounts",
+    pageSize: options?.pageSize,
+    pageToken: options?.pageToken
+  };
+}
+function buildGoogleAnalyticsListPropertiesPayload(accountId, options) {
+  return {
+    type: "api",
+    subtype: "googleanalytics",
+    operation: "listProperties",
+    accountId,
+    pageSize: options?.pageSize,
+    pageToken: options?.pageToken
+  };
+}
+function buildGoogleAnalyticsListDataStreamsPayload(propertyId, options) {
+  return {
+    type: "api",
+    subtype: "googleanalytics",
+    operation: "listDataStreams",
+    propertyId,
+    pageSize: options?.pageSize,
+    pageToken: options?.pageToken
+  };
+}
+function buildGoogleAnalyticsInvokePayload(payload) {
+  return {
+    type: "api",
+    subtype: "googleanalytics",
+    ...payload
+  };
+}
+
+// src/clients/google-analytics.ts
+var GoogleAnalyticsResourceClient = class extends BaseResourceClient {
+  /**
+   * Run a GA4 report with dimensions, metrics, and date ranges
+   * @param dimensions Dimensions to group by (e.g. [{name: 'country'}])
+   * @param metrics Metrics to retrieve (e.g. [{name: 'activeUsers'}])
+   * @param dateRanges Date ranges (e.g. [{startDate: '2024-01-01', endDate: '2024-01-31'}])
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Optional report options (filters, ordering, limit, offset)
+   */
+  async runReport(dimensions, metrics, dateRanges, invocationKey, options) {
+    const payload = buildGoogleAnalyticsRunReportPayload(dimensions, metrics, dateRanges, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Get available dimensions and metrics for the GA4 property
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async getMetadata(invocationKey) {
+    const payload = buildGoogleAnalyticsGetMetadataPayload();
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Run a realtime report showing current live user activity
+   * @param metrics Metrics to retrieve (e.g. [{name: 'activeUsers'}])
+   * @param invocationKey Unique key for tracking this invocation
+   * @param dimensions Optional dimensions to group by
+   * @param limit Optional row limit
+   */
+  async runRealtimeReport(metrics, invocationKey, dimensions, limit) {
+    const payload = buildGoogleAnalyticsRunRealtimeReportPayload(metrics, dimensions, limit);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * List all GA4 accounts accessible to the authenticated user
+   * @param invocationKey Unique key for tracking this invocation
+   * @param options Optional pagination options
+   */
+  async listAccounts(invocationKey, options) {
+    const payload = buildGoogleAnalyticsListAccountsPayload(options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * List GA4 properties, optionally filtered by account
+   * @param invocationKey Unique key for tracking this invocation
+   * @param accountId Optional account filter (e.g. 'accounts/12345')
+   * @param options Optional pagination options
+   */
+  async listProperties(invocationKey, accountId, options) {
+    const payload = buildGoogleAnalyticsListPropertiesPayload(accountId, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * List data streams for a GA4 property
+   * @param invocationKey Unique key for tracking this invocation
+   * @param propertyId Optional property ID (defaults to configured property)
+   * @param options Optional pagination options
+   */
+  async listDataStreams(invocationKey, propertyId, options) {
+    const payload = buildGoogleAnalyticsListDataStreamsPayload(propertyId, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  /**
+   * Execute a raw Google Analytics operation
+   * @param payload The raw operation payload
+   * @param invocationKey Unique key for tracking this invocation
+   */
+  async invoke(payload, invocationKey) {
+    const p = buildGoogleAnalyticsInvokePayload(payload);
+    return this.invokeRaw(p, invocationKey);
+  }
+};
+
+// src/payload-builders/graphql.ts
+function buildGraphQLInvokePayload(query, options) {
+  return {
+    type: "api",
+    subtype: "graphql",
+    query,
+    variables: options?.variables,
+    operationName: options?.operationName,
+    headers: options?.headers,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+
+// src/clients/api-graphql.ts
+var GraphQLResourceClient = class extends BaseResourceClient {
+  async query(query, invocationKey, options = {}) {
+    const payload = buildGraphQLInvokePayload(query, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+  async mutate(mutation, invocationKey, options = {}) {
+    const payload = buildGraphQLInvokePayload(mutation, options);
+    return this.invokeRaw(payload, invocationKey);
+  }
+};
+
+// src/payload-builders/outreach.ts
+function buildOutreachInvokePayload(method, path, options) {
+  return {
+    type: "api",
+    subtype: "outreach",
+    method,
+    path,
+    queryParams: options?.queryParams,
+    body: options?.body,
+    timeoutMs: options?.timeoutMs ?? 3e4
+  };
+}
+
+// src/payload-builders/from-extracted-params.ts
+function isUndefinedParam(param) {
+  return param.known === false && param.expression === "undefined";
+}
+function parseParamValue(value, valueType) {
+  if (valueType === "object" || valueType === "list") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  if (valueType === "number") {
+    const num = Number(value);
+    return isNaN(num) ? value : num;
+  }
+  if (valueType === "boolean") {
+    return value === "true";
+  }
+  return value;
+}
+function findParam(params, name) {
+  const param = params.find((p) => p.name.toLowerCase() === name.toLowerCase());
+  if (!param) return void 0;
+  if (isUndefinedParam(param)) return void 0;
+  return parseParamValue(param.value, param.valueType);
+}
+function buildPayloadFromExtractedParams(subtype, methodName, extractedParams) {
+  switch (subtype) {
+    // =========================================================================
+    // PostgreSQL
+    // =========================================================================
+    case "postgresql": {
+      const sql = findParam(extractedParams, "SQL");
+      const params = findParam(extractedParams, "Params");
+      const timeoutMs = findParam(extractedParams, "Timeout");
+      return buildPostgresInvokePayload(sql, params, timeoutMs);
+    }
+    // =========================================================================
+    // DynamoDB
+    // =========================================================================
+    case "dynamodb": {
+      const command = findParam(extractedParams, "Command");
+      const params = findParam(extractedParams, "Params");
+      return buildDynamoDBInvokePayload(command, params);
+    }
+    // =========================================================================
+    // CosmosDB
+    // =========================================================================
+    case "cosmosdb": {
+      if (methodName === "invoke") {
+        const payload2 = findParam(extractedParams, "Payload");
+        return buildCosmosDBInvokePayload(payload2);
+      }
+      if (methodName === "query") {
+        const container = findParam(extractedParams, "Container");
+        const query = findParam(extractedParams, "Query");
+        const options = findParam(extractedParams, "Options");
+        return buildCosmosDBQueryPayload(container, query, options);
+      }
+      if (methodName === "read") {
+        const container = findParam(extractedParams, "Container");
+        const id = findParam(extractedParams, "Id");
+        const options = findParam(extractedParams, "Options");
+        return buildCosmosDBReadPayload(container, id, options);
+      }
+      if (methodName === "create") {
+        const container = findParam(extractedParams, "Container");
+        const body = findParam(extractedParams, "Body");
+        const options = findParam(extractedParams, "Options");
+        return buildCosmosDBCreatePayload(container, body, options);
+      }
+      if (methodName === "replace") {
+        const container = findParam(extractedParams, "Container");
+        const id = findParam(extractedParams, "Id");
+        const body = findParam(extractedParams, "Body");
+        const options = findParam(extractedParams, "Options");
+        return buildCosmosDBReplacePayload(container, id, body, options);
+      }
+      if (methodName === "upsert") {
+        const container = findParam(extractedParams, "Container");
+        const body = findParam(extractedParams, "Body");
+        const options = findParam(extractedParams, "Options");
+        return buildCosmosDBUpsertPayload(container, body, options);
+      }
+      if (methodName === "delete") {
+        const container = findParam(extractedParams, "Container");
+        const id = findParam(extractedParams, "Id");
+        const options = findParam(extractedParams, "Options");
+        return buildCosmosDBDeletePayload(container, id, options);
+      }
+      if (methodName === "patch") {
+        const container = findParam(extractedParams, "Container");
+        const id = findParam(extractedParams, "Id");
+        const patchOperations = findParam(extractedParams, "PatchOperations");
+        const options = findParam(extractedParams, "Options");
+        return buildCosmosDBPatchPayload(container, id, patchOperations, options);
+      }
+      const payload = findParam(extractedParams, "Payload");
+      return buildCosmosDBInvokePayload(payload);
+    }
+    // =========================================================================
+    // MSSQL
+    // =========================================================================
+    case "mssql": {
+      const sql = findParam(extractedParams, "SQL");
+      const params = findParam(extractedParams, "Params");
+      const timeoutMs = findParam(extractedParams, "Timeout");
+      return buildMssqlInvokePayload(sql, params, timeoutMs);
+    }
+    // =========================================================================
+    // Snowflake
+    // =========================================================================
+    case "snowflake": {
+      if (methodName === "invoke") {
+        const payload2 = findParam(extractedParams, "Payload");
+        return buildSnowflakeInvokePayload(payload2);
+      }
+      if (methodName === "execute") {
+        const statement = findParam(extractedParams, "Statement");
+        const options = findParam(extractedParams, "Options");
+        return buildSnowflakeExecutePayload(statement, options);
+      }
+      if (methodName === "status") {
+        const statementHandle = findParam(extractedParams, "StatementHandle");
+        const options = findParam(extractedParams, "Options");
+        return buildSnowflakeStatusPayload(statementHandle, options);
+      }
+      if (methodName === "cancel") {
+        const statementHandle = findParam(extractedParams, "StatementHandle");
+        return buildSnowflakeCancelPayload(statementHandle);
+      }
+      const payload = findParam(extractedParams, "Payload");
+      return buildSnowflakeInvokePayload(payload);
+    }
+    // =========================================================================
+    // S3
+    // =========================================================================
+    case "s3": {
+      const command = findParam(extractedParams, "Command");
+      const params = findParam(extractedParams, "Params");
+      const options = findParam(extractedParams, "Options");
+      return buildS3InvokePayload(command, params, options);
+    }
+    // =========================================================================
+    // Lambda
+    // =========================================================================
+    case "lambda": {
+      const functionName = findParam(extractedParams, "FunctionName");
+      const payload = findParam(extractedParams, "Payload");
+      const options = findParam(extractedParams, "Options");
+      return buildLambdaInvokePayload(functionName, payload, options);
+    }
+    // =========================================================================
+    // Google Sheets
+    // =========================================================================
+    case "googlesheets": {
+      if (methodName === "getValues") {
+        const range = findParam(extractedParams, "Range");
+        return buildGoogleSheetsGetValuesPayload(range);
+      }
+      if (methodName === "updateValues") {
+        const range = findParam(extractedParams, "Range");
+        const values = findParam(extractedParams, "Values");
+        const valueInputOption = findParam(extractedParams, "ValueInputOption") ?? "USER_ENTERED";
+        return buildGoogleSheetsUpdateValuesPayload(range, values, valueInputOption);
+      }
+      if (methodName === "appendValues") {
+        const range = findParam(extractedParams, "Range");
+        const values = findParam(extractedParams, "Values");
+        const valueInputOption = findParam(extractedParams, "ValueInputOption") ?? "USER_ENTERED";
+        return buildGoogleSheetsAppendValuesPayload(range, values, valueInputOption);
+      }
+      if (methodName === "clearValues") {
+        const range = findParam(extractedParams, "Range");
+        return buildGoogleSheetsClearValuesPayload(range);
+      }
+      if (methodName === "batchGetValues") {
+        const ranges = findParam(extractedParams, "Ranges");
+        return buildGoogleSheetsBatchGetValuesPayload(ranges);
+      }
+      if (methodName === "batchUpdateValues") {
+        const data = findParam(extractedParams, "Data");
+        const valueInputOption = findParam(extractedParams, "ValueInputOption") ?? "USER_ENTERED";
+        return buildGoogleSheetsBatchUpdateValuesPayload(data, valueInputOption);
+      }
+      if (methodName === "getSpreadsheet") {
+        return buildGoogleSheetsGetSpreadsheetPayload();
+      }
+      if (methodName === "batchUpdate") {
+        const requests = findParam(extractedParams, "Requests");
+        return buildGoogleSheetsBatchUpdatePayload(requests);
+      }
+      const method = findParam(extractedParams, "Method");
+      const path = findParam(extractedParams, "Path");
+      const options = findParam(extractedParams, "Options");
+      return buildGoogleSheetsInvokePayload(method, path, options);
+    }
+    // =========================================================================
+    // HubSpot
+    // =========================================================================
+    case "hubspot": {
+      const method = findParam(extractedParams, "Method");
+      const path = findParam(extractedParams, "Path");
+      const options = findParam(extractedParams, "Options");
+      return buildHubSpotInvokePayload(method, path, options);
+    }
+    // =========================================================================
+    // Salesforce
+    // =========================================================================
+    case "salesforce": {
+      if (methodName === "query") {
+        const query = findParam(extractedParams, "Query");
+        return buildSalesforceQueryPayload(query);
+      }
+      if (methodName === "getRecord") {
+        const objectType = findParam(extractedParams, "ObjectType");
+        const recordId = findParam(extractedParams, "RecordId");
+        return buildSalesforceGetRecordPayload(objectType, recordId);
+      }
+      if (methodName === "createRecord") {
+        const objectType = findParam(extractedParams, "ObjectType");
+        const data = findParam(extractedParams, "Data");
+        return buildSalesforceCreateRecordPayload(objectType, data);
+      }
+      if (methodName === "updateRecord") {
+        const objectType = findParam(extractedParams, "ObjectType");
+        const recordId = findParam(extractedParams, "RecordId");
+        const data = findParam(extractedParams, "Data");
+        return buildSalesforceUpdateRecordPayload(objectType, recordId, data);
+      }
+      if (methodName === "deleteRecord") {
+        const objectType = findParam(extractedParams, "ObjectType");
+        const recordId = findParam(extractedParams, "RecordId");
+        return buildSalesforceDeleteRecordPayload(objectType, recordId);
+      }
+      if (methodName === "describeObject") {
+        const objectType = findParam(extractedParams, "ObjectType");
+        return buildSalesforceDescribeObjectPayload(objectType);
+      }
+      const method = findParam(extractedParams, "Method");
+      const path = findParam(extractedParams, "Path");
+      const options = findParam(extractedParams, "Options");
+      return buildSalesforceInvokePayload(method, path, options);
+    }
+    // =========================================================================
+    // Custom API
+    // =========================================================================
+    case "custom": {
+      const method = findParam(extractedParams, "Method");
+      const path = findParam(extractedParams, "Path");
+      const options = findParam(extractedParams, "Options");
+      return buildCustomApiInvokePayload(method, path, options);
+    }
+    // =========================================================================
+    // BigQuery
+    // =========================================================================
+    case "bigquery": {
+      if (methodName === "query") {
+        const sql = findParam(extractedParams, "SQL");
+        const params = findParam(extractedParams, "Params");
+        const options = findParam(extractedParams, "Options");
+        return buildBigQueryQueryPayload(sql, params, options);
+      }
+      if (methodName === "listDatasets") {
+        const options = findParam(extractedParams, "Options");
+        return buildBigQueryListDatasetsPayload(options);
+      }
+      if (methodName === "listTables") {
+        const datasetId = findParam(extractedParams, "DatasetId");
+        const options = findParam(extractedParams, "Options");
+        return buildBigQueryListTablesPayload(datasetId, options);
+      }
+      if (methodName === "getTable") {
+        const datasetId = findParam(extractedParams, "DatasetId");
+        const tableId = findParam(extractedParams, "TableId");
+        return buildBigQueryGetTablePayload(datasetId, tableId);
+      }
+      if (methodName === "insertRows") {
+        const datasetId = findParam(extractedParams, "DatasetId");
+        const tableId = findParam(extractedParams, "TableId");
+        const rows = findParam(extractedParams, "Rows");
+        return buildBigQueryInsertRowsPayload(datasetId, tableId, rows);
+      }
+      if (methodName === "createTable") {
+        const datasetId = findParam(extractedParams, "DatasetId");
+        const tableId = findParam(extractedParams, "TableId");
+        const schema = findParam(extractedParams, "Schema");
+        const options = findParam(extractedParams, "Options");
+        return buildBigQueryCreateTablePayload(datasetId, tableId, schema, options);
+      }
+      const payload = findParam(extractedParams, "Payload");
+      return buildBigQueryInvokePayload(payload);
+    }
+    // =========================================================================
+    // Outreach
+    // =========================================================================
+    case "outreach": {
+      const method = findParam(extractedParams, "Method");
+      const path = findParam(extractedParams, "Path");
+      const options = findParam(extractedParams, "Options");
+      return buildOutreachInvokePayload(method, path, options);
+    }
+    // =========================================================================
+    // Neo4j
+    // =========================================================================
+    case "neo4j": {
+      const cypher = findParam(extractedParams, "Cypher");
+      const params = findParam(extractedParams, "Params");
+      const timeoutMs = findParam(extractedParams, "Timeout");
+      return buildNeo4jInvokePayload(cypher, params, timeoutMs);
+    }
+    // =========================================================================
+    // Slack
+    // =========================================================================
+    case "slack": {
+      if (methodName === "getUploadURL") {
+        const filename = findParam(extractedParams, "Filename");
+        const length = findParam(extractedParams, "Length");
+        const options2 = findParam(extractedParams, "Options");
+        return buildSlackGetUploadURLPayload(filename, length, options2);
+      }
+      if (methodName === "completeUpload") {
+        const files = findParam(extractedParams, "Files");
+        const channelId = findParam(extractedParams, "ChannelId");
+        const options2 = findParam(extractedParams, "Options");
+        return buildSlackCompleteUploadPayload(files, channelId, options2);
+      }
+      const method = findParam(extractedParams, "Method");
+      const options = findParam(extractedParams, "Options");
+      return buildSlackInvokePayload(method, options);
+    }
+    // =========================================================================
+    // QuickBooks
+    // =========================================================================
+    case "quickbooks": {
+      if (methodName === "query") {
+        const query = findParam(extractedParams, "Query");
+        return buildQuickBooksQueryPayload(query);
+      }
+      const method = findParam(extractedParams, "Method");
+      const path = findParam(extractedParams, "Path");
+      const options = findParam(extractedParams, "Options");
+      return buildQuickBooksInvokePayload(method, path, options);
+    }
+    // =========================================================================
+    // Major Auth
+    // =========================================================================
+    case "majorauth": {
+      const email = findParam(extractedParams, "Email");
+      if (methodName === "revokeAccess") {
+        return buildAuthRevokeAccessPayload(email);
+      }
+      return buildAuthShareAccessPayload(email);
+    }
+    // =========================================================================
+    // Google Analytics
+    // =========================================================================
+    case "googleanalytics": {
+      if (methodName === "runReport") {
+        const dimensions = findParam(extractedParams, "Dimensions");
+        const metrics = findParam(extractedParams, "Metrics");
+        const dateRanges = findParam(extractedParams, "DateRanges");
+        const options = findParam(extractedParams, "Options");
+        return buildGoogleAnalyticsRunReportPayload(
+          dimensions ?? [],
+          metrics ?? [],
+          dateRanges ?? [],
+          options
+        );
+      }
+      if (methodName === "getMetadata") {
+        return buildGoogleAnalyticsGetMetadataPayload();
+      }
+      if (methodName === "listAccounts") {
+        const options = findParam(extractedParams, "Options");
+        return buildGoogleAnalyticsListAccountsPayload(options);
+      }
+      if (methodName === "listProperties") {
+        const accountId = findParam(extractedParams, "AccountId");
+        const options = findParam(extractedParams, "Options");
+        return buildGoogleAnalyticsListPropertiesPayload(accountId, options);
+      }
+      const payload = findParam(extractedParams, "Payload");
+      return buildGoogleAnalyticsInvokePayload(payload);
+    }
+    // =========================================================================
+    // GraphQL
+    // =========================================================================
+    case "graphql": {
+      const query = findParam(extractedParams, "Query");
+      const options = findParam(extractedParams, "Options");
+      return buildGraphQLInvokePayload(query, options);
+    }
+    default:
+      throw new Error(`Unsupported resource subtype: ${subtype}`);
+  }
+}
 //# sourceMappingURL=index.cjs.map