@contractspec/lib.contracts-integrations 2.0.0

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

@@ -0,0 +1,297 @@
+// 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/transactions.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, SchemaModel as SchemaModel2 } from "@contractspec/lib.schema";
+import {
+  defineCommand,
+  defineQuery
+} from "@contractspec/lib.contracts-spec/operations";
+var OpenBankingListTransactionsInput = new SchemaModel2({
+  name: "OpenBankingListTransactionsInput",
+  description: "Parameters for listing bank transactions from the canonical ledger.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    from: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    to: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    cursor: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    pageSize: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    direction: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    minimumAmount: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
+    maximumAmount: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: true },
+    category: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+  }
+});
+var OpenBankingListTransactionsOutput = new SchemaModel2({
+  name: "OpenBankingListTransactionsOutput",
+  description: "Paginated list of transactions for a bank account.",
+  fields: {
+    transactions: {
+      type: BankTransactionRecord,
+      isOptional: false,
+      isArray: true
+    },
+    nextCursor: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    hasMore: { type: ScalarTypeEnum2.Boolean(), isOptional: true }
+  }
+});
+var OpenBankingSyncTransactionsInput = new SchemaModel2({
+  name: "OpenBankingSyncTransactionsInput",
+  description: "Command payload to synchronise transactions from the open banking provider into the canonical ledger.",
+  fields: {
+    tenantId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    accountId: { type: ScalarTypeEnum2.ID(), isOptional: false },
+    from: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    to: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    connectionId: { type: ScalarTypeEnum2.ID(), isOptional: true },
+    includePending: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    backfillDays: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true }
+  }
+});
+var OpenBankingSyncTransactionsOutput = new SchemaModel2({
+  name: "OpenBankingSyncTransactionsOutput",
+  description: "Result of a transaction synchronisation run.",
+  fields: {
+    synced: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    failed: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    earliestSyncedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    latestSyncedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    nextSinceToken: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    errors: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var OpenBankingListTransactions = defineQuery({
+  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 = defineCommand({
+  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);
+}
+export {
+  registerOpenBankingTransactionContracts,
+  openBankingTransactionContracts,
+  OpenBankingSyncTransactions,
+  OpenBankingListTransactions
+};

package/dist/node/integrations/openbanking/guards.js

@@ -0,0 +1,41 @@
+// src/integrations/openbanking/guards.ts
+var PRIMARY_SLOT_ID = "primaryOpenBanking";
+function ensurePrimaryOpenBankingIntegration(config) {
+  const integration = config.integrations.find((item) => item.slot.slotId === PRIMARY_SLOT_ID);
+  if (!integration) {
+    return {
+      ok: false,
+      error: "primaryOpenBanking slot is not bound in the resolved app config."
+    };
+  }
+  const status = integration.connection.status;
+  if (status === "error" || status === "disconnected") {
+    return {
+      ok: false,
+      integration,
+      error: `primaryOpenBanking connection is in status "${status}".`
+    };
+  }
+  if (status === "unknown") {
+    return {
+      ok: false,
+      integration,
+      error: "primaryOpenBanking connection health is unknown."
+    };
+  }
+  return { ok: true, integration };
+}
+function assertPrimaryOpenBankingReady(config) {
+  const result = ensurePrimaryOpenBankingIntegration(config);
+  if (!result.ok) {
+    throw new Error(result.error ?? "Open banking integration not available.");
+  }
+  if (!result.integration) {
+    throw new Error(result.error ?? "Open banking integration not available.");
+  }
+  return result.integration;
+}
+export {
+  ensurePrimaryOpenBankingIntegration,
+  assertPrimaryOpenBankingReady
+};

package/dist/node/integrations/openbanking/models.js

@@ -0,0 +1,109 @@
+// 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 }
+  }
+});
+export {
+  BankTransactionRecord,
+  BankAccountRecord,
+  AccountBalanceRecord
+};

package/dist/node/integrations/openbanking/openbanking.capability.js

@@ -0,0 +1,17 @@
+// src/integrations/openbanking/openbanking.capability.ts
+import { defineCapability } from "@contractspec/lib.contracts-spec/capabilities";
+import { StabilityEnum } from "@contractspec/lib.contracts-spec/ownership";
+var OpenBankingCapability = defineCapability({
+  meta: {
+    key: "openbanking",
+    version: "1.0.0",
+    kind: "integration",
+    stability: StabilityEnum.Experimental,
+    description: "Open Banking integrations capability",
+    owners: ["@platform.finance"],
+    tags: ["openbanking", "finance", "integrations"]
+  }
+});
+export {
+  OpenBankingCapability
+};

package/dist/node/integrations/openbanking/openbanking.feature.js

@@ -0,0 +1,34 @@
+// 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" }]
+  }
+});
+export {
+  OpenBankingFeature
+};

package/dist/node/integrations/openbanking/telemetry.js

@@ -0,0 +1,50 @@
+// 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)}`;
+}
+export {
+  redactOpenBankingTelemetryPayload,
+  OPENBANKING_TELEMETRY_EVENTS,
+  OPENBANKING_PII_FIELDS
+};