@mycreat-labs/integrations-sdk 0.0.0-stage → 0.1.0

package/dist/testing.js

@@ -0,0 +1,248 @@
+// src/errors.ts
+var IntegrationError = class extends Error {
+  constructor(code, disposition = "permanent_failure", retryAfterMs) {
+    super(code);
+    this.code = code;
+    this.disposition = disposition;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "IntegrationError";
+  }
+  code;
+  disposition;
+  retryAfterMs;
+  sdkError = "@mycreat-labs/integrations-sdk/v1";
+};
+
+// src/testing.ts
+var key = (namespace, id) => `${namespace}\0${id}`;
+var matches = (value, scope) => value.namespace === scope.namespace && value.ownerId === scope.ownerId;
+function createTestStore() {
+  let data = {
+    owners: /* @__PURE__ */ new Map(),
+    flows: /* @__PURE__ */ new Map(),
+    grants: /* @__PURE__ */ new Map(),
+    connections: /* @__PURE__ */ new Map(),
+    operations: /* @__PURE__ */ new Map(),
+    events: /* @__PURE__ */ new Map()
+  };
+  let tail = Promise.resolve();
+  const store = {
+    async assertCompatible() {
+    },
+    snapshot: () => structuredClone(data),
+    async transaction(work) {
+      let release;
+      const previous = tail;
+      tail = new Promise((resolve) => {
+        release = resolve;
+      });
+      await previous;
+      const draft = structuredClone(data);
+      const tx = {
+        nativeContext: { testTransaction: true },
+        async lockScope(scope, allowErased = false) {
+          const id = key(scope.namespace, scope.ownerId);
+          if (!draft.owners.has(id))
+            draft.owners.set(id, { erased: false, epochs: {} });
+          if (draft.owners.get(id).erased && !allowErased)
+            throw new IntegrationError("owner_erased");
+          return draft.owners.get(id).erased;
+        },
+        async authorizationEpoch(scope, epochKey, advance = false) {
+          const owner = draft.owners.get(key(scope.namespace, scope.ownerId));
+          if (!owner) throw new Error("owner_not_locked");
+          if (advance)
+            owner.epochs[epochKey] = (owner.epochs[epochKey] ?? 0) + 1;
+          return owner.epochs[epochKey] ?? 0;
+        },
+        async markOwnerErased(scope) {
+          const owner = draft.owners.get(key(scope.namespace, scope.ownerId));
+          if (owner) owner.erased = true;
+        },
+        async assertAccountOwner(scope, provider, registrationId, accountId) {
+          if ([...draft.connections.values()].some(
+            (c) => c.namespace === scope.namespace && c.ownerId !== scope.ownerId && c.provider === provider && c.registrationId === registrationId && c.account.id === accountId
+          ))
+            throw new IntegrationError("account_already_connected");
+        },
+        async collectGarbage(namespace, now, retentionMs) {
+          for (const [id, flow] of draft.flows)
+            if (flow.namespace === namespace && flow.expiresAt <= now)
+              draft.flows.delete(id);
+          for (const [id, op] of draft.operations)
+            if (op.namespace === namespace && op.action !== "__sdk.revoke" && ["failed", "blocked", "outcome_unknown", "cancelled"].includes(
+              op.status
+            ) && op.updatedAt <= now - retentionMs)
+              draft.operations.set(id, {
+                ...op,
+                input: { keyId: "", value: "" },
+                hostContext: void 0,
+                status: "failed",
+                errorCode: "payload_expired",
+                version: op.version + 1
+              });
+          for (const [id, grant] of draft.grants)
+            if (grant.namespace === namespace && grant.status === "revoked" && ![...draft.connections.values()].some(
+              (c) => c.namespace === namespace && c.grantId === grant.id
+            ))
+              draft.grants.delete(id);
+        },
+        async insertFlow(value) {
+          draft.flows.set(key(value.namespace, value.id), value);
+        },
+        async consumeFlow(namespace, id, bindingHash, purpose, now) {
+          const idKey = key(namespace, id);
+          const value = draft.flows.get(idKey);
+          if (!value || value.bindingHash !== bindingHash || value.purpose !== purpose || value.expiresAt <= now)
+            return null;
+          draft.flows.delete(idKey);
+          return value;
+        },
+        async insertGrant(value) {
+          draft.grants.set(key(value.namespace, value.id), value);
+        },
+        async getGrant(scope, id) {
+          const value = draft.grants.get(key(scope.namespace, id));
+          return value && matches(value, scope) ? value : null;
+        },
+        async saveGrant(value, expected) {
+          const id = key(value.namespace, value.id);
+          if (draft.grants.get(id)?.version !== expected) return false;
+          draft.grants.set(id, value);
+          return true;
+        },
+        async insertConnection(value) {
+          if ([...draft.connections.values()].some(
+            (c) => matches(c, value) && c.provider === value.provider && c.registrationId === value.registrationId && c.account.id === value.account.id
+          ))
+            throw new Error("unique_connection");
+          draft.connections.set(key(value.namespace, value.id), value);
+        },
+        async getConnection(scope, id) {
+          const value = draft.connections.get(key(scope.namespace, id));
+          return value && matches(value, scope) ? value : null;
+        },
+        async listConnections(scope) {
+          return [...draft.connections.values()].filter(
+            (v) => matches(v, scope)
+          );
+        },
+        async saveConnection(value, expected) {
+          const id = key(value.namespace, value.id);
+          if (draft.connections.get(id)?.generation !== expected) return false;
+          draft.connections.set(id, value);
+          return true;
+        },
+        async insertOperation(value) {
+          const existing = [...draft.operations.values()].find(
+            (v) => matches(v, value) && v.action === value.action && v.idempotencyKey === value.idempotencyKey
+          );
+          if (existing) return existing;
+          draft.operations.set(key(value.namespace, value.id), value);
+          return value;
+        },
+        async getOperation(scope, id) {
+          const value = draft.operations.get(key(scope.namespace, id));
+          return value && matches(value, scope) ? value : null;
+        },
+        async listOperations(scope, connectionId) {
+          return [...draft.operations.values()].filter(
+            (v) => matches(v, scope) && (!connectionId || v.connectionId === connectionId)
+          );
+        },
+        async hasPendingRevocation(scope, connectionId) {
+          return [...draft.operations.values()].some(
+            (op) => matches(op, scope) && op.connectionId === connectionId && op.action === "__sdk.revoke" && !["succeeded", "cancelled"].includes(op.status)
+          );
+        },
+        async saveOperation(value, expected, lease) {
+          const id = key(value.namespace, value.id);
+          const current = draft.operations.get(id);
+          if (current?.version !== expected || lease && (current.leaseToken !== lease || (current.leaseUntil ?? 0) <= Date.now()))
+            return false;
+          draft.operations.set(id, value);
+          return true;
+        },
+        async claimOperation(namespace, id, version, now, leaseToken, leaseUntil) {
+          const idKey = key(namespace, id);
+          const current = draft.operations.get(idKey);
+          if (!current || current.version !== version || !["pending", "outcome_unknown"].includes(current.status) || current.availableAt > now)
+            return null;
+          const next = {
+            ...current,
+            status: "running",
+            version: current.version + 1,
+            attempts: current.attempts + 1,
+            leaseToken,
+            leaseUntil,
+            updatedAt: now
+          };
+          draft.operations.set(idKey, next);
+          return next;
+        },
+        async dueOperations(namespace, now, limit) {
+          return [...draft.operations.values()].filter(
+            (v) => v.namespace === namespace && ["pending", "outcome_unknown"].includes(v.status) && v.availableAt <= now
+          ).slice(0, limit).map((v) => ({ id: v.id, version: v.version }));
+        },
+        async recoverOperations(namespace, now) {
+          let count = 0;
+          for (const [id, value] of draft.operations)
+            if (value.namespace === namespace && value.status === "running" && (value.leaseUntil ?? 0) <= now) {
+              draft.operations.set(id, {
+                ...value,
+                status: value.dispatching ? "outcome_unknown" : "pending",
+                version: value.version + 1,
+                availableAt: now,
+                leaseToken: void 0,
+                leaseUntil: void 0
+              });
+              count++;
+            }
+          return count;
+        },
+        async insertEvent(value) {
+          draft.events.set(key(value.namespace, value.id), value);
+        },
+        async listEvents(scope, after) {
+          const values = [...draft.events.values()].filter(
+            (v) => matches(v, scope)
+          );
+          const at = after ? values.findIndex((v) => v.id === after) : -1;
+          return values.slice(at + 1);
+        },
+        async eraseOwner(scope, preserve) {
+          for (const [id, value] of draft.flows)
+            if (matches(value, scope)) draft.flows.delete(id);
+          for (const [id, value] of draft.events)
+            if (matches(value, scope)) draft.events.delete(id);
+          for (const [id, value] of draft.operations)
+            if (matches(value, scope) && (!preserve || value.action !== "__sdk.revoke" || ["succeeded", "cancelled"].includes(value.status)))
+              draft.operations.delete(id);
+          for (const [id, value] of draft.connections)
+            if (matches(value, scope) && (!preserve || ![...draft.operations.values()].some(
+              (op) => op.connectionId === value.id && matches(op, scope)
+            )))
+              draft.connections.delete(id);
+          for (const [id, value] of draft.grants)
+            if (matches(value, scope) && (!preserve || ![...draft.connections.values()].some(
+              (c) => c.grantId === value.id && matches(c, scope)
+            )))
+              draft.grants.delete(id);
+        }
+      };
+      try {
+        const result = await work(tx);
+        data = draft;
+        return result;
+      } finally {
+        release();
+      }
+    }
+  };
+  return store;
+}
+export {
+  createTestStore
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/testing.ts"],"sourcesContent":["export type FailureDisposition =\n  \"retryable\" | \"requires_reauth\" | \"outcome_unknown\" | \"permanent_failure\";\nexport class IntegrationError extends Error {\n  readonly sdkError = \"@mycreat-labs/integrations-sdk/v1\";\n  constructor(\n    readonly code: string,\n    readonly disposition: FailureDisposition = \"permanent_failure\",\n    readonly retryAfterMs?: number,\n  ) {\n    super(code);\n    this.name = \"IntegrationError\";\n  }\n}\nexport function integrationError(error: unknown): IntegrationError {\n  if (error instanceof IntegrationError) return error;\n  // Bundled subpath entries and independently installed copies have separate class identities.\n  if (\n    error instanceof Error &&\n    \"sdkError\" in error &&\n    error.sdkError === \"@mycreat-labs/integrations-sdk/v1\" &&\n    \"code\" in error &&\n    typeof error.code === \"string\" &&\n    /^[a-zA-Z0-9_]{1,100}$/.test(error.code) &&\n    \"disposition\" in error &&\n    [\n      \"retryable\",\n      \"requires_reauth\",\n      \"outcome_unknown\",\n      \"permanent_failure\",\n    ].includes(String(error.disposition))\n  ) {\n    const delay =\n      \"retryAfterMs\" in error &&\n      typeof error.retryAfterMs === \"number\" &&\n      Number.isFinite(error.retryAfterMs) &&\n      error.retryAfterMs >= 0\n        ? error.retryAfterMs\n        : undefined;\n    return new IntegrationError(\n      error.code,\n      error.disposition as FailureDisposition,\n      delay,\n    );\n  }\n  return new IntegrationError(\"provider_unavailable\", \"outcome_unknown\");\n}\n","/** Test-only in-memory transactional adapter. Import explicitly from /testing; never a production default. */\nimport type {\n  Connection,\n  Flow,\n  Grant,\n  IntegrationEvent,\n  IntegrationStore,\n  IntegrationTransaction,\n  Operation,\n  Scope,\n} from \"./types\";\nimport { IntegrationError } from \"./errors\";\ntype Data = {\n  owners: Map<string, { erased: boolean; epochs: Record<string, number> }>;\n  flows: Map<string, Flow>;\n  grants: Map<string, Grant>;\n  connections: Map<string, Connection>;\n  operations: Map<string, Operation>;\n  events: Map<string, IntegrationEvent>;\n};\nconst key = (namespace: string, id: string) => `${namespace}\\0${id}`;\nconst matches = (value: { namespace: string; ownerId: string }, scope: Scope) =>\n  value.namespace === scope.namespace && value.ownerId === scope.ownerId;\nexport function createTestStore() {\n  let data: Data = {\n    owners: new Map(),\n    flows: new Map(),\n    grants: new Map(),\n    connections: new Map(),\n    operations: new Map(),\n    events: new Map(),\n  };\n  let tail = Promise.resolve();\n  const store: IntegrationStore & { snapshot: () => Data } = {\n    async assertCompatible() {},\n    snapshot: () => structuredClone(data),\n    async transaction(work) {\n      let release!: () => void;\n      const previous = tail;\n      tail = new Promise<void>((resolve) => {\n        release = resolve;\n      });\n      await previous;\n      const draft = structuredClone(data);\n      const tx: IntegrationTransaction = {\n        nativeContext: { testTransaction: true },\n        async lockScope(scope, allowErased = false) {\n          const id = key(scope.namespace, scope.ownerId);\n          if (!draft.owners.has(id))\n            draft.owners.set(id, { erased: false, epochs: {} });\n          if (draft.owners.get(id)!.erased && !allowErased)\n            throw new IntegrationError(\"owner_erased\");\n          return draft.owners.get(id)!.erased;\n        },\n        async authorizationEpoch(scope, epochKey, advance = false) {\n          const owner = draft.owners.get(key(scope.namespace, scope.ownerId));\n          if (!owner) throw new Error(\"owner_not_locked\");\n          if (advance)\n            owner.epochs[epochKey] = (owner.epochs[epochKey] ?? 0) + 1;\n          return owner.epochs[epochKey] ?? 0;\n        },\n        async markOwnerErased(scope) {\n          const owner = draft.owners.get(key(scope.namespace, scope.ownerId));\n          if (owner) owner.erased = true;\n        },\n        async assertAccountOwner(scope, provider, registrationId, accountId) {\n          if (\n            [...draft.connections.values()].some(\n              (c) =>\n                c.namespace === scope.namespace &&\n                c.ownerId !== scope.ownerId &&\n                c.provider === provider &&\n                c.registrationId === registrationId &&\n                c.account.id === accountId,\n            )\n          )\n            throw new IntegrationError(\"account_already_connected\");\n        },\n        async collectGarbage(namespace, now, retentionMs) {\n          for (const [id, flow] of draft.flows)\n            if (flow.namespace === namespace && flow.expiresAt <= now)\n              draft.flows.delete(id);\n          for (const [id, op] of draft.operations)\n            if (\n              op.namespace === namespace &&\n              op.action !== \"__sdk.revoke\" &&\n              [\"failed\", \"blocked\", \"outcome_unknown\", \"cancelled\"].includes(\n                op.status,\n              ) &&\n              op.updatedAt <= now - retentionMs\n            )\n              draft.operations.set(id, {\n                ...op,\n                input: { keyId: \"\", value: \"\" },\n                hostContext: undefined,\n                status: \"failed\",\n                errorCode: \"payload_expired\",\n                version: op.version + 1,\n              });\n          for (const [id, grant] of draft.grants)\n            if (\n              grant.namespace === namespace &&\n              grant.status === \"revoked\" &&\n              ![...draft.connections.values()].some(\n                (c) => c.namespace === namespace && c.grantId === grant.id,\n              )\n            )\n              draft.grants.delete(id);\n        },\n        async insertFlow(value) {\n          draft.flows.set(key(value.namespace, value.id), value);\n        },\n        async consumeFlow(namespace, id, bindingHash, purpose, now) {\n          const idKey = key(namespace, id);\n          const value = draft.flows.get(idKey);\n          if (\n            !value ||\n            value.bindingHash !== bindingHash ||\n            value.purpose !== purpose ||\n            value.expiresAt <= now\n          )\n            return null;\n          draft.flows.delete(idKey);\n          return value;\n        },\n        async insertGrant(value) {\n          draft.grants.set(key(value.namespace, value.id), value);\n        },\n        async getGrant(scope, id) {\n          const value = draft.grants.get(key(scope.namespace, id));\n          return value && matches(value, scope) ? value : null;\n        },\n        async saveGrant(value, expected) {\n          const id = key(value.namespace, value.id);\n          if (draft.grants.get(id)?.version !== expected) return false;\n          draft.grants.set(id, value);\n          return true;\n        },\n        async insertConnection(value) {\n          if (\n            [...draft.connections.values()].some(\n              (c) =>\n                matches(c, value) &&\n                c.provider === value.provider &&\n                c.registrationId === value.registrationId &&\n                c.account.id === value.account.id,\n            )\n          )\n            throw new Error(\"unique_connection\");\n          draft.connections.set(key(value.namespace, value.id), value);\n        },\n        async getConnection(scope, id) {\n          const value = draft.connections.get(key(scope.namespace, id));\n          return value && matches(value, scope) ? value : null;\n        },\n        async listConnections(scope) {\n          return [...draft.connections.values()].filter((v) =>\n            matches(v, scope),\n          );\n        },\n        async saveConnection(value, expected) {\n          const id = key(value.namespace, value.id);\n          if (draft.connections.get(id)?.generation !== expected) return false;\n          draft.connections.set(id, value);\n          return true;\n        },\n        async insertOperation(value) {\n          const existing = [...draft.operations.values()].find(\n            (v) =>\n              matches(v, value) &&\n              v.action === value.action &&\n              v.idempotencyKey === value.idempotencyKey,\n          );\n          if (existing) return existing;\n          draft.operations.set(key(value.namespace, value.id), value);\n          return value;\n        },\n        async getOperation(scope, id) {\n          const value = draft.operations.get(key(scope.namespace, id));\n          return value && matches(value, scope) ? value : null;\n        },\n        async listOperations(scope, connectionId) {\n          return [...draft.operations.values()].filter(\n            (v) =>\n              matches(v, scope) &&\n              (!connectionId || v.connectionId === connectionId),\n          );\n        },\n        async hasPendingRevocation(scope, connectionId) {\n          return [...draft.operations.values()].some(\n            (op) =>\n              matches(op, scope) &&\n              op.connectionId === connectionId &&\n              op.action === \"__sdk.revoke\" &&\n              ![\"succeeded\", \"cancelled\"].includes(op.status),\n          );\n        },\n        async saveOperation(value, expected, lease) {\n          const id = key(value.namespace, value.id);\n          const current = draft.operations.get(id);\n          if (\n            current?.version !== expected ||\n            (lease &&\n              (current.leaseToken !== lease ||\n                (current.leaseUntil ?? 0) <= Date.now()))\n          )\n            return false;\n          draft.operations.set(id, value);\n          return true;\n        },\n        async claimOperation(\n          namespace,\n          id,\n          version,\n          now,\n          leaseToken,\n          leaseUntil,\n        ) {\n          const idKey = key(namespace, id);\n          const current = draft.operations.get(idKey);\n          if (\n            !current ||\n            current.version !== version ||\n            ![\"pending\", \"outcome_unknown\"].includes(current.status) ||\n            current.availableAt > now\n          )\n            return null;\n          const next: Operation = {\n            ...current,\n            status: \"running\",\n            version: current.version + 1,\n            attempts: current.attempts + 1,\n            leaseToken,\n            leaseUntil,\n            updatedAt: now,\n          };\n          draft.operations.set(idKey, next);\n          return next;\n        },\n        async dueOperations(namespace, now, limit) {\n          return [...draft.operations.values()]\n            .filter(\n              (v) =>\n                v.namespace === namespace &&\n                [\"pending\", \"outcome_unknown\"].includes(v.status) &&\n                v.availableAt <= now,\n            )\n            .slice(0, limit)\n            .map((v) => ({ id: v.id, version: v.version }));\n        },\n        async recoverOperations(namespace, now) {\n          let count = 0;\n          for (const [id, value] of draft.operations)\n            if (\n              value.namespace === namespace &&\n              value.status === \"running\" &&\n              (value.leaseUntil ?? 0) <= now\n            ) {\n              draft.operations.set(id, {\n                ...value,\n                status: value.dispatching ? \"outcome_unknown\" : \"pending\",\n                version: value.version + 1,\n                availableAt: now,\n                leaseToken: undefined,\n                leaseUntil: undefined,\n              });\n              count++;\n            }\n          return count;\n        },\n        async insertEvent(value) {\n          draft.events.set(key(value.namespace, value.id), value);\n        },\n        async listEvents(scope, after) {\n          const values = [...draft.events.values()].filter((v) =>\n            matches(v, scope),\n          );\n          const at = after ? values.findIndex((v) => v.id === after) : -1;\n          return values.slice(at + 1);\n        },\n        async eraseOwner(scope, preserve) {\n          for (const [id, value] of draft.flows)\n            if (matches(value, scope)) draft.flows.delete(id);\n          for (const [id, value] of draft.events)\n            if (matches(value, scope)) draft.events.delete(id);\n          for (const [id, value] of draft.operations)\n            if (\n              matches(value, scope) &&\n              (!preserve ||\n                value.action !== \"__sdk.revoke\" ||\n                [\"succeeded\", \"cancelled\"].includes(value.status))\n            )\n              draft.operations.delete(id);\n          for (const [id, value] of draft.connections)\n            if (\n              matches(value, scope) &&\n              (!preserve ||\n                ![...draft.operations.values()].some(\n                  (op) => op.connectionId === value.id && matches(op, scope),\n                ))\n            )\n              draft.connections.delete(id);\n          for (const [id, value] of draft.grants)\n            if (\n              matches(value, scope) &&\n              (!preserve ||\n                ![...draft.connections.values()].some(\n                  (c) => c.grantId === value.id && matches(c, scope),\n                ))\n            )\n              draft.grants.delete(id);\n        },\n      };\n      try {\n        const result = await work(tx);\n        data = draft;\n        return result;\n      } finally {\n        release();\n      }\n    },\n  };\n  return store;\n}\n"],"mappings":"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","names":[]}

package/dist/types-Y4-DoJ1A.d.cts

@@ -0,0 +1,260 @@
+type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+type Purpose = "identity" | "connect";
+type Scope = {
+    namespace: string;
+    ownerId: string;
+};
+type VerifiedIdentity = {
+    provider: string;
+    issuer: string;
+    subject: string;
+    identityNamespace: string;
+    email?: string;
+    emailVerified: boolean;
+    name?: string;
+    username?: string;
+};
+type CredentialMaterial = {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    scopes?: string[];
+    extra?: {
+        [key: string]: Json;
+    };
+};
+type RemoteAccount = {
+    id: string;
+    label: string;
+    metadata?: {
+        [key: string]: Json;
+    };
+};
+type Resource = {
+    id: string;
+    type: string;
+    name: string;
+    url?: string;
+    metadata?: {
+        [key: string]: Json;
+    };
+};
+type ResourcePage = {
+    items: Resource[];
+    nextCursor?: string;
+};
+type ProviderContext = {
+    credentials: CredentialMaterial;
+    signal?: AbortSignal;
+    fetch: typeof globalThis.fetch;
+};
+type ActionContext = ProviderContext & {
+    operationId: string;
+    checkpoint: Json;
+    saveCheckpoint(value: Json): Promise<void>;
+};
+type ActionDefinition = {
+    validate(input: unknown): Json;
+    execute(input: Json, context: ActionContext): Promise<Json>;
+    reconcile?(input: Json, context: ActionContext): Promise<{
+        resolved: true;
+        result: Json;
+    } | {
+        resolved: false;
+    }>;
+};
+type AuthorizationInput = {
+    state: string;
+    verifier: string;
+    challenge: string;
+    nonce: string;
+    purpose: Purpose;
+};
+type AuthorizationResult = {
+    identity?: VerifiedIdentity;
+    account?: RemoteAccount;
+    credentials?: CredentialMaterial;
+};
+interface IntegrationProvider {
+    key: string;
+    registrationId: string;
+    purposes: readonly Purpose[];
+    authorization?: {
+        url(input: AuthorizationInput): string;
+        exchange(input: {
+            code: string;
+            verifier: string;
+            nonce: string;
+            purpose: Purpose;
+            signal?: AbortSignal;
+        }, fetch: typeof globalThis.fetch): Promise<AuthorizationResult>;
+    };
+    verifyNative?(input: {
+        idToken: string;
+        nonce: string;
+        authorizationCode?: string;
+    }, fetch: typeof globalThis.fetch): Promise<VerifiedIdentity>;
+    resources?(input: {
+        cursor?: string;
+        query?: string;
+        parentId?: string;
+    }, context: ProviderContext): Promise<ResourcePage>;
+    refresh?(credentials: CredentialMaterial, context: {
+        fetch: typeof globalThis.fetch;
+        signal?: AbortSignal;
+    }): Promise<CredentialMaterial>;
+    revoke?(credentials: CredentialMaterial, context: {
+        fetch: typeof globalThis.fetch;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    actions?: Readonly<Record<string, ActionDefinition>>;
+}
+type SealedValue = {
+    keyId: string;
+    value: string;
+};
+interface TokenVault {
+    seal(value: Json, context: string): Promise<SealedValue>;
+    open(value: SealedValue, context: string): Promise<Json>;
+}
+type Flow = {
+    id: string;
+    namespace: string;
+    ownerId: string;
+    provider: string;
+    registrationId: string;
+    purpose: Purpose;
+    bindingHash: string;
+    expiresAt: number;
+    secret: SealedValue;
+    authorizationEpoch?: number;
+    connectionId?: string;
+    generation?: number;
+};
+type Grant = {
+    id: string;
+    namespace: string;
+    ownerId: string;
+    provider: string;
+    registrationId: string;
+    account: RemoteAccount;
+    version: number;
+    status: "active" | "reauth_required" | "revoked";
+    credentials: SealedValue;
+    expiresAt?: number;
+    refreshLease?: string;
+    refreshUntil?: number;
+    authorizationLease?: string;
+    authorizationUntil?: number;
+};
+type Connection = {
+    id: string;
+    namespace: string;
+    ownerId: string;
+    provider: string;
+    registrationId: string;
+    grantId: string;
+    account: RemoteAccount;
+    generation: number;
+    status: "active" | "reauth_required" | "revoked";
+    createdAt: number;
+    updatedAt: number;
+};
+type OperationStatus = "pending" | "running" | "succeeded" | "failed" | "blocked" | "outcome_unknown" | "cancelled";
+type Operation = {
+    id: string;
+    namespace: string;
+    ownerId: string;
+    connectionId: string;
+    generation: number;
+    action: string;
+    idempotencyKey: string;
+    fingerprint: string;
+    input: SealedValue;
+    hostContext?: Json;
+    status: OperationStatus;
+    version: number;
+    attempts: number;
+    authRecoveries?: number;
+    availableAt: number;
+    checkpoint: Json;
+    dispatching: boolean;
+    leaseToken?: string;
+    leaseUntil?: number;
+    result?: Json;
+    errorCode?: string;
+    createdAt: number;
+    updatedAt: number;
+};
+type IntegrationEvent = {
+    id: string;
+    namespace: string;
+    ownerId: string;
+    operationId: string;
+    type: string;
+    createdAt: number;
+    data: Json;
+};
+interface IntegrationTransaction {
+    readonly nativeContext?: unknown;
+    lockScope(scope: Scope, allowErased?: boolean): Promise<boolean>;
+    authorizationEpoch(scope: Scope, key: string, advance?: boolean): Promise<number>;
+    markOwnerErased(scope: Scope): Promise<void>;
+    assertAccountOwner(scope: Scope, provider: string, registrationId: string, accountId: string): Promise<void>;
+    collectGarbage(namespace: string, now: number, retentionMs: number): Promise<void>;
+    insertFlow(flow: Flow): Promise<void>;
+    consumeFlow(namespace: string, id: string, bindingHash: string, purpose: Purpose, now: number): Promise<Flow | null>;
+    insertGrant(grant: Grant): Promise<void>;
+    getGrant(scope: Scope, id: string, lock?: boolean): Promise<Grant | null>;
+    saveGrant(grant: Grant, expectedVersion: number): Promise<boolean>;
+    insertConnection(connection: Connection): Promise<void>;
+    getConnection(scope: Scope, id: string, lock?: boolean): Promise<Connection | null>;
+    listConnections(scope: Scope): Promise<Connection[]>;
+    saveConnection(connection: Connection, expectedGeneration: number): Promise<boolean>;
+    insertOperation(operation: Operation): Promise<Operation>;
+    getOperation(scope: Scope, id: string, lock?: boolean): Promise<Operation | null>;
+    listOperations(scope: Scope, connectionId?: string): Promise<Operation[]>;
+    hasPendingRevocation(scope: Scope, connectionId: string): Promise<boolean>;
+    saveOperation(operation: Operation, expectedVersion: number, leaseToken?: string): Promise<boolean>;
+    claimOperation(namespace: string, id: string, version: number, now: number, leaseToken: string, leaseUntil: number): Promise<Operation | null>;
+    dueOperations(namespace: string, now: number, limit: number): Promise<Array<{
+        id: string;
+        version: number;
+    }>>;
+    recoverOperations(namespace: string, now: number): Promise<number>;
+    insertEvent(event: IntegrationEvent): Promise<void>;
+    listEvents(scope: Scope, after?: string): Promise<IntegrationEvent[]>;
+    eraseOwner(scope: Scope, preserveRevocations: boolean): Promise<void>;
+}
+interface IntegrationStore {
+    transaction<T>(work: (tx: IntegrationTransaction) => Promise<T>): Promise<T>;
+    assertCompatible(): Promise<void>;
+}
+type TaskMessage = {
+    taskId: string;
+    version: number;
+};
+interface QueueTransport {
+    publish(messages: TaskMessage[]): Promise<void>;
+    start(handler: (message: TaskMessage) => Promise<void>): Promise<void>;
+    stop(): Promise<void>;
+}
+type SdkLogger = {
+    info?(fields: Record<string, string | number | boolean>, message: string): void;
+    warn?(fields: Record<string, string | number | boolean>, message: string): void;
+    error?(fields: Record<string, string | number | boolean>, message: string): void;
+};
+interface ApiRateLimiter {
+    take(key: string): Promise<{
+        allowed: boolean;
+        retryAfterMs: number;
+    }>;
+}
+type HostHooks = {
+    beforeExecute?(context: unknown, operation: Operation, input: Json): Promise<void>;
+    onResult?(context: unknown, operation: Operation, event: IntegrationEvent, input: Json): Promise<void>;
+};
+
+export type { ApiRateLimiter as A, Connection as C, Flow as F, Grant as G, HostHooks as H, IntegrationStore as I, Json as J, Operation as O, Purpose as P, QueueTransport as Q, ResourcePage as R, Scope as S, TokenVault as T, VerifiedIdentity as V, IntegrationTransaction as a, IntegrationEvent as b, TaskMessage as c, IntegrationProvider as d, SdkLogger as e, ActionContext as f, ActionDefinition as g, AuthorizationInput as h, AuthorizationResult as i, CredentialMaterial as j, OperationStatus as k, ProviderContext as l, RemoteAccount as m, Resource as n, SealedValue as o };