@contractspec/lib.contracts-integrations 2.0.0

package/dist/node/integrations/openbanking/contracts/index.js

@@ -0,0 +1,643 @@
+// src/integrations/openbanking/models.ts
+import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
+var BankAccountRecord = new SchemaModel({
+  name: "BankAccountRecord",
+  description: "Canonical representation of a bank account synced from an open banking provider.",
+  fields: {
+    id: { type: ScalarTypeEnum.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    userId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    institutionId: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    institutionName: {
+      type: ScalarTypeEnum.NonEmptyString(),
+      isOptional: false
+    },
+    institutionLogoUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    iban: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    bic: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    accountType: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    currency: { type: ScalarTypeEnum.Currency(), isOptional: false },
+    displayName: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    accountNumberMasked: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    productCode: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    balance: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    availableBalance: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true
+    },
+    lastSyncedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var BankTransactionRecord = new SchemaModel({
+  name: "BankTransactionRecord",
+  description: "Canonical transaction entry mapped from Powens into the open banking ledger.",
+  fields: {
+    id: { type: ScalarTypeEnum.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    externalId: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    amount: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum.Currency(), isOptional: false },
+    date: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    bookingDate: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    valueDate: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    counterpartyName: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    counterpartyAccount: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    merchantCategoryCode: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    rawCategory: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    standardizedCategory: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    transactionType: {
+      type: ScalarTypeEnum.NonEmptyString(),
+      isOptional: false
+    },
+    status: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    runningBalance: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AccountBalanceRecord = new SchemaModel({
+  name: "AccountBalanceRecord",
+  description: "Canonical balance snapshot computed from Powens balance payloads.",
+  fields: {
+    id: { type: ScalarTypeEnum.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    tenantId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum.ID(), isOptional: false },
+    balanceType: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
+    currentBalance: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: false
+    },
+    availableBalance: {
+      type: ScalarTypeEnum.Float_unsecure(),
+      isOptional: true
+    },
+    currency: { type: ScalarTypeEnum.Currency(), isOptional: false },
+    lastUpdatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+
+// src/integrations/openbanking/telemetry.ts
+var OPENBANKING_PII_FIELDS = [
+  "iban",
+  "bic",
+  "accountNumberMasked",
+  "accountNumber",
+  "counterpartyName",
+  "counterpartyAccount",
+  "description",
+  "merchantName",
+  "merchantCategoryCode",
+  "reference"
+];
+var OPENBANKING_TELEMETRY_EVENTS = {
+  accountsSynced: "openbanking.accounts.synced",
+  accountsSyncFailed: "openbanking.accounts.sync_failed",
+  transactionsSynced: "openbanking.transactions.synced",
+  transactionsSyncFailed: "openbanking.transactions.sync_failed",
+  balancesRefreshed: "openbanking.balances.refreshed",
+  balancesRefreshFailed: "openbanking.balances.refresh_failed",
+  overviewGenerated: "openbanking.overview.generated"
+};
+function redactOpenBankingTelemetryPayload(payload) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (OPENBANKING_PII_FIELDS.includes(key)) {
+      redacted[key] = maskValue(value);
+    } else if (Array.isArray(value)) {
+      redacted[key] = value.map((item) => typeof item === "object" && item !== null ? redactOpenBankingTelemetryPayload(item) : item);
+    } else if (typeof value === "object" && value !== null) {
+      redacted[key] = redactOpenBankingTelemetryPayload(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+function maskValue(value) {
+  if (value == null)
+    return "";
+  const str = String(value);
+  if (str.length <= 4)
+    return "*".repeat(str.length);
+  return `${"*".repeat(Math.max(str.length - 4, 0))}${str.slice(-4)}`;
+}
+
+// src/integrations/openbanking/contracts/accounts.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts-spec/operations";
+var OpenBankingListAccountsInput = new SchemaModel2({
+  name: "OpenBankingListAccountsInput",
+  description: "Parameters for listing bank accounts through the open banking provider.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    userId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    includeBalances: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    institutionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    cursor: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    pageSize: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true }
+  }
+});
+var OpenBankingListAccountsOutput = new SchemaModel2({
+  name: "OpenBankingListAccountsOutput",
+  description: "Paginated list of bank accounts available to the tenant and user.",
+  fields: {
+    accounts: {
+      type: BankAccountRecord,
+      isOptional: false,
+      isArray: true
+    },
+    nextCursor: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+  }
+});
+var OpenBankingGetAccountInput = new SchemaModel2({
+  name: "OpenBankingGetAccountInput",
+  description: "Parameters for retrieving a specific bank account.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    includeBalances: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    includeLatestTransactions: {
+      type: ScalarTypeEnum2.Boolean(),
+      isOptional: true
+    }
+  }
+});
+var OpenBankingSyncAccountsInput = new SchemaModel2({
+  name: "OpenBankingSyncAccountsInput",
+  description: "Command payload to trigger an account synchronisation against the open banking provider.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    userId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    accountIds: {
+      type: ScalarTypeEnum2.ID(),
+      isArray: true,
+      isOptional: true
+    },
+    forceFullRefresh: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    triggerWorkflows: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+  }
+});
+var OpenBankingSyncAccountsOutput = new SchemaModel2({
+  name: "OpenBankingSyncAccountsOutput",
+  description: "Result of a bank account synchronisation run.",
+  fields: {
+    synced: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    failed: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    errors: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    nextSyncSuggestedAt: {
+      type: ScalarTypeEnum2.DateTime(),
+      isOptional: true
+    }
+  }
+});
+var OpenBankingListAccounts = defineQuery({
+  meta: {
+    key: "openbanking.accounts.list",
+    version: "1.0.0",
+    description: "List bank accounts available to a tenant/user via Powens Open Banking.",
+    goal: "Provide downstream workflows with the set of accounts accessible via the configured open banking connection.",
+    context: "Used by Pocket Family Office dashboards and sync workflows to enumerate bank accounts prior to syncing balances or transactions.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "accounts"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingListAccountsInput,
+    output: OpenBankingListAccountsOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var OpenBankingGetAccount = defineQuery({
+  meta: {
+    key: "openbanking.accounts.get",
+    version: "1.0.0",
+    description: "Retrieve the canonical bank account record for the given account identifier.",
+    goal: "Allow user-facing experiences and automations to display up-to-date account metadata.",
+    context: "Invoked by UI surfaces and workflow automation steps that require detailed metadata for a specific bank account.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "accounts"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingGetAccountInput,
+    output: BankAccountRecord
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var OpenBankingSyncAccounts = defineCommand({
+  meta: {
+    key: "openbanking.accounts.sync",
+    version: "1.0.0",
+    description: "Initiate a synchronisation run to refresh bank account metadata from Powens.",
+    goal: "Keep canonical bank account records aligned with the external open banking provider.",
+    context: "Triggered by scheduled workflows or manual operator actions to reconcile account metadata prior to transaction/balance syncs.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "accounts"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingSyncAccountsInput,
+    output: OpenBankingSyncAccountsOutput
+  },
+  policy: {
+    auth: "admin"
+  },
+  telemetry: {
+    success: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSynced },
+      properties: ({ input, output }) => {
+        const payload = input;
+        const result = output;
+        return {
+          tenantId: payload?.tenantId,
+          connectionId: payload?.connectionId,
+          synced: result?.synced,
+          failed: result?.failed
+        };
+      }
+    },
+    failure: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.accountsSyncFailed },
+      properties: ({ input, error }) => {
+        const payload = input;
+        return {
+          tenantId: payload?.tenantId,
+          connectionId: payload?.connectionId,
+          error: error instanceof Error ? error.message : String(error ?? "unknown")
+        };
+      }
+    }
+  }
+});
+var openBankingAccountContracts = {
+  OpenBankingListAccounts,
+  OpenBankingGetAccount,
+  OpenBankingSyncAccounts
+};
+function registerOpenBankingAccountContracts(registry) {
+  return registry.register(OpenBankingListAccounts).register(OpenBankingGetAccount).register(OpenBankingSyncAccounts);
+}
+
+// src/integrations/openbanking/contracts/transactions.ts
+import { ScalarTypeEnum as ScalarTypeEnum3, SchemaModel as SchemaModel3 } from "@contractspec/lib.schema";
+import {
+  defineCommand as defineCommand2,
+  defineQuery as defineQuery2
+} from "@contractspec/lib.contracts-spec/operations";
+var OpenBankingListTransactionsInput = new SchemaModel3({
+  name: "OpenBankingListTransactionsInput",
+  description: "Parameters for listing bank transactions from the canonical ledger.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    from: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
+    to: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
+    cursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    pageSize: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
+    direction: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    minimumAmount: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: true },
+    maximumAmount: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: true },
+    category: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
+  }
+});
+var OpenBankingListTransactionsOutput = new SchemaModel3({
+  name: "OpenBankingListTransactionsOutput",
+  description: "Paginated list of transactions for a bank account.",
+  fields: {
+    transactions: {
+      type: BankTransactionRecord,
+      isOptional: false,
+      isArray: true
+    },
+    nextCursor: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    hasMore: { type: ScalarTypeEnum3.Boolean(), isOptional: true }
+  }
+});
+var OpenBankingSyncTransactionsInput = new SchemaModel3({
+  name: "OpenBankingSyncTransactionsInput",
+  description: "Command payload to synchronise transactions from the open banking provider into the canonical ledger.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum3.ID(), isOptional: false },
+    from: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
+    to: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
+    connectionId: { type: ScalarTypeEnum3.ID(), isOptional: true },
+    includePending: { type: ScalarTypeEnum3.Boolean(), isOptional: true },
+    backfillDays: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true }
+  }
+});
+var OpenBankingSyncTransactionsOutput = new SchemaModel3({
+  name: "OpenBankingSyncTransactionsOutput",
+  description: "Result of a transaction synchronisation run.",
+  fields: {
+    synced: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    failed: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    earliestSyncedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
+    latestSyncedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: true },
+    nextSinceToken: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: true
+    },
+    errors: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var OpenBankingListTransactions = defineQuery2({
+  meta: {
+    key: "openbanking.transactions.list",
+    version: "1.0.0",
+    description: "List bank transactions that have been normalised into the canonical ledger.",
+    goal: "Allow downstream analytics and UI surfaces to page through canonical bank transactions.",
+    context: "Used by Pocket Family Office dashboards, reconciliation workflows, and analytics data views.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "transactions"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingListTransactionsInput,
+    output: OpenBankingListTransactionsOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var OpenBankingSyncTransactions = defineCommand2({
+  meta: {
+    key: "openbanking.transactions.sync",
+    version: "1.0.0",
+    description: "Synchronise transactions for a bank account by calling the configured open banking provider.",
+    goal: "Ensure the canonical transaction ledger stays aligned with the external provider.",
+    context: "Triggered by scheduled workflows or on-demand actions when activity is expected on an account.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "transactions"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingSyncTransactionsInput,
+    output: OpenBankingSyncTransactionsOutput
+  },
+  policy: {
+    auth: "admin"
+  },
+  telemetry: {
+    success: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.transactionsSynced },
+      properties: ({ input, output }) => {
+        const payload = input;
+        const result = output;
+        return {
+          tenantId: payload?.tenantId,
+          accountId: payload?.accountId,
+          synced: result?.synced,
+          failed: result?.failed,
+          earliestSyncedAt: result?.earliestSyncedAt,
+          latestSyncedAt: result?.latestSyncedAt
+        };
+      }
+    },
+    failure: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.transactionsSyncFailed },
+      properties: ({ input, error }) => {
+        const payload = input;
+        return {
+          tenantId: payload?.tenantId,
+          accountId: payload?.accountId,
+          error: error instanceof Error ? error.message : String(error ?? "unknown")
+        };
+      }
+    }
+  }
+});
+var openBankingTransactionContracts = {
+  OpenBankingListTransactions,
+  OpenBankingSyncTransactions
+};
+function registerOpenBankingTransactionContracts(registry) {
+  return registry.register(OpenBankingListTransactions).register(OpenBankingSyncTransactions);
+}
+
+// src/integrations/openbanking/contracts/balances.ts
+import { ScalarTypeEnum as ScalarTypeEnum4, SchemaModel as SchemaModel4 } from "@contractspec/lib.schema";
+import {
+  defineCommand as defineCommand3,
+  defineQuery as defineQuery3
+} from "@contractspec/lib.contracts-spec/operations";
+var OpenBankingGetBalancesInput = new SchemaModel4({
+  name: "OpenBankingGetBalancesInput",
+  description: "Parameters for retrieving bank account balances from the canonical ledger.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum4.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum4.ID(), isOptional: false },
+    balanceTypes: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var OpenBankingGetBalancesOutput = new SchemaModel4({
+  name: "OpenBankingGetBalancesOutput",
+  description: "Canonical balances for a bank account.",
+  fields: {
+    balances: {
+      type: AccountBalanceRecord,
+      isOptional: false,
+      isArray: true
+    },
+    asOf: { type: ScalarTypeEnum4.DateTime(), isOptional: true }
+  }
+});
+var OpenBankingRefreshBalancesInput = new SchemaModel4({
+  name: "OpenBankingRefreshBalancesInput",
+  description: "Command payload to refresh balances for a bank account via the open banking provider.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum4.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum4.ID(), isOptional: false },
+    connectionId: { type: ScalarTypeEnum4.ID(), isOptional: true },
+    balanceTypes: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    forceRefresh: { type: ScalarTypeEnum4.Boolean(), isOptional: true }
+  }
+});
+var OpenBankingRefreshBalancesOutput = new SchemaModel4({
+  name: "OpenBankingRefreshBalancesOutput",
+  description: "Result of a balance refresh against the open banking provider.",
+  fields: {
+    balances: {
+      type: AccountBalanceRecord,
+      isOptional: false,
+      isArray: true
+    },
+    refreshedAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    errors: {
+      type: ScalarTypeEnum4.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var OpenBankingGetBalances = defineQuery3({
+  meta: {
+    key: "openbanking.balances.get",
+    version: "1.0.0",
+    description: "Retrieve the latest cached balances for a bank account.",
+    goal: "Expose current and available balances required by dashboards and analytics.",
+    context: "Used by Pocket Family Office UI surfaces and automation steps that require balance totals prior to generating summaries.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "balances"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingGetBalancesInput,
+    output: OpenBankingGetBalancesOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var OpenBankingRefreshBalances = defineCommand3({
+  meta: {
+    key: "openbanking.balances.refresh",
+    version: "1.0.0",
+    description: "Refresh balances for a bank account via the configured open banking provider.",
+    goal: "Ensure canonical balance records reflect the latest values from Powens.",
+    context: "Triggered by scheduled workflows before generating summaries or forecasting cashflow.",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "balances"],
+    stability: "experimental"
+  },
+  io: {
+    input: OpenBankingRefreshBalancesInput,
+    output: OpenBankingRefreshBalancesOutput
+  },
+  policy: {
+    auth: "admin"
+  },
+  telemetry: {
+    success: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.balancesRefreshed },
+      properties: ({ input, output }) => {
+        const payload = input;
+        const result = output;
+        return {
+          tenantId: payload?.tenantId,
+          accountId: payload?.accountId,
+          refreshedAt: result?.refreshedAt,
+          balanceCount: Array.isArray(result?.balances) ? result?.balances.length : undefined
+        };
+      }
+    },
+    failure: {
+      event: { key: OPENBANKING_TELEMETRY_EVENTS.balancesRefreshFailed },
+      properties: ({ input, error }) => {
+        const payload = input;
+        return {
+          tenantId: payload?.tenantId,
+          accountId: payload?.accountId,
+          error: error instanceof Error ? error.message : String(error ?? "unknown")
+        };
+      }
+    }
+  }
+});
+var openBankingBalanceContracts = {
+  OpenBankingGetBalances,
+  OpenBankingRefreshBalances
+};
+function registerOpenBankingBalanceContracts(registry) {
+  return registry.register(OpenBankingGetBalances).register(OpenBankingRefreshBalances);
+}
+
+// src/integrations/openbanking/openbanking.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts-spec/features";
+var OpenBankingFeature = defineFeature({
+  meta: {
+    key: "openbanking",
+    version: "1.0.0",
+    title: "Open Banking Integration",
+    description: "Open banking account sync, balance refresh, and transaction synchronization",
+    domain: "integrations",
+    owners: ["@platform.finance"],
+    tags: ["open-banking", "powens", "finance", "banking"],
+    stability: "experimental"
+  },
+  operations: [
+    { key: "openbanking.accounts.sync", version: "1.0.0" },
+    { key: "openbanking.accounts.list", version: "1.0.0" },
+    { key: "openbanking.accounts.get", version: "1.0.0" },
+    { key: "openbanking.balances.refresh", version: "1.0.0" },
+    { key: "openbanking.balances.get", version: "1.0.0" },
+    { key: "openbanking.transactions.sync", version: "1.0.0" },
+    { key: "openbanking.transactions.list", version: "1.0.0" }
+  ],
+  events: [],
+  presentations: [],
+  opToPresentation: [],
+  presentationsTargets: [],
+  capabilities: {
+    provides: [{ key: "openbanking", version: "1.0.0" }],
+    requires: [{ key: "identity", version: "1.0.0" }]
+  }
+});
+// src/integrations/openbanking/contracts/index.ts
+function registerOpenBankingContracts(registry) {
+  return registerOpenBankingBalanceContracts(registerOpenBankingTransactionContracts(registerOpenBankingAccountContracts(registry)));
+}
+export {
+  registerOpenBankingContracts,
+  OpenBankingSyncTransactions,
+  OpenBankingSyncAccounts,
+  OpenBankingRefreshBalances,
+  OpenBankingListTransactions,
+  OpenBankingListAccounts,
+  OpenBankingGetBalances,
+  OpenBankingGetAccount,
+  OpenBankingFeature
+};