@tangle-network/agent-integrations 0.53.22 → 0.53.23

package/dist/{chunk-GODEAAAZ.js → chunk-X3WHOEX7.js}

@@ -74,6 +74,7 @@ __export(adapters_exports, {
   auth0Connector: () => auth0Connector,
   autoboundConnector: () => autoboundConnector,
   autocallsConnector: () => autocallsConnector,
+  avalaraConnector: () => avalaraConnector,
   avianConnector: () => avianConnector,
   avomaConnector: () => avomaConnector,
   azureAdConnector: () => azureAdConnector,
@@ -146,6 +147,7 @@ __export(adapters_exports, {
   clicdataConnector: () => clicdataConnector,
   clickfunnelsConnector: () => clickfunnelsConnector,
   clickupConnector: () => clickupConnector,
+  clientCredentialsRestConnector: () => clientCredentialsRestConnector,
   clioConnector: () => clioConnector,
   clockifyConnector: () => clockifyConnector,
   clockodoConnector: () => clockodoConnector,
@@ -419,6 +421,7 @@ __export(adapters_exports, {
   mollieConnector: () => mollieConnector,
   mondayConnector: () => mondayConnector,
   mongodbConnector: () => mongodbConnector,
+  mycaseConnector: () => mycaseConnector,
   n8nConnector: () => n8nConnector,
   netlifyConnector: () => netlifyConnector,
   netsuiteConnector: () => netsuiteConnector,
@@ -436,6 +439,7 @@ __export(adapters_exports, {
   omnihrConnector: () => omnihrConnector,
   oneDrive: () => oneDrive,
   oneSpanSignConnector: () => oneSpanSignConnector,
+  oneloginConnector: () => oneloginConnector,
   openPhoneConnector: () => openPhoneConnector,
   openRouterConnector: () => openRouterConnector,
   openaiConnector: () => openaiConnector,
@@ -463,6 +467,7 @@ __export(adapters_exports, {
   phonyConnector: () => phonyConnector,
   pinchPaymentsConnector: () => pinchPaymentsConnector,
   pineconeConnector: () => pineconeConnector,
+  pingIdentityConnector: () => pingIdentityConnector,
   pipedreamConnector: () => pipedreamConnector,
   pipedriveConnector: () => pipedriveConnector,
   placidConnector: () => placidConnector,
@@ -490,6 +495,7 @@ __export(adapters_exports, {
   rapidtextAiConnector: () => rapidtextAiConnector,
   reachinboxConnector: () => reachinboxConnector,
   recallAiConnector: () => recallAiConnector,
+  recurlyConnector: () => recurlyConnector,
   redditConnector: () => redditConnector,
   reoonVerifierConnector: () => reoonVerifierConnector,
   replyIoConnector: () => replyIoConnector,
@@ -510,6 +516,7 @@ __export(adapters_exports, {
   sanityConnector: () => sanityConnector,
   sardisConnector: () => sardisConnector,
   savvycalConnector: () => savvycalConnector,
+  scimConnector: () => scimConnector,
   scrapegraphaiConnector: () => scrapegraphaiConnector,
   scrapelessConnector: () => scrapelessConnector,
   seamlessAiConnector: () => seamlessAiConnector,
@@ -557,6 +564,7 @@ __export(adapters_exports, {
   talkableConnector: () => talkableConnector,
   tallyConnector: () => tallyConnector,
   tangleIdentity: () => tangleIdentity,
+  taxjarConnector: () => taxjarConnector,
   teableConnector: () => teableConnector,
   telegramConnector: () => telegramConnector,
   telnyxConnector: () => telnyxConnector,
@@ -770,11 +778,11 @@ function declarativeRestConnector(spec) {
       const op = readOperation(spec, inv.capabilityName, "read");
       const response = await executeRestRequest(spec, op.request, inv, requiredArgsOf(op.parameters));
       if (response.outcome === "rate-limited") {
-        const retryAfterMs3 = response.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS;
+        const retryAfterMs4 = response.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS;
         throw new ProviderRateLimited(
-          `${spec.displayName} ${inv.capabilityName} rate limit (429); retry after ${retryAfterMs3}ms`,
+          `${spec.displayName} ${inv.capabilityName} rate limit (429); retry after ${retryAfterMs4}ms`,
           inv.source.id,
-          { status: 429, body: response.data, retryAfterMs: retryAfterMs3 }
+          { status: 429, body: response.data, retryAfterMs: retryAfterMs4 }
         );
       }
       if (response.outcome === "conflict") {
@@ -919,7 +927,10 @@ async function executeRestRequest(spec, request4, inv, requiredArgs) {
     ...renderHeaders(spec.defaultHeaders ?? {}, scope, true),
     ...renderHeaders(renderableHeaders, scope)
   };
-  const structuredCredentials = placement.kind === "structured-headers" || placement.kind === "structured-json-body" ? readStructuredCredentials(inv.source.credentials, placement.fields) : void 0;
+  const structuredCredentials = placement.kind === "structured-headers" || placement.kind === "structured-json-body" ? readStructuredCredentials(inv.source.credentials, placement.fields) : placement.kind === "basic-structured" ? readStructuredCredentials(inv.source.credentials, {
+    [placement.usernameField]: placement.usernameField,
+    [placement.passwordField]: placement.passwordField
+  }) : void 0;
   if (placement.kind === "structured-headers") {
     for (const [credentialName, headerName] of Object.entries(placement.fields)) {
       headers[headerName] = structuredCredentials[credentialName];
@@ -955,6 +966,10 @@ async function executeRestRequest(spec, request4, inv, requiredArgs) {
       region: awsRegion,
       bundle: aws
     });
+  } else if (placement.kind === "basic-structured") {
+    const username = structuredCredentials[placement.usernameField];
+    const password = structuredCredentials[placement.passwordField];
+    headers.authorization = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
   } else if (placement.kind !== "structured-headers" && placement.kind !== "structured-json-body") {
     applyCredentials(headers, url, placement, inv.source.credentials);
   }
@@ -968,7 +983,11 @@ async function executeRestRequest(spec, request4, inv, requiredArgs) {
     throw new CredentialsExpired(`${spec.displayName} rejected credentials (${res.status})`, inv.source.id);
   }
   if (res.status === 409 || res.status === 412) {
-    const text2 = redactCredentialText(await safeErrorText(res), inv.source.credentials);
+    const text2 = redactCredentialText(
+      await safeErrorText(res),
+      inv.source.credentials,
+      [getHeaderCI(headers, "authorization")]
+    );
     return {
       data: parseBodyText(text2),
       outcome: "conflict",
@@ -978,7 +997,11 @@ async function executeRestRequest(spec, request4, inv, requiredArgs) {
     };
   }
   if (res.status === 429) {
-    const text2 = redactCredentialText(await safeErrorText(res), inv.source.credentials);
+    const text2 = redactCredentialText(
+      await safeErrorText(res),
+      inv.source.credentials,
+      [getHeaderCI(headers, "authorization")]
+    );
     return {
       data: parseBodyText(text2),
       outcome: "rate-limited",
@@ -991,7 +1014,11 @@ async function executeRestRequest(spec, request4, inv, requiredArgs) {
     return { data: { exists: res.status === 204 } };
   }
   if (!res.ok) {
-    const text2 = redactCredentialText(await safeErrorText(res), inv.source.credentials);
+    const text2 = redactCredentialText(
+      await safeErrorText(res),
+      inv.source.credentials,
+      [getHeaderCI(headers, "authorization")]
+    );
     throw new Error(`${spec.kind} ${request4.method} ${url.pathname} HTTP ${res.status}: ${text2.slice(0, 300)}`);
   }
   const text = await res.text();
@@ -1080,7 +1107,9 @@ function applyCredentials(headers, url, placement, credentials) {
   if (placement.kind === "basic-api-key") {
     headers.authorization = `Basic ${Buffer.from(`${token}:`).toString("base64")}`;
   }
-  if (placement.kind === "header") headers[placement.header] = `${placement.prefix ?? ""}${token}`;
+  if (placement.kind === "header") {
+    headers[placement.header] = `${placement.prefix ?? ""}${token}${placement.suffix ?? ""}`;
+  }
   if (placement.kind === "query") url.searchParams.set(placement.parameter, token);
 }
 function readStructuredCredentials(credentials, fields) {
@@ -1121,9 +1150,9 @@ function credentialToken(credentials) {
   }
   throw new Error(`declarative REST connectors require oauth2 or api-key credentials, got ${credentials.kind}`);
 }
-function redactCredentialText(text, credentials) {
+function redactCredentialText(text, credentials, additionalSecrets = []) {
   const candidates = credentials.kind === "oauth2" ? [credentials.accessToken, credentials.refreshToken] : credentials.kind === "api-key" ? [credentials.apiKey, ...jsonStringValues(credentials.apiKey)] : credentials.kind === "custom" ? Object.values(credentials.values) : [];
-  const secrets = candidates.filter(
+  const secrets = [...candidates, ...additionalSecrets].filter(
     (secret) => typeof secret === "string" && secret.length > 0
   );
   return secrets.reduce(
@@ -1537,6 +1566,803 @@ function membershipCapability(name, method, description) {
   };
 }
 
+// src/connectors/adapters/client-credentials-rest.ts
+import { createHash as createHash2 } from "crypto";
+function clientCredentialsRestConnector(spec) {
+  const regionMetadataKey = spec.regionMetadataKey ?? "region";
+  const delegated = declarativeRestConnector({
+    ...spec,
+    baseUrl: { metadataKey: "__clientCredentialsApiBaseUrl" },
+    allowedBaseUrls: Object.values(spec.regions).map((region) => region.apiBaseUrl),
+    credentialPlacement: spec.apiCredentialPlacement ?? { kind: "bearer" }
+  });
+  const tokens = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  async function authenticatedSource(source) {
+    const bundle = readCredentialBundle(source.credentials);
+    const regionName = readRegionName(bundle, source.metadata, regionMetadataKey, spec.defaultRegion);
+    const region = spec.regions[regionName];
+    if (!region) {
+      throw new Error(`${spec.kind}: unsupported region ${regionName}; expected one of ${Object.keys(spec.regions).join(", ")}`);
+    }
+    const resolvedRegion = {
+      ...region,
+      tokenUrl: renderConnectionMetadata(region.tokenUrl, source.metadata)
+    };
+    const scope = bundle.scope ?? spec.defaultScope;
+    const fingerprint = credentialFingerprint(bundle, resolvedRegion, scope);
+    const cached = tokens.get(source.id);
+    if (cached?.fingerprint === fingerprint && cached.expiresAt > Date.now() + 6e4) {
+      return withAccessToken(source, resolvedRegion.apiBaseUrl, cached.accessToken);
+    }
+    if (cached) tokens.delete(source.id);
+    const inFlight = pending.get(source.id);
+    if (inFlight?.fingerprint === fingerprint) {
+      const token = await inFlight.promise;
+      return withAccessToken(source, resolvedRegion.apiBaseUrl, token.accessToken);
+    }
+    const promise = exchangeClientCredentials(
+      spec.displayName,
+      source.id,
+      bundle,
+      resolvedRegion,
+      fingerprint,
+      scope,
+      spec.tokenCredentialPlacement ?? "basic"
+    );
+    pending.set(source.id, { fingerprint, promise });
+    try {
+      const token = await promise;
+      if (pending.get(source.id)?.promise === promise) cacheToken(tokens, source.id, token);
+      return withAccessToken(source, resolvedRegion.apiBaseUrl, token.accessToken);
+    } finally {
+      if (pending.get(source.id)?.promise === promise) pending.delete(source.id);
+    }
+  }
+  return {
+    manifest: delegated.manifest,
+    executeRead: delegated.executeRead ? async (invocation) => delegated.executeRead({
+      ...invocation,
+      source: await authenticatedSource(invocation.source)
+    }) : void 0,
+    executeMutation: delegated.executeMutation ? async (invocation) => delegated.executeMutation({
+      ...invocation,
+      source: await authenticatedSource(invocation.source)
+    }) : void 0,
+    async test(source) {
+      try {
+        return delegated.test(await authenticatedSource(source));
+      } catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : "unknown error" };
+      }
+    }
+  };
+}
+function cacheToken(tokens, sourceId, token) {
+  tokens.set(sourceId, token);
+  const timeout = setTimeout(() => {
+    if (tokens.get(sourceId) === token) tokens.delete(sourceId);
+  }, Math.max(0, token.expiresAt - Date.now()));
+  timeout.unref();
+}
+function readCredentialBundle(credentials) {
+  let values;
+  if (credentials.kind === "custom") {
+    values = credentials.values;
+  } else if (credentials.kind === "api-key") {
+    try {
+      const parsed = JSON.parse(credentials.apiKey);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("not an object");
+      values = parsed;
+    } catch {
+      throw new Error("client credentials require a JSON object in the API-key field");
+    }
+  } else {
+    throw new Error(`client credentials require custom or API-key credentials, got ${credentials.kind}`);
+  }
+  const clientId = requiredString(values.clientId, "clientId");
+  const clientSecret = requiredString(values.clientSecret, "clientSecret");
+  return {
+    clientId,
+    clientSecret,
+    region: optionalString(values.region, "region"),
+    scope: optionalString(values.scope, "scope")
+  };
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`client credentials are missing ${field}`);
+  return value.trim();
+}
+function optionalString(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new Error(`client credentials ${field} must be a string`);
+  return value.trim();
+}
+function readRegionName(bundle, metadata, metadataKey, fallback) {
+  const metadataRegion = metadata[metadataKey];
+  if (metadataRegion !== void 0 && typeof metadataRegion !== "string") {
+    throw new Error(`connection metadata.${metadataKey} must be a string`);
+  }
+  return (bundle.region ?? metadataRegion ?? fallback).toLowerCase().trim();
+}
+function credentialFingerprint(bundle, region, scope) {
+  return createHash2("sha256").update(bundle.clientId).update("\0").update(bundle.clientSecret).update("\0").update(region.tokenUrl).update("\0").update(scope ?? "").digest("hex");
+}
+function renderConnectionMetadata(template, metadata) {
+  const rendered = template.replace(/\{connection\.([a-zA-Z0-9_.-]+)\}/g, (_match, key) => {
+    const value = key.split(".").reduce((current, part) => {
+      if (current && typeof current === "object" && part in current) {
+        return current[part];
+      }
+      return void 0;
+    }, metadata);
+    if (typeof value !== "string" || !value.trim()) throw new Error(`missing metadata.${key}`);
+    return encodeURIComponent(value.trim());
+  });
+  const url = new URL(rendered);
+  if (url.protocol !== "https:" || url.username || url.password) {
+    throw new Error("client-credentials token URL must be HTTPS without embedded credentials");
+  }
+  return url.href;
+}
+async function exchangeClientCredentials(displayName, sourceId, bundle, region, fingerprint, scope, credentialPlacement = "basic") {
+  const body = new URLSearchParams({ grant_type: "client_credentials" });
+  if (scope) body.set("scope", scope);
+  if (credentialPlacement === "form-body") {
+    body.set("client_id", bundle.clientId);
+    body.set("client_secret", bundle.clientSecret);
+  }
+  const headers = {
+    accept: "application/json",
+    "content-type": "application/x-www-form-urlencoded"
+  };
+  if (credentialPlacement === "basic") {
+    headers.authorization = `Basic ${Buffer.from(`${bundle.clientId}:${bundle.clientSecret}`).toString("base64")}`;
+  }
+  const response = await fetch(region.tokenUrl, {
+    method: "POST",
+    headers,
+    body: body.toString(),
+    signal: AbortSignal.timeout(2e4)
+  });
+  if (response.status === 429) {
+    throw new ProviderRateLimited(`${displayName} token endpoint rate limit (429)`, sourceId, {
+      status: 429,
+      retryAfterMs: retryAfterMs(response.headers.get("retry-after"))
+    });
+  }
+  if (response.status === 400 || response.status === 401 || response.status === 403) {
+    throw new CredentialsExpired(`${displayName} rejected client credentials (${response.status})`, sourceId, {
+      status: response.status
+    });
+  }
+  if (!response.ok) throw new Error(`${displayName} token exchange failed (${response.status})`);
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error(`${displayName} token exchange returned malformed JSON`);
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(`${displayName} token exchange returned an invalid response`);
+  }
+  const values = payload;
+  const accessToken3 = requiredString(values.access_token, "access_token");
+  const expiresIn = Number(values.expires_in ?? 3600);
+  if (!Number.isFinite(expiresIn) || expiresIn <= 0) {
+    throw new Error(`${displayName} token exchange returned an invalid expires_in`);
+  }
+  return {
+    fingerprint,
+    accessToken: accessToken3,
+    expiresAt: Date.now() + Math.round(expiresIn * 1e3)
+  };
+}
+function withAccessToken(source, apiBaseUrl, accessToken3) {
+  return {
+    ...source,
+    metadata: { ...source.metadata, __clientCredentialsApiBaseUrl: apiBaseUrl },
+    credentials: { kind: "oauth2", accessToken: accessToken3 }
+  };
+}
+function retryAfterMs(raw) {
+  if (!raw) return 6e4;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.max(1e3, Math.round(seconds * 1e3));
+  const at = Date.parse(raw);
+  return Number.isFinite(at) ? Math.max(1e3, at - Date.now()) : 6e4;
+}
+
+// src/connectors/adapters/onelogin.ts
+var userId2 = { type: "string", description: "OneLogin user id." };
+var groupId2 = { type: "string", description: "OneLogin group id." };
+var oneloginRestConnector = clientCredentialsRestConnector({
+  kind: "onelogin",
+  displayName: "OneLogin",
+  description: "Provision OneLogin users, groups, and user group assignments with customer-owned API credentials.",
+  auth: {
+    kind: "api-key",
+    hint: 'JSON credential bundle: {"clientId":"...","clientSecret":"...","region":"us|eu"}.'
+  },
+  category: "other",
+  defaultConsistencyModel: "authoritative",
+  regions: {
+    us: {
+      apiBaseUrl: "https://api.us.onelogin.com",
+      tokenUrl: "https://api.us.onelogin.com/auth/oauth2/v2/token"
+    },
+    eu: {
+      apiBaseUrl: "https://api.eu.onelogin.com",
+      tokenUrl: "https://api.eu.onelogin.com/auth/oauth2/v2/token"
+    }
+  },
+  defaultRegion: "us",
+  tokenCredentialPlacement: "form-body",
+  apiCredentialPlacement: { kind: "header", header: "Authorization", prefix: "bearer:" },
+  defaultHeaders: { Accept: "application/json" },
+  test: { method: "GET", path: "/api/2/users", query: { limit: 1 } },
+  capabilities: [
+    {
+      name: "users.list",
+      class: "read",
+      description: "List or filter OneLogin users.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "integer", minimum: 1, maximum: 1e3 },
+          page: { type: "integer", minimum: 1 },
+          email: { type: "string" },
+          username: { type: "string" },
+          status: { type: "integer" },
+          group_id: { type: "integer" },
+          role_id: { type: "integer" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/api/2/users",
+        query: {
+          limit: "{limit}",
+          page: "{page}",
+          email: "{email}",
+          username: "{username}",
+          status: "{status}",
+          group_id: "{group_id}",
+          role_id: "{role_id}"
+        }
+      }
+    },
+    {
+      name: "users.get",
+      class: "read",
+      description: "Read one OneLogin user.",
+      parameters: { type: "object", properties: { userId: userId2 }, required: ["userId"] },
+      request: { method: "GET", path: "/api/2/users/{userId}" }
+    },
+    {
+      name: "users.create",
+      class: "mutation",
+      description: "Create a OneLogin user from a provider-native user object.",
+      parameters: { type: "object", properties: { user: { type: "object" } }, required: ["user"] },
+      request: { method: "POST", path: "/api/2/users", body: "{user}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "users.update",
+      class: "mutation",
+      description: "Update mutable fields on a OneLogin user.",
+      parameters: {
+        type: "object",
+        properties: { userId: userId2, user: { type: "object" } },
+        required: ["userId", "user"]
+      },
+      request: { method: "PUT", path: "/api/2/users/{userId}", body: "{user}" },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    },
+    {
+      name: "users.deactivate",
+      class: "mutation",
+      description: "Set a OneLogin user to suspended status without deleting the record.",
+      parameters: { type: "object", properties: { userId: userId2 }, required: ["userId"] },
+      request: { method: "PUT", path: "/api/2/users/{userId}", body: { status: 2 } },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    },
+    {
+      name: "groups.list",
+      class: "read",
+      description: "List OneLogin groups.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "integer", minimum: 1, maximum: 1e3 },
+          page: { type: "integer", minimum: 1 },
+          name: { type: "string" }
+        }
+      },
+      request: { method: "GET", path: "/api/1/groups", query: { limit: "{limit}", page: "{page}", name: "{name}" } }
+    },
+    {
+      name: "groups.get",
+      class: "read",
+      description: "Read one OneLogin group.",
+      parameters: { type: "object", properties: { groupId: groupId2 }, required: ["groupId"] },
+      request: { method: "GET", path: "/api/1/groups/{groupId}" }
+    },
+    {
+      name: "groups.users.add",
+      class: "mutation",
+      description: "Assign a OneLogin user to a group. OneLogin permits one group per user.",
+      parameters: {
+        type: "object",
+        properties: { groupId: groupId2, userId: userId2 },
+        required: ["groupId", "userId"]
+      },
+      request: { method: "PUT", path: "/api/2/users/{userId}", body: { group_id: "{groupId}" } },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    },
+    {
+      name: "groups.users.remove",
+      class: "mutation",
+      description: "Remove a OneLogin user from the expected current group.",
+      parameters: {
+        type: "object",
+        properties: { groupId: groupId2, userId: userId2 },
+        required: ["groupId", "userId"]
+      },
+      request: { method: "PUT", path: "/api/2/users/{userId}", body: { group_id: null } },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    }
+  ]
+});
+var oneloginConnector = {
+  ...oneloginRestConnector,
+  async executeMutation(invocation) {
+    if (invocation.capabilityName !== "groups.users.remove") {
+      return oneloginRestConnector.executeMutation(invocation);
+    }
+    const current = await oneloginRestConnector.executeRead({
+      ...invocation,
+      capabilityName: "users.get",
+      args: { userId: invocation.args.userId }
+    });
+    const currentGroup = readGroupId(current.data);
+    const expectedGroup = String(invocation.args.groupId);
+    if (currentGroup !== expectedGroup) {
+      return {
+        status: "conflict",
+        alternatives: [],
+        currentState: current.data,
+        message: `OneLogin user is assigned to group ${currentGroup ?? "none"}, not ${expectedGroup}`
+      };
+    }
+    return oneloginRestConnector.executeMutation(invocation);
+  }
+};
+function readGroupId(data4) {
+  if (!data4 || typeof data4 !== "object" || Array.isArray(data4)) return void 0;
+  const value = data4.group_id;
+  return typeof value === "string" || typeof value === "number" ? String(value) : void 0;
+}
+
+// src/connectors/adapters/ping-identity.ts
+var userId3 = { type: "string", description: "PingOne user id." };
+var groupId3 = { type: "string", description: "PingOne group id." };
+var regions = {
+  us: { apiBaseUrl: "https://api.pingone.com", tokenUrl: "https://auth.pingone.com/{connection.environmentId}/as/token" },
+  ca: { apiBaseUrl: "https://api.pingone.ca", tokenUrl: "https://auth.pingone.ca/{connection.environmentId}/as/token" },
+  eu: { apiBaseUrl: "https://api.pingone.eu", tokenUrl: "https://auth.pingone.eu/{connection.environmentId}/as/token" },
+  au: { apiBaseUrl: "https://api.pingone.com.au", tokenUrl: "https://auth.pingone.com.au/{connection.environmentId}/as/token" },
+  asia: { apiBaseUrl: "https://api.pingone.asia", tokenUrl: "https://auth.pingone.asia/{connection.environmentId}/as/token" }
+};
+var pingIdentityConnector = clientCredentialsRestConnector({
+  kind: "ping-identity",
+  displayName: "Ping Identity",
+  description: "Provision PingOne users, groups, and group memberships with customer-owned worker credentials.",
+  auth: {
+    kind: "api-key",
+    hint: 'JSON credential bundle: {"clientId":"...","clientSecret":"...","region":"us|ca|eu|au|asia"}. Set environmentId in connection metadata.'
+  },
+  category: "other",
+  defaultConsistencyModel: "authoritative",
+  regions,
+  defaultRegion: "us",
+  defaultHeaders: { Accept: "application/json" },
+  test: {
+    method: "GET",
+    path: "/v1/environments/{connection.environmentId}/users",
+    query: { limit: 1 }
+  },
+  capabilities: [
+    {
+      name: "users.list",
+      class: "read",
+      description: "List or filter users in the connected PingOne environment.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "integer", minimum: 1, maximum: 200 },
+          filter: { type: "string" },
+          order: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/v1/environments/{connection.environmentId}/users",
+        query: { limit: "{limit}", filter: "{filter}", order: "{order}" }
+      }
+    },
+    {
+      name: "users.get",
+      class: "read",
+      description: "Read one PingOne user.",
+      parameters: { type: "object", properties: { userId: userId3 }, required: ["userId"] },
+      request: { method: "GET", path: "/v1/environments/{connection.environmentId}/users/{userId}" }
+    },
+    {
+      name: "users.create",
+      class: "mutation",
+      description: "Create a PingOne user from a provider-native user object.",
+      parameters: {
+        type: "object",
+        properties: { user: { type: "object" } },
+        required: ["user"]
+      },
+      request: { method: "POST", path: "/v1/environments/{connection.environmentId}/users", body: "{user}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "users.update",
+      class: "mutation",
+      description: "Patch mutable fields on a PingOne user.",
+      parameters: {
+        type: "object",
+        properties: { userId: userId3, user: { type: "object" } },
+        required: ["userId", "user"]
+      },
+      request: { method: "PATCH", path: "/v1/environments/{connection.environmentId}/users/{userId}", body: "{user}" },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    },
+    {
+      name: "users.deactivate",
+      class: "mutation",
+      description: "Disable a PingOne user without deleting the record.",
+      parameters: { type: "object", properties: { userId: userId3 }, required: ["userId"] },
+      request: {
+        method: "PATCH",
+        path: "/v1/environments/{connection.environmentId}/users/{userId}",
+        body: { enabled: false }
+      },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    },
+    {
+      name: "groups.list",
+      class: "read",
+      description: "List or filter groups in the PingOne environment.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "integer", minimum: 1, maximum: 200 },
+          filter: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/v1/environments/{connection.environmentId}/groups",
+        query: { limit: "{limit}", filter: "{filter}" }
+      }
+    },
+    {
+      name: "groups.get",
+      class: "read",
+      description: "Read one PingOne group.",
+      parameters: { type: "object", properties: { groupId: groupId3 }, required: ["groupId"] },
+      request: { method: "GET", path: "/v1/environments/{connection.environmentId}/groups/{groupId}" }
+    },
+    {
+      name: "groups.create",
+      class: "mutation",
+      description: "Create a PingOne group from a provider-native group object.",
+      parameters: { type: "object", properties: { group: { type: "object" } }, required: ["group"] },
+      request: { method: "POST", path: "/v1/environments/{connection.environmentId}/groups", body: "{group}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "groups.update",
+      class: "mutation",
+      description: "Patch mutable fields on a PingOne group.",
+      parameters: {
+        type: "object",
+        properties: { groupId: groupId3, group: { type: "object" } },
+        required: ["groupId", "group"]
+      },
+      request: { method: "PUT", path: "/v1/environments/{connection.environmentId}/groups/{groupId}", body: "{group}" },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    },
+    {
+      name: "groups.users.add",
+      class: "mutation",
+      description: "Add a PingOne user to a group.",
+      parameters: {
+        type: "object",
+        properties: { groupId: groupId3, userId: userId3 },
+        required: ["groupId", "userId"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/environments/{connection.environmentId}/users/{userId}/memberOfGroups",
+        body: { id: "{groupId}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "groups.users.remove",
+      class: "mutation",
+      description: "Remove a PingOne user from a group.",
+      parameters: {
+        type: "object",
+        properties: { groupId: groupId3, userId: userId3 },
+        required: ["groupId", "userId"]
+      },
+      request: {
+        method: "DELETE",
+        path: "/v1/environments/{connection.environmentId}/users/{userId}/memberOfGroups/{groupId}"
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/scim.ts
+var userId4 = { type: "string", description: "SCIM user resource id." };
+var groupId4 = { type: "string", description: "SCIM group resource id." };
+var patchSchema = "urn:ietf:params:scim:api:messages:2.0:PatchOp";
+var scimRestConnector = declarativeRestConnector({
+  kind: "scim",
+  displayName: "SCIM",
+  description: "Provision users, groups, and group memberships against any public SCIM 2.0 service provider.",
+  auth: {
+    kind: "api-key",
+    hint: "SCIM bearer token. Set baseUrl to the provider SCIM 2.0 root, for example https://tenant.example.com/scim/v2."
+  },
+  category: "other",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: { metadataKey: "baseUrl" },
+  requirePublicHttpsBaseUrl: true,
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: {
+    Accept: "application/scim+json, application/json",
+    "Content-Type": "application/scim+json"
+  },
+  test: { method: "GET", path: "/ServiceProviderConfig" },
+  capabilities: [
+    {
+      name: "users.list",
+      class: "read",
+      description: "List or filter SCIM users with standard pagination and attribute selection.",
+      parameters: {
+        type: "object",
+        properties: {
+          filter: { type: "string" },
+          startIndex: { type: "integer", minimum: 1 },
+          count: { type: "integer", minimum: 1, maximum: 1e3 },
+          attributes: { type: "string" },
+          excludedAttributes: { type: "string" },
+          sortBy: { type: "string" },
+          sortOrder: { type: "string", enum: ["ascending", "descending"] }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/Users",
+        query: {
+          filter: "{filter}",
+          startIndex: "{startIndex}",
+          count: "{count}",
+          attributes: "{attributes}",
+          excludedAttributes: "{excludedAttributes}",
+          sortBy: "{sortBy}",
+          sortOrder: "{sortOrder}"
+        }
+      }
+    },
+    {
+      name: "users.get",
+      class: "read",
+      description: "Read one SCIM user.",
+      parameters: { type: "object", properties: { userId: userId4 }, required: ["userId"] },
+      request: { method: "GET", path: "/Users/{userId}" }
+    },
+    {
+      name: "users.create",
+      class: "mutation",
+      description: "Create a SCIM user from a complete provider-compatible resource.",
+      parameters: { type: "object", properties: { user: { type: "object" } }, required: ["user"] },
+      request: { method: "POST", path: "/Users", body: "{user}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "users.replace",
+      class: "mutation",
+      description: "Replace a SCIM user resource.",
+      parameters: {
+        type: "object",
+        properties: { userId: userId4, user: { type: "object" } },
+        required: ["userId", "user"]
+      },
+      request: { method: "PUT", path: "/Users/{userId}", body: "{user}" },
+      cas: "etag-if-match",
+      externalEffect: true
+    },
+    {
+      name: "users.update",
+      class: "mutation",
+      description: "Apply SCIM PatchOp operations to a user.",
+      parameters: {
+        type: "object",
+        properties: { userId: userId4, operations: { type: "array", items: { type: "object" } } },
+        required: ["userId", "operations"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/Users/{userId}",
+        body: { schemas: [patchSchema], Operations: "{operations}" }
+      },
+      cas: "etag-if-match",
+      externalEffect: true
+    },
+    {
+      name: "users.deactivate",
+      class: "mutation",
+      description: "Deactivate a SCIM user by setting active=false.",
+      parameters: { type: "object", properties: { userId: userId4 }, required: ["userId"] },
+      request: {
+        method: "PATCH",
+        path: "/Users/{userId}",
+        body: { schemas: [patchSchema], Operations: [{ op: "replace", path: "active", value: false }] }
+      },
+      cas: "etag-if-match",
+      externalEffect: true
+    },
+    {
+      name: "groups.list",
+      class: "read",
+      description: "List or filter SCIM groups.",
+      parameters: {
+        type: "object",
+        properties: {
+          filter: { type: "string" },
+          startIndex: { type: "integer", minimum: 1 },
+          count: { type: "integer", minimum: 1, maximum: 1e3 },
+          attributes: { type: "string" },
+          excludedAttributes: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/Groups",
+        query: {
+          filter: "{filter}",
+          startIndex: "{startIndex}",
+          count: "{count}",
+          attributes: "{attributes}",
+          excludedAttributes: "{excludedAttributes}"
+        }
+      }
+    },
+    {
+      name: "groups.get",
+      class: "read",
+      description: "Read one SCIM group.",
+      parameters: { type: "object", properties: { groupId: groupId4 }, required: ["groupId"] },
+      request: { method: "GET", path: "/Groups/{groupId}" }
+    },
+    {
+      name: "groups.create",
+      class: "mutation",
+      description: "Create a SCIM group from a complete provider-compatible resource.",
+      parameters: { type: "object", properties: { group: { type: "object" } }, required: ["group"] },
+      request: { method: "POST", path: "/Groups", body: "{group}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "groups.update",
+      class: "mutation",
+      description: "Apply SCIM PatchOp operations to a group.",
+      parameters: {
+        type: "object",
+        properties: { groupId: groupId4, operations: { type: "array", items: { type: "object" } } },
+        required: ["groupId", "operations"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/Groups/{groupId}",
+        body: { schemas: [patchSchema], Operations: "{operations}" }
+      },
+      cas: "etag-if-match",
+      externalEffect: true
+    },
+    {
+      name: "groups.users.add",
+      class: "mutation",
+      description: "Add a user reference to a SCIM group.",
+      parameters: {
+        type: "object",
+        properties: { groupId: groupId4, userId: userId4 },
+        required: ["groupId", "userId"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/Groups/{groupId}",
+        body: {
+          schemas: [patchSchema],
+          Operations: [{ op: "add", path: "members", value: [{ value: "{userId}" }] }]
+        }
+      },
+      cas: "etag-if-match",
+      externalEffect: true
+    },
+    {
+      name: "groups.users.remove",
+      class: "mutation",
+      description: "Remove a user reference from a SCIM group.",
+      parameters: {
+        type: "object",
+        properties: {
+          groupId: groupId4,
+          userId: userId4
+        },
+        required: ["groupId", "userId"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/Groups/{groupId}",
+        body: { schemas: [patchSchema], Operations: ["{operation}"] }
+      },
+      cas: "etag-if-match",
+      externalEffect: true
+    }
+  ]
+});
+var scimConnector = {
+  ...scimRestConnector,
+  async executeMutation(invocation) {
+    if (invocation.capabilityName !== "groups.users.remove") {
+      return scimRestConnector.executeMutation(invocation);
+    }
+    const userIdValue = invocation.args.userId;
+    if (typeof userIdValue !== "string" || !userIdValue.trim()) {
+      throw new Error("missing required argument: userId");
+    }
+    return scimRestConnector.executeMutation({
+      ...invocation,
+      args: {
+        ...invocation.args,
+        operation: {
+          op: "remove",
+          path: `members[value eq "${escapeScimFilterValue(userIdValue)}"]`
+        }
+      }
+    });
+  }
+};
+function escapeScimFilterValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
 // src/connectors/adapters/actualbudget.ts
 var actualbudgetConnector = declarativeRestConnector({
   kind: "actualbudget",
@@ -6899,7 +7725,7 @@ var modelslabConnector = {
     if (inv.capabilityName !== "text.to.image") {
       throw new Error(`modelslab: unknown mutation capability ${inv.capabilityName}`);
     }
-    const prompt = requiredString(inv.args, "prompt");
+    const prompt = requiredString2(inv.args, "prompt");
     const data4 = await request(inv.source, `${baseUrl}/text2img`, {
       ...pick(inv.args, [
         "negative_prompt",
@@ -6925,7 +7751,7 @@ var modelslabConnector = {
     if (inv.capabilityName !== "images.status") {
       throw new Error(`modelslab: unknown read capability ${inv.capabilityName}`);
     }
-    const requestId = encodeURIComponent(requiredString(inv.args, "requestId"));
+    const requestId = encodeURIComponent(requiredString2(inv.args, "requestId"));
     const data4 = await request(inv.source, `${baseUrl}/fetch/${requestId}`, {});
     return { data: data4, fetchedAt: Date.now() };
   },
@@ -6954,7 +7780,7 @@ async function request(source, url, body) {
     throw new ProviderRateLimited("ModelsLab rate limit (429)", source.id, {
       status: 429,
       body: responseBody,
-      retryAfterMs: retryAfterMs(response.headers.get("retry-after"))
+      retryAfterMs: retryAfterMs2(response.headers.get("retry-after"))
     });
   }
   if (!response.ok) throw new Error(`modelslab POST ${new URL(url).pathname} HTTP ${response.status}`);
@@ -6967,7 +7793,7 @@ function credential(source) {
   }
   return source.credentials.apiKey;
 }
-function requiredString(args, key) {
+function requiredString2(args, key) {
   const value = args[key];
   if (typeof value !== "string" || !value) throw new Error(`modelslab: ${key} is required`);
   return value;
@@ -6987,7 +7813,7 @@ async function readBody(response) {
 function isErrorResponse(value) {
   return Boolean(value && typeof value === "object" && value.status === "error");
 }
-function retryAfterMs(value) {
+function retryAfterMs2(value) {
   if (!value) return 6e4;
   const seconds = Number(value);
   return Number.isFinite(seconds) && seconds >= 0 ? Math.max(1e3, seconds * 1e3) : 6e4;
@@ -7701,12 +8527,12 @@ function collectionRead(name, description, path, entity) {
     }
   };
 }
-function entityRead(name, description, path, id) {
+function entityRead(name, description, path, id2) {
   return {
     name,
     class: "read",
     description,
-    parameters: idParameters(id),
+    parameters: idParameters(id2),
     request: { method: "GET", path }
   };
 }
@@ -7721,15 +8547,15 @@ function entityCreate(name, description, path) {
     externalEffect: true
   };
 }
-function entityUpdate(name, description, path, id) {
+function entityUpdate(name, description, path, id2) {
   return {
     name,
     class: "mutation",
     description,
     parameters: {
       type: "object",
-      properties: { [id]: { type: "integer" } },
-      required: [id],
+      properties: { [id2]: { type: "integer" } },
+      required: [id2],
       additionalProperties: true
     },
     request: { method: "PUT", path, body: "args" },
@@ -7737,22 +8563,22 @@ function entityUpdate(name, description, path, id) {
     externalEffect: true
   };
 }
-function entityDelete(name, description, path, id) {
+function entityDelete(name, description, path, id2) {
   return {
     name,
     class: "mutation",
     description,
-    parameters: idParameters(id),
+    parameters: idParameters(id2),
     request: { method: "DELETE", path },
     cas: "native-idempotency",
     externalEffect: true
   };
 }
-function idParameters(id) {
+function idParameters(id2) {
   return {
     type: "object",
-    properties: { [id]: { type: "integer" } },
-    required: [id]
+    properties: { [id2]: { type: "integer" } },
+    required: [id2]
   };
 }
 function arbitraryBodyParameters() {
@@ -9635,6 +10461,192 @@ var avomaConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/avalara.ts
+var companyCode = { type: "string", description: "Avalara company code." };
+var transactionCode = { type: "string", description: "Merchant transaction code." };
+var model = {
+  type: "object",
+  description: "Provider-native AvaTax v2 request model."
+};
+var avalaraConnector = declarativeRestConnector({
+  kind: "avalara",
+  displayName: "Avalara AvaTax",
+  description: "Calculate tax and manage AvaTax transaction documents, adjustments, commits, voids, and refunds.",
+  auth: {
+    kind: "api-key",
+    hint: 'JSON credential bundle: {"accountId":"...","licenseKey":"..."}. Use apiBaseUrl metadata for the sandbox host when needed.'
+  },
+  category: "commerce",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: { metadataKey: "apiBaseUrl", fallback: "https://rest.avatax.com" },
+  allowedBaseUrls: ["https://rest.avatax.com", "https://sandbox-rest.avatax.com"],
+  credentialPlacement: {
+    kind: "basic-structured",
+    usernameField: "accountId",
+    passwordField: "licenseKey"
+  },
+  test: { method: "GET", path: "/api/v2/utilities/ping" },
+  capabilities: [
+    {
+      name: "rates.by-address",
+      class: "read",
+      description: "Estimate the total tax rate for one postal address.",
+      parameters: {
+        type: "object",
+        properties: {
+          line1: { type: "string" },
+          city: { type: "string" },
+          region: { type: "string" },
+          postalCode: { type: "string" },
+          country: { type: "string" }
+        },
+        required: ["postalCode", "country"]
+      },
+      request: {
+        method: "GET",
+        path: "/api/v2/taxrates/byaddress",
+        query: {
+          line1: "{line1}",
+          city: "{city}",
+          region: "{region}",
+          postalCode: "{postalCode}",
+          country: "{country}"
+        }
+      }
+    },
+    {
+      name: "definitions.tax-codes.list",
+      class: "read",
+      description: "List Avalara system tax codes for product classification.",
+      parameters: {
+        type: "object",
+        properties: {
+          top: { type: "integer", minimum: 1, maximum: 1e3 },
+          skip: { type: "integer", minimum: 0 },
+          filter: { type: "string" },
+          orderBy: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/api/v2/definitions/taxcodes",
+        query: { "$top": "{top}", "$skip": "{skip}", "$filter": "{filter}", "$orderby": "{orderBy}" }
+      }
+    },
+    {
+      name: "transactions.create",
+      class: "mutation",
+      description: "Create an AvaTax transaction document and calculate its tax.",
+      parameters: {
+        type: "object",
+        properties: { model },
+        required: ["model"]
+      },
+      request: { method: "POST", path: "/api/v2/transactions/create", body: "{model}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "transactions.create-or-adjust",
+      class: "mutation",
+      description: "Create a transaction or adjust the existing transaction with the same company/code/type.",
+      parameters: {
+        type: "object",
+        properties: { model },
+        required: ["model"]
+      },
+      request: { method: "POST", path: "/api/v2/transactions/createoradjust", body: "{model}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    transactionRead("transactions.get", "", "Read one AvaTax transaction and its summary."),
+    {
+      name: "transactions.audit",
+      class: "read",
+      description: "Read the audit trail for one AvaTax transaction.",
+      parameters: {
+        type: "object",
+        properties: { companyCode, transactionCode },
+        required: ["companyCode", "transactionCode"]
+      },
+      request: {
+        method: "GET",
+        path: "/api/v2/companies/{companyCode}/transactions/{transactionCode}/audit"
+      }
+    },
+    transactionAction("transactions.commit", "/commit", "Commit a transaction for reporting and filing."),
+    transactionAction("transactions.void", "/void", "Void a transaction with an explicit AvaTax void reason."),
+    transactionAction("transactions.refund", "/refund", "Create a full or partial refund transaction."),
+    transactionAction("transactions.lock", "/lock", "Lock a transaction against further edits."),
+    {
+      name: "companies.list",
+      class: "read",
+      description: "List AvaTax companies accessible to the account.",
+      parameters: {
+        type: "object",
+        properties: {
+          top: { type: "integer", minimum: 1, maximum: 1e3 },
+          skip: { type: "integer", minimum: 0 },
+          filter: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/api/v2/companies",
+        query: { "$top": "{top}", "$skip": "{skip}", "$filter": "{filter}" }
+      }
+    }
+  ]
+});
+function transactionRead(name, suffix, description) {
+  return {
+    name,
+    class: "read",
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        companyCode,
+        transactionCode,
+        documentType: { type: "string" },
+        include: { type: "string", description: "Related response objects to include." }
+      },
+      required: ["companyCode", "transactionCode"]
+    },
+    request: {
+      method: "GET",
+      path: `/api/v2/companies/{companyCode}/transactions/{transactionCode}${suffix}`,
+      query: { documentType: "{documentType}", "$include": "{include}" }
+    }
+  };
+}
+function transactionAction(name, suffix, description) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        companyCode,
+        transactionCode,
+        documentType: { type: "string" },
+        include: { type: "string", description: "Related response objects to include." },
+        model
+      },
+      required: ["companyCode", "transactionCode", "model"]
+    },
+    request: {
+      method: "POST",
+      path: `/api/v2/companies/{companyCode}/transactions/{transactionCode}${suffix}`,
+      query: { documentType: "{documentType}", "$include": "{include}" },
+      body: "{model}"
+    },
+    cas: "native-idempotency",
+    externalEffect: true
+  };
+}
+
 // src/connectors/adapters/azure-ad.ts
 var azureAdConnector = declarativeRestConnector({
   kind: "azure-ad",
@@ -15310,6 +16322,494 @@ var chargebeeConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/recurly.ts
+var id = (description) => ({ type: "string", description });
+var pageQuery = {
+  limit: { type: "integer", minimum: 1, maximum: 200 },
+  cursor: { type: "string" },
+  sort: { type: "string", enum: ["asc", "desc"] },
+  begin_time: { type: "string", description: "ISO 8601 lower timestamp bound." },
+  end_time: { type: "string", description: "ISO 8601 upper timestamp bound." }
+};
+var recurlyConnector = declarativeRestConnector({
+  kind: "recurly",
+  displayName: "Recurly",
+  description: "Manage Recurly billing accounts, plans, subscriptions, invoices, and subscription lifecycle state.",
+  auth: {
+    kind: "api-key",
+    hint: "Recurly private API key from Developer Settings. Sent as the HTTP Basic username with an empty password."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://v3.recurly.com",
+  credentialPlacement: { kind: "basic-api-key" },
+  defaultHeaders: {
+    accept: "application/vnd.recurly.v2021-02-25",
+    "content-type": "application/json"
+  },
+  test: { method: "GET", path: "/sites", query: { limit: 1 } },
+  capabilities: [
+    {
+      name: "sites.list",
+      class: "read",
+      description: "List sites accessible to the supplied Recurly private API key.",
+      parameters: { type: "object", properties: { limit: pageQuery.limit } },
+      request: { method: "GET", path: "/sites", query: { limit: "{limit}" } }
+    },
+    {
+      name: "accounts.list",
+      class: "read",
+      description: "List billing accounts with optional lifecycle and time filters.",
+      parameters: {
+        type: "object",
+        properties: {
+          ...pageQuery,
+          state: { type: "string", enum: ["active", "closed", "any"] },
+          email: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/accounts",
+        query: {
+          limit: "{limit}",
+          cursor: "{cursor}",
+          sort: "{sort}",
+          begin_time: "{begin_time}",
+          end_time: "{end_time}",
+          state: "{state}",
+          email: "{email}"
+        }
+      }
+    },
+    {
+      name: "accounts.get",
+      class: "read",
+      description: "Read one billing account by UUID or code-prefixed identifier.",
+      parameters: {
+        type: "object",
+        properties: { accountId: id("Account UUID or `code-<account code>`.") },
+        required: ["accountId"]
+      },
+      request: { method: "GET", path: "/accounts/{accountId}" }
+    },
+    {
+      name: "accounts.create",
+      class: "mutation",
+      description: "Create a billing account.",
+      parameters: {
+        type: "object",
+        properties: {
+          code: { type: "string" },
+          email: { type: "string" },
+          first_name: { type: "string" },
+          last_name: { type: "string" },
+          company: { type: "string" },
+          preferred_locale: { type: "string" },
+          preferred_time_zone: { type: "string" },
+          address: { type: "object" },
+          custom_fields: { type: "array", items: { type: "object" } }
+        },
+        required: ["code", "email"]
+      },
+      request: { method: "POST", path: "/accounts", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "accounts.update",
+      class: "mutation",
+      description: "Update profile, address, locale, or custom fields on a billing account.",
+      parameters: {
+        type: "object",
+        properties: {
+          accountId: id("Account UUID or `code-<account code>`."),
+          email: { type: "string" },
+          first_name: { type: "string" },
+          last_name: { type: "string" },
+          company: { type: "string" },
+          preferred_locale: { type: "string" },
+          preferred_time_zone: { type: "string" },
+          address: { type: "object" },
+          custom_fields: { type: "array", items: { type: "object" } }
+        },
+        required: ["accountId"]
+      },
+      request: { method: "PUT", path: "/accounts/{accountId}", body: "args" },
+      cas: "optimistic-read-verify",
+      externalEffect: true
+    },
+    {
+      name: "plans.list",
+      class: "read",
+      description: "List subscription plans.",
+      parameters: {
+        type: "object",
+        properties: { ...pageQuery, state: { type: "string", enum: ["active", "inactive"] } }
+      },
+      request: {
+        method: "GET",
+        path: "/plans",
+        query: {
+          limit: "{limit}",
+          cursor: "{cursor}",
+          sort: "{sort}",
+          begin_time: "{begin_time}",
+          end_time: "{end_time}",
+          state: "{state}"
+        }
+      }
+    },
+    {
+      name: "subscriptions.list",
+      class: "read",
+      description: "List subscriptions across the site.",
+      parameters: {
+        type: "object",
+        properties: {
+          ...pageQuery,
+          state: { type: "string", enum: ["active", "canceled", "expired", "failed", "future", "paused"] }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/subscriptions",
+        query: {
+          limit: "{limit}",
+          cursor: "{cursor}",
+          sort: "{sort}",
+          begin_time: "{begin_time}",
+          end_time: "{end_time}",
+          state: "{state}"
+        }
+      }
+    },
+    {
+      name: "accounts.subscriptions.list",
+      class: "read",
+      description: "List subscriptions belonging to one billing account.",
+      parameters: {
+        type: "object",
+        properties: {
+          ...pageQuery,
+          accountId: id("Account UUID or `code-<account code>`."),
+          state: { type: "string", enum: ["active", "canceled", "expired", "failed", "future", "paused"] }
+        },
+        required: ["accountId"]
+      },
+      request: {
+        method: "GET",
+        path: "/accounts/{accountId}/subscriptions",
+        query: {
+          limit: "{limit}",
+          cursor: "{cursor}",
+          sort: "{sort}",
+          begin_time: "{begin_time}",
+          end_time: "{end_time}",
+          state: "{state}"
+        }
+      }
+    },
+    {
+      name: "subscriptions.get",
+      class: "read",
+      description: "Read one subscription by UUID.",
+      parameters: {
+        type: "object",
+        properties: { subscriptionId: id("Subscription UUID.") },
+        required: ["subscriptionId"]
+      },
+      request: { method: "GET", path: "/subscriptions/{subscriptionId}" }
+    },
+    {
+      name: "subscriptions.create",
+      class: "mutation",
+      description: "Start a subscription for an existing or inline billing account.",
+      parameters: {
+        type: "object",
+        properties: {
+          plan_code: { type: "string" },
+          currency: { type: "string", minLength: 3, maxLength: 3 },
+          account: { type: "object", description: "Existing account reference or inline account object." },
+          quantity: { type: "integer", minimum: 1 },
+          starts_at: { type: "string" },
+          trial_ends_at: { type: "string" },
+          collection_method: { type: "string", enum: ["automatic", "manual"] },
+          net_terms: { type: "integer", minimum: 0 },
+          custom_fields: { type: "array", items: { type: "object" } }
+        },
+        required: ["plan_code", "currency", "account"]
+      },
+      request: { method: "POST", path: "/subscriptions", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "subscriptions.cancel",
+      class: "mutation",
+      description: "Schedule a subscription to cancel at its renewal date.",
+      parameters: {
+        type: "object",
+        properties: { subscriptionId: id("Subscription UUID.") },
+        required: ["subscriptionId"]
+      },
+      request: { method: "POST", path: "/subscriptions/{subscriptionId}/cancel", body: {} },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "subscriptions.reactivate",
+      class: "mutation",
+      description: "Reactivate a subscription that is pending cancellation.",
+      parameters: {
+        type: "object",
+        properties: { subscriptionId: id("Subscription UUID.") },
+        required: ["subscriptionId"]
+      },
+      request: { method: "POST", path: "/subscriptions/{subscriptionId}/reactivate", body: {} },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "subscriptions.terminate",
+      class: "mutation",
+      description: "Immediately terminate a subscription, with an explicit refund policy.",
+      parameters: {
+        type: "object",
+        properties: {
+          subscriptionId: id("Subscription UUID."),
+          refund: { type: "string", enum: ["none", "partial", "full"] }
+        },
+        required: ["subscriptionId", "refund"]
+      },
+      request: {
+        method: "POST",
+        path: "/subscriptions/{subscriptionId}/terminate",
+        query: { refund: "{refund}" },
+        body: {}
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "invoices.list",
+      class: "read",
+      description: "List invoices with account, state, type, and time filters.",
+      parameters: {
+        type: "object",
+        properties: {
+          ...pageQuery,
+          accountId: id("Optional account UUID or `code-<account code>`."),
+          state: { type: "string", enum: ["pending", "processing", "past_due", "paid", "failed", "voided"] },
+          type: { type: "string", enum: ["charge", "credit", "non-legacy"] }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/invoices",
+        query: {
+          limit: "{limit}",
+          cursor: "{cursor}",
+          sort: "{sort}",
+          begin_time: "{begin_time}",
+          end_time: "{end_time}",
+          account_id: "{accountId}",
+          state: "{state}",
+          type: "{type}"
+        }
+      }
+    },
+    {
+      name: "invoices.get",
+      class: "read",
+      description: "Read one invoice by UUID or number-prefixed identifier.",
+      parameters: {
+        type: "object",
+        properties: { invoiceId: id("Invoice UUID or `number-<invoice number>`.") },
+        required: ["invoiceId"]
+      },
+      request: { method: "GET", path: "/invoices/{invoiceId}" }
+    },
+    {
+      name: "accounts.invoices.list",
+      class: "read",
+      description: "List invoices belonging to one billing account.",
+      parameters: {
+        type: "object",
+        properties: {
+          ...pageQuery,
+          accountId: id("Account UUID or `code-<account code>`."),
+          state: { type: "string", enum: ["pending", "processing", "past_due", "paid", "failed", "voided"] },
+          type: { type: "string", enum: ["charge", "credit", "non-legacy"] }
+        },
+        required: ["accountId"]
+      },
+      request: {
+        method: "GET",
+        path: "/accounts/{accountId}/invoices",
+        query: {
+          limit: "{limit}",
+          cursor: "{cursor}",
+          sort: "{sort}",
+          begin_time: "{begin_time}",
+          end_time: "{end_time}",
+          state: "{state}",
+          type: "{type}"
+        }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/taxjar.ts
+var transactionId = { type: "string", description: "Merchant transaction id." };
+var provider = {
+  type: "string",
+  enum: ["api", "stripe", "square"],
+  description: "Transaction source. Defaults to api."
+};
+var taxjarConnector = declarativeRestConnector({
+  kind: "taxjar",
+  displayName: "TaxJar",
+  description: "Calculate sales tax and synchronize order/refund transactions with TaxJar for reporting and filing.",
+  auth: {
+    kind: "api-key",
+    hint: "TaxJar SmartCalcs API token from Account \u2192 TaxJar API."
+  },
+  category: "commerce",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.taxjar.com/v2",
+  credentialPlacement: {
+    kind: "header",
+    header: "Authorization",
+    prefix: 'Token token="',
+    suffix: '"'
+  },
+  test: { method: "GET", path: "/categories" },
+  capabilities: [
+    {
+      name: "taxes.calculate",
+      class: "read",
+      description: "Calculate sales tax for a cart or order without creating a TaxJar transaction.",
+      parameters: {
+        type: "object",
+        properties: {
+          from_country: { type: "string" },
+          from_zip: { type: "string" },
+          from_state: { type: "string" },
+          from_city: { type: "string" },
+          from_street: { type: "string" },
+          to_country: { type: "string" },
+          to_zip: { type: "string" },
+          to_state: { type: "string" },
+          to_city: { type: "string" },
+          to_street: { type: "string" },
+          amount: { type: "number" },
+          shipping: { type: "number" },
+          customer_id: { type: "string" },
+          exemption_type: { type: "string" },
+          nexus_addresses: { type: "array", items: { type: "object" } },
+          line_items: { type: "array", items: { type: "object" } }
+        },
+        required: ["from_country", "from_zip", "to_country", "to_zip", "amount", "shipping"]
+      },
+      request: { method: "POST", path: "/taxes", body: "args" }
+    },
+    {
+      name: "rates.get",
+      class: "read",
+      description: "Read the combined sales-tax rate for a US or Canadian postal code.",
+      parameters: {
+        type: "object",
+        properties: {
+          zip: { type: "string" },
+          country: { type: "string" },
+          state: { type: "string" },
+          city: { type: "string" },
+          street: { type: "string" }
+        },
+        required: ["zip"]
+      },
+      request: {
+        method: "GET",
+        path: "/rates/{zip}",
+        query: { country: "{country}", state: "{state}", city: "{city}", street: "{street}" }
+      }
+    },
+    {
+      name: "categories.list",
+      class: "read",
+      description: "List TaxJar product tax categories and their tax codes.",
+      parameters: { type: "object", properties: {} },
+      request: { method: "GET", path: "/categories" }
+    },
+    {
+      name: "nexus-regions.list",
+      class: "read",
+      description: "List nexus regions configured for the TaxJar account.",
+      parameters: { type: "object", properties: {} },
+      request: { method: "GET", path: "/nexus/regions" }
+    },
+    transactionRead2("orders.get", "/transactions/orders/{transactionId}", "Read a synced order transaction."),
+    transactionWrite("orders.create", "POST", "/transactions/orders", "Create an order transaction for reporting and filing."),
+    transactionWrite("orders.update", "PUT", "/transactions/orders/{transactionId}", "Update an order transaction."),
+    transactionDelete("orders.delete", "/transactions/orders/{transactionId}", "Delete an order transaction."),
+    transactionRead2("refunds.get", "/transactions/refunds/{transactionId}", "Read a synced refund transaction."),
+    transactionWrite("refunds.create", "POST", "/transactions/refunds", "Create a refund transaction for reporting and filing."),
+    transactionWrite("refunds.update", "PUT", "/transactions/refunds/{transactionId}", "Update a refund transaction."),
+    transactionDelete("refunds.delete", "/transactions/refunds/{transactionId}", "Delete a refund transaction.")
+  ]
+});
+function transactionRead2(name, path, description) {
+  return {
+    name,
+    class: "read",
+    description,
+    parameters: {
+      type: "object",
+      properties: { transactionId, provider },
+      required: ["transactionId"]
+    },
+    request: { method: "GET", path, query: { provider: "{provider}" } }
+  };
+}
+function transactionWrite(name, method, path, description) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        transactionId,
+        data: {
+          type: "object",
+          description: "Provider-native TaxJar order/refund payload, including transaction_id and transaction_date."
+        }
+      },
+      required: method === "POST" ? ["data"] : ["transactionId", "data"]
+    },
+    request: { method, path, body: "{data}" },
+    cas: "native-idempotency",
+    externalEffect: true
+  };
+}
+function transactionDelete(name, path, description) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: {
+      type: "object",
+      properties: { transactionId, provider },
+      required: ["transactionId"]
+    },
+    request: { method: "DELETE", path, query: { provider: "{provider}" } },
+    cas: "native-idempotency",
+    externalEffect: true
+  };
+}
+
 // src/connectors/adapters/cashfree-payments.ts
 var cashfreePaymentsConnector = declarativeRestConnector({
   kind: "cashfree-payments",
@@ -19726,7 +21226,7 @@ var frontConnector = declarativeRestConnector({
 });
 
 // src/connectors/oauth.ts
-import { createHash as createHash2, randomBytes } from "crypto";
+import { createHash as createHash3, randomBytes } from "crypto";
 var PENDING_TTL_MS = 10 * 60 * 1e3;
 var InMemoryOAuthFlowStore = class {
   pendingFlows = /* @__PURE__ */ new Map();
@@ -19754,7 +21254,7 @@ function startOAuthFlow(input) {
   const now = input.now ?? Date.now();
   store.sweep?.(now);
   const codeVerifier = base64Url(randomBytes(48));
-  const codeChallenge = base64Url(createHash2("sha256").update(codeVerifier).digest());
+  const codeChallenge = base64Url(createHash3("sha256").update(codeVerifier).digest());
   const state = base64Url(randomBytes(24));
   store.put(state, {
     codeVerifier,
@@ -19939,20 +21439,20 @@ async function googleApiError(res, context, dataSourceId) {
   const body = await readErrorBody(res);
   return classifyGoogleError(res.status, body, context, dataSourceId);
 }
-function googleTestFailureReason(status, body, provider) {
+function googleTestFailureReason(status, body, provider2) {
   const reason = googleErrorReason(body);
   const cls = classifyGoogleReason(reason);
   const detail = reason ? `, ${reason}` : "";
   if (cls === "quota" || status === 429) {
-    return `${provider} rate limit (${status}${detail}) \u2014 retry later`;
+    return `${provider2} rate limit (${status}${detail}) \u2014 retry later`;
   }
   if (cls === "auth" || status === 401) {
-    return `${provider} rejected token (${status}${detail}) \u2014 reconnect required`;
+    return `${provider2} rejected token (${status}${detail}) \u2014 reconnect required`;
   }
   if (cls === "config" || status === 403) {
-    return `${provider} permission/config error (${status}${detail}) \u2014 check the API is enabled and scopes are granted`;
+    return `${provider2} permission/config error (${status}${detail}) \u2014 check the API is enabled and scopes are granted`;
   }
-  return `${provider} returned ${status}`;
+  return `${provider2} returned ${status}`;
 }
 async function readErrorBody(res) {
   const text = await res.text().catch(() => "");
@@ -20163,7 +21663,7 @@ async function listMessages(inv, accessToken3, timeoutMs) {
   const params = new URLSearchParams({
     maxResults: String(args.maxResults ?? 25)
   });
-  for (const id of args.labelIds ?? ["INBOX"]) params.append("labelIds", id);
+  for (const id2 of args.labelIds ?? ["INBOX"]) params.append("labelIds", id2);
   if (args.query) params.set("q", args.query);
   if (args.pageToken) params.set("pageToken", args.pageToken);
   const listRes = await fetch(`${API}/messages?${params.toString()}`, {
@@ -20176,8 +21676,8 @@ async function listMessages(inv, accessToken3, timeoutMs) {
   const listJson = await listRes.json();
   const ids = listJson.messages ?? [];
   const metas = await Promise.all(
-    ids.map(async ({ id }) => {
-      const res = await fetch(`${API}/messages/${encodeURIComponent(id)}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`, {
+    ids.map(async ({ id: id2 }) => {
+      const res = await fetch(`${API}/messages/${encodeURIComponent(id2)}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`, {
         headers: { authorization: `Bearer ${accessToken3}` },
         signal: AbortSignal.timeout(timeoutMs)
       });
@@ -20206,13 +21706,13 @@ function toMessageSummary(meta) {
   };
 }
 async function readMessage(inv, accessToken3, timeoutMs) {
-  const { id } = inv.args;
-  const res = await fetch(`${API}/messages/${encodeURIComponent(id)}?format=full`, {
+  const { id: id2 } = inv.args;
+  const res = await fetch(`${API}/messages/${encodeURIComponent(id2)}?format=full`, {
     headers: { authorization: `Bearer ${accessToken3}` },
     signal: AbortSignal.timeout(timeoutMs)
   });
   if (res.status === 404) {
-    throw new Error(`gmail read_message: message ${id} not found`);
+    throw new Error(`gmail read_message: message ${id2} not found`);
   }
   if (!res.ok) {
     throw await googleApiError(res, "gmail read_message", inv.source.id);
@@ -23444,7 +24944,7 @@ async function ensureFreshAccessToken5(creds, clientId, clientSecret) {
 }
 
 // src/connectors/adapters/google-sheets.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var SCOPES5 = ["https://www.googleapis.com/auth/spreadsheets"];
 var AUTH_URL6 = "https://accounts.google.com/o/oauth2/v2/auth";
 var TOKEN_URL6 = "https://oauth2.googleapis.com/token";
@@ -23717,7 +25217,7 @@ async function fetchAllRows(accessToken3, meta) {
 function rowFingerprint(values) {
   const keys = Object.keys(values).sort();
   const blob = keys.map((k) => `${k}=${values[k]}`).join("
");
-  return createHash3("sha256").update(blob).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(blob).digest("hex").slice(0, 16);
 }
 function matchesPredicate(row, predicate) {
   for (const [k, v] of Object.entries(predicate)) {
@@ -25628,8 +27128,8 @@ async function createDeal(inv, accessToken3, timeoutMs) {
   const payload = { properties: dealProperties };
   const contactIds = args.associations?.contactIds ?? [];
   if (contactIds.length > 0) {
-    payload.associations = contactIds.map((id) => ({
-      to: { id },
+    payload.associations = contactIds.map((id2) => ({
+      to: { id: id2 },
       // 3 = deal→contact association type id (standard HubSpot mapping)
       types: [{ associationCategory: "HUBSPOT_DEFINED", associationTypeId: 3 }]
     }));
@@ -31844,9 +33344,9 @@ function microsoftGraph(opts) {
         return { data: { groups }, fetchedAt: Date.now() };
       }
       if (inv.capabilityName === "list_group_members") {
-        const { groupId: groupId2, top } = inv.args;
+        const { groupId: groupId5, top } = inv.args;
         const t = Math.min(Math.max(1, top ?? 50), 100);
-        const url = `${GRAPH}/groups/${encodeURIComponent(groupId2)}/members?$select=id,displayName,mail,userPrincipalName&$top=${t}`;
+        const url = `${GRAPH}/groups/${encodeURIComponent(groupId5)}/members?$select=id,displayName,mail,userPrincipalName&$top=${t}`;
         const json = await graphGet(url, accessToken3, inv.source.id);
         const members = (json.value ?? []).map((m) => ({
           // odata.type is '#microsoft.graph.user' | '#microsoft.graph.group'
@@ -34034,6 +35534,200 @@ var mondayConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/mycase.ts
+var pageProperties = {
+  page: { type: "integer", minimum: 1 },
+  page_size: { type: "integer", minimum: 1, maximum: 100 },
+  updated_after: { type: "string", description: "ISO 8601 lower timestamp bound for incremental synchronization." }
+};
+var resourceId = { type: "string", description: "MyCase resource id." };
+var dataObject = {
+  type: "object",
+  description: "Provider-native MyCase JSON payload for this resource."
+};
+function list(name, path, description, extra = {}) {
+  const query2 = Object.fromEntries(
+    Object.keys({ ...pageProperties, ...extra }).map((key) => [key, `{${key}}`])
+  );
+  return {
+    name,
+    class: "read",
+    description,
+    parameters: { type: "object", properties: { ...pageProperties, ...extra } },
+    request: { method: "GET", path, query: query2 }
+  };
+}
+function create(name, path, description) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: {
+      type: "object",
+      properties: { data: dataObject },
+      required: ["data"]
+    },
+    request: { method: "POST", path, body: "{data}" },
+    cas: "native-idempotency",
+    externalEffect: true
+  };
+}
+function update(name, path, description) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: {
+      type: "object",
+      properties: { id: resourceId, data: dataObject },
+      required: ["id", "data"]
+    },
+    request: { method: "PUT", path: `${path}/{id}`, body: "{data}" },
+    cas: "optimistic-read-verify",
+    externalEffect: true
+  };
+}
+var mycaseConnector = declarativeRestConnector({
+  kind: "mycase",
+  displayName: "MyCase",
+  description: "Manage legal cases, clients, companies, leads, matters, activities, time, expenses, and notes in MyCase.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://auth.mycase.com/login_sessions/new",
+    tokenUrl: "https://auth.mycase.com/tokens",
+    scopes: [],
+    sendScopeParam: false,
+    clientIdEnv: "MYCASE_OAUTH_CLIENT_ID",
+    clientSecretEnv: "MYCASE_OAUTH_CLIENT_SECRET"
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://external-integrations.mycase.com/v1",
+  credentialPlacement: { kind: "bearer" },
+  test: { method: "GET", path: "/staff", query: { page_size: 1 } },
+  capabilities: [
+    list("cases.list", "/cases", "List or incrementally synchronize legal cases.", {
+      name: { type: "string" },
+      case_number: { type: "string" },
+      case_stage_id: { type: "string" },
+      practice_area_id: { type: "string" },
+      status: { type: "string" }
+    }),
+    create("cases.create", "/cases", "Create a legal case."),
+    update("cases.update", "/cases", "Update a legal case."),
+    list("clients.list", "/clients", "List or incrementally synchronize clients.", {
+      first_name: { type: "string" },
+      last_name: { type: "string" },
+      email: { type: "string" }
+    }),
+    create("clients.create", "/clients", "Create a person/client record."),
+    update("clients.update", "/clients", "Update a person/client record."),
+    list("companies.list", "/companies", "List or incrementally synchronize companies.", {
+      name: { type: "string" },
+      email: { type: "string" }
+    }),
+    create("companies.create", "/companies", "Create a company record."),
+    update("companies.update", "/companies", "Update a company record."),
+    list("leads.list", "/leads", "List or incrementally synchronize leads.", {
+      first_name: { type: "string" },
+      last_name: { type: "string" },
+      email: { type: "string" },
+      status: { type: "string" }
+    }),
+    create("leads.create", "/leads", "Create a lead."),
+    list("staff.list", "/staff", "List firm staff who can own or participate in work.", {
+      first_name: { type: "string" },
+      last_name: { type: "string" },
+      email: { type: "string" }
+    }),
+    list("case-stages.list", "/case_stages", "List case stages."),
+    create("case-stages.create", "/case_stages", "Create a case stage."),
+    list("practice-areas.list", "/practice_areas", "List practice areas."),
+    create("practice-areas.create", "/practice_areas", "Create a practice area."),
+    list("referral-sources.list", "/referral_sources", "List referral sources."),
+    create("referral-sources.create", "/referral_sources", "Create a referral source."),
+    list("people-groups.list", "/people_groups", "List people groups."),
+    list("locations.list", "/locations", "List office and event locations.", {
+      name: { type: "string" }
+    }),
+    create("locations.create", "/locations", "Create a location."),
+    list("events.list", "/events", "List or incrementally synchronize calendar events.", {
+      start_date: { type: "string" },
+      end_date: { type: "string" },
+      case_id: { type: "string" }
+    }),
+    create("events.create", "/events", "Create a calendar event."),
+    list("tasks.list", "/tasks", "List or incrementally synchronize tasks.", {
+      due_date_start: { type: "string" },
+      due_date_end: { type: "string" },
+      case_id: { type: "string" },
+      assignee_id: { type: "string" },
+      completed: { type: "boolean" }
+    }),
+    create("tasks.create", "/tasks", "Create a task."),
+    list("calls.list", "/calls", "List logged calls.", {
+      caller_id: { type: "string" },
+      caller_type: { type: "string", enum: ["client", "lead"] },
+      staff_id: { type: "string" }
+    }),
+    create("calls.create", "/calls", "Log a call."),
+    list("time-entries.list", "/time_entries", "List time entries.", {
+      case_id: { type: "string" },
+      staff_id: { type: "string" },
+      start_date: { type: "string" },
+      end_date: { type: "string" }
+    }),
+    create("time-entries.create", "/time_entries", "Create a time entry."),
+    list("expenses.list", "/expenses", "List case expenses.", {
+      case_id: { type: "string" },
+      staff_id: { type: "string" },
+      start_date: { type: "string" },
+      end_date: { type: "string" }
+    }),
+    create("expenses.create", "/expenses", "Create a case expense."),
+    {
+      name: "case-notes.create",
+      class: "mutation",
+      description: "Add a note to a case.",
+      parameters: {
+        type: "object",
+        properties: { caseId: resourceId, data: dataObject },
+        required: ["caseId", "data"]
+      },
+      request: { method: "POST", path: "/cases/{caseId}/notes", body: "{data}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "client-notes.create",
+      class: "mutation",
+      description: "Add a note to a client.",
+      parameters: {
+        type: "object",
+        properties: { clientId: resourceId, data: dataObject },
+        required: ["clientId", "data"]
+      },
+      request: { method: "POST", path: "/clients/{clientId}/notes", body: "{data}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "company-notes.create",
+      class: "mutation",
+      description: "Add a note to a company.",
+      parameters: {
+        type: "object",
+        properties: { companyId: resourceId, data: dataObject },
+        required: ["companyId", "data"]
+      },
+      request: { method: "POST", path: "/companies/{companyId}/notes", body: "{data}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    create("custom-fields.create", "/custom_fields", "Create a custom field definition.")
+  ]
+});
+
 // src/connectors/adapters/notion.ts
 var TOKEN_URL12 = "https://api.notion.com/v1/oauth/token";
 var NOTION_VERSION = "2022-06-28";
@@ -36656,8 +38350,8 @@ function toMessageSummary2(m) {
   };
 }
 async function readMessage2(inv, accessToken3, timeoutMs) {
-  const { id } = inv.args;
-  const url = `${API7}/me/messages/${encodeURIComponent(id)}?$expand=attachments($select=id,name,contentType,size,isInline)`;
+  const { id: id2 } = inv.args;
+  const url = `${API7}/me/messages/${encodeURIComponent(id2)}?$expand=attachments($select=id,name,contentType,size,isInline)`;
   const res = await fetch(url, {
     headers: { authorization: `Bearer ${accessToken3}` },
     signal: AbortSignal.timeout(timeoutMs)
@@ -36666,7 +38360,7 @@ async function readMessage2(inv, accessToken3, timeoutMs) {
     throw new CredentialsExpired(`Outlook Mail rejected token (${res.status})`, inv.source.id);
   }
   if (res.status === 404) {
-    throw new Error(`outlook-mail read_message: message ${id} not found`);
+    throw new Error(`outlook-mail read_message: message ${id2} not found`);
   }
   if (!res.ok) {
     const text = await res.text().catch(() => "");
@@ -39228,9 +40922,9 @@ function parseRss(text) {
     const pubDate = firstTagText(item, "pubDate");
     const author = firstTagText(item, "author") ?? firstTagText(item, "dc:creator");
     const categories = collectElements(item, "category").map((cat) => decodeXml(stripTags(cat)) ?? "").filter(Boolean);
-    const id = decodeXml(guid) ?? decodeXml(link) ?? hash(item);
+    const id2 = decodeXml(guid) ?? decodeXml(link) ?? hash(item);
     return {
-      id,
+      id: id2,
       title: decodeXml(title),
       link: decodeXml(link),
       summary: decodeXml(description),
@@ -39250,7 +40944,7 @@ function parseAtom(text, feedUrl) {
   const feedUpdated = normalizeDate(decodeXml(firstTagText(feedInner, "updated")));
   const items = collectElements(feedOuter, "entry");
   const entries = items.map((item) => {
-    const id = decodeXml(firstTagText(item, "id"));
+    const id2 = decodeXml(firstTagText(item, "id"));
     const title = decodeXml(firstTagText(item, "title"));
     const summary = decodeXml(firstTagText(item, "summary"));
     const contentNode = firstTagText(item, "content");
@@ -39260,7 +40954,7 @@ function parseAtom(text, feedUrl) {
     const link = pickAtomLink(item);
     const categories = collectAtomCategories(item);
     return {
-      id: id ?? link ?? hash(item),
+      id: id2 ?? link ?? hash(item),
       title,
       link,
       summary,
@@ -40964,11 +42658,11 @@ function sharepoint(opts) {
         };
       }
       if (inv.capabilityName === "lists.create") {
-        const { siteId, displayName, columns, list } = inv.args;
+        const { siteId, displayName, columns, list: list2 } = inv.args;
         const url = `${GRAPH3}/sites/${encodeURIComponent(siteId)}/lists`;
         const body = { displayName };
         if (Array.isArray(columns)) body.columns = columns;
-        if (list && typeof list === "object") body.list = list;
+        if (list2 && typeof list2 === "object") body.list = list2;
         const res = await fetch(url, {
           method: "POST",
           headers: {
@@ -49400,7 +51094,7 @@ async function request2(source, path, options) {
     throw new ProviderRateLimited("Zoho Bookings rate limit (429)", source.id, {
       status: 429,
       body: responseBody,
-      retryAfterMs: retryAfterMs2(response.headers.get("retry-after"))
+      retryAfterMs: retryAfterMs3(response.headers.get("retry-after"))
     });
   }
   if (!response.ok) throw new Error(`zoho-bookings ${options.method} ${path} HTTP ${response.status}`);
@@ -49445,7 +51139,7 @@ function exactlyOne(args, keys, label) {
   const present = keys.filter((key) => args[key] !== void 0 && args[key] !== null && args[key] !== "");
   if (present.length !== 1) throw new Error(`zoho-bookings: exactly one ${label} is required`);
 }
-function retryAfterMs2(value) {
+function retryAfterMs3(value) {
   if (!value) return 6e4;
   const seconds = Number(value);
   return Number.isFinite(seconds) && seconds >= 0 ? Math.max(1e3, seconds * 1e3) : 6e4;
@@ -50584,11 +52278,11 @@ async function request3(source, path, options) {
     });
   }
   if (response.status === 429) {
-    const retryAfterMs3 = parseRetryAfter(response.headers.get("retry-after"));
+    const retryAfterMs4 = parseRetryAfter(response.headers.get("retry-after"));
     throw new ProviderRateLimited("Zoho Campaigns rate limit (429)", source.id, {
       status: 429,
       body: responseBody,
-      retryAfterMs: retryAfterMs3
+      retryAfterMs: retryAfterMs4
     });
   }
   if (!response.ok) {
@@ -57355,6 +59049,10 @@ var CONNECTOR_ADAPTER_FACTORIES = [
     clientId: "IRONCLAD_OAUTH_CLIENT_ID",
     clientSecret: "IRONCLAD_OAUTH_CLIENT_SECRET"
   }),
+  defineFactoryAdapter(() => mycaseConnector, {
+    clientId: "MYCASE_OAUTH_CLIENT_ID",
+    clientSecret: "MYCASE_OAUTH_CLIENT_SECRET"
+  }),
   defineFactoryAdapter(() => signNowConnector, {}),
   defineFactoryAdapter(() => oneSpanSignConnector, {}),
   defineFactoryAdapter(() => affinityConnector, {}),
@@ -57399,6 +59097,9 @@ var CONNECTOR_ADAPTER_FACTORIES = [
     clientSecret: "AUTH0_OAUTH_CLIENT_SECRET"
   }),
   defineFactoryAdapter(() => oktaConnector, {}),
+  defineFactoryAdapter(() => pingIdentityConnector, {}),
+  defineFactoryAdapter(() => oneloginConnector, {}),
+  defineFactoryAdapter(() => scimConnector, {}),
   defineFactoryAdapter(() => twentyConnector, {}),
   defineFactoryAdapter(() => folkConnector, {}),
   defineFactoryAdapter(() => freshsalesConnector, {}),
@@ -57436,6 +59137,9 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   // credential bundles, so no shared deployment secret gates registration.
   defineFactoryAdapter(() => stripePackConnector, {}),
   defineFactoryAdapter(() => chargebeeConnector, {}),
+  defineFactoryAdapter(() => recurlyConnector, {}),
+  defineFactoryAdapter(() => avalaraConnector, {}),
+  defineFactoryAdapter(() => taxjarConnector, {}),
   defineFactoryAdapter(() => paddleConnector, {}),
   defineFactoryAdapter(() => plaidConnector, {}),
   defineFactoryAdapter(() => rampConnector, {}),
@@ -57807,11 +59511,11 @@ var phonyConnector = {
       };
     }
     if (inv.capabilityName === "get_call") {
-      const { id } = inv.args;
+      const { id: id2 } = inv.args;
       const json = await getJson(
         inv,
         token,
-        `${API13}/v1/outbound/${encodeURIComponent(id)}`,
+        `${API13}/v1/outbound/${encodeURIComponent(id2)}`,
         "get_call"
       );
       return { data: { call: json.call ?? null }, fetchedAt: Date.now() };
@@ -137110,6 +138814,10 @@ var demandbaseConnector = declarativeRestConnector({
 export {
   declarativeRestConnector,
   oktaConnector,
+  clientCredentialsRestConnector,
+  oneloginConnector,
+  pingIdentityConnector,
+  scimConnector,
   actualbudgetConnector,
   aianswerConnector,
   airparserConnector,
@@ -137161,6 +138869,7 @@ export {
   attioConnector,
   auth0Connector,
   avomaConnector,
+  avalaraConnector,
   azureAdConnector,
   basecampConnector,
   backblazeConnector,
@@ -137181,6 +138890,8 @@ export {
   contentfulConnector,
   copperConnector,
   chargebeeConnector,
+  recurlyConnector,
+  taxjarConnector,
   cashfreePaymentsConnector,
   circleConnector,
   checkoutConnector,
@@ -137255,6 +138966,7 @@ export {
   meetgeekAiConnector,
   mollieConnector,
   mondayConnector,
+  mycaseConnector,
   notionConnector,
   notion,
   n8nConnector,
@@ -137722,4 +139434,4 @@ export {
   demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-GODEAAAZ.js.map
+//# sourceMappingURL=chunk-X3WHOEX7.js.map