@api-client/core 0.18.21 → 0.18.22

package/src/modeling/templates/verticals/business-services/financial-services-domain.ts

@@ -0,0 +1,943 @@
+/**
+ * Financial Services Data Domain Example
+ *
+ * This file demonstrates how to create a comprehensive financial services data domain
+ * using the API Client Core modeling system. It follows the business-first approach
+ * and demonstrates proper use of namespaces, models, entities, properties,
+ * associations, and semantic annotations.
+ *
+ * The example includes:
+ * - Account Management with bank accounts, investment accounts, and credit cards
+ * - Transaction Processing with payments, transfers, deposits, and withdrawals
+ * - Customer Management with KYC, risk profiles, and customer segments
+ * - Investment Portfolio with assets, positions, and performance tracking
+ * - Compliance & Reporting with regulatory reporting and audit trails
+ * - Fraud Detection with transaction monitoring and risk scoring
+ *
+ * @example
+ * ```typescript
+ * import { createFinancialServicesDomain } from './financial-services-domain.js'
+ *
+ * const domain = createFinancialServicesDomain()
+ * console.log('Financial Services domain created with', domain.graph.nodeCount(), 'nodes')
+ * ```
+ */
+
+import { DataDomain } from '../../../DataDomain.js'
+import {
+  addIdField,
+  addNameField,
+  addDescriptionField,
+  addEmailField,
+  addFirstNameField,
+  addLastNameField,
+  addPhoneField,
+  addCustomStatusField,
+  addCreatedAtField,
+  addUpdatedAtField,
+  addCurrencyAmountField,
+} from '../../../helpers/Intelisense.js'
+import type { CreateTemplateOptions } from '../../types.js'
+
+function createDomain(): DataDomain {
+  return new DataDomain({
+    info: {
+      name: 'Financial Services Platform',
+      displayName: 'Financial Services Platform',
+      description:
+        'A comprehensive financial services platform with account management, transaction processing, ' +
+        'customer management, investment portfolios, and compliance features',
+    },
+  })
+}
+
+/**
+ * Creates a comprehensive financial services data domain following domain-driven design principles.
+ *
+ * This function demonstrates the proper hierarchy and organization for a financial services platform:
+ * 1. Creates the root DataDomain for the financial services platform
+ * 2. Organizes functionality into logical namespaces (Customer Management, Account Management, etc.)
+ * 3. Groups related entities into models within each namespace
+ * 4. Defines entities with proper semantic annotations for financial workflows
+ * 5. Establishes associations with appropriate cardinality for customer-account relationships
+ *
+ * @returns A fully configured DataDomain with all financial services entities and relationships
+ */
+export default function createFinancialServicesDomain(options: CreateTemplateOptions = {}): DataDomain {
+  // Ensure the root data domain
+  const domain = options.domain ?? createDomain()
+
+  //
+  // 1. CUSTOMER MANAGEMENT NAMESPACE
+  //
+  const customerManagement = domain.addNamespace({
+    info: {
+      name: 'CustomerManagement',
+      displayName: 'Customer Management',
+      description: 'Customer profiles, KYC, risk assessment, and segmentation',
+    },
+  })
+
+  // Customer Model
+  const customerModel = customerManagement.addModel({
+    info: {
+      name: 'Customers',
+      displayName: 'Customer Management',
+      description: 'Customer profiles and information',
+    },
+  })
+
+  // Customer Entity
+  const customerEntity = customerModel.addEntity({
+    info: {
+      name: 'customer',
+      displayName: 'Customer',
+      description: 'Financial services customer with KYC and risk profile',
+    },
+  })
+
+  addIdField(customerEntity, { displayName: 'Customer ID', description: 'Unique identifier for the customer' })
+
+  addFirstNameField(customerEntity, { description: 'Customer first name' })
+  addLastNameField(customerEntity, { description: 'Customer last name' })
+
+  customerEntity.addProperty({
+    info: { name: 'date_of_birth', displayName: 'Date of Birth', description: 'Customer date of birth' },
+    type: 'date',
+    required: true,
+  })
+
+  customerEntity.addProperty({
+    info: { name: 'ssn', displayName: 'Social Security Number', description: 'Customer SSN for identification' },
+    type: 'string',
+    required: true,
+    writeOnly: true, // Sensitive data - write only
+  })
+
+  addEmailField(customerEntity, { description: 'Customer email address' })
+  addPhoneField(customerEntity, { description: 'Customer phone number' })
+
+  customerEntity.addProperty({
+    info: { name: 'address', displayName: 'Address', description: 'Customer residential address' },
+    type: 'string',
+    required: true,
+  })
+
+  customerEntity.addProperty({
+    info: { name: 'city', displayName: 'City', description: 'Customer city' },
+    type: 'string',
+    required: true,
+  })
+
+  customerEntity.addProperty({
+    info: { name: 'state', displayName: 'State', description: 'Customer state' },
+    type: 'string',
+    required: true,
+  })
+
+  customerEntity.addProperty({
+    info: { name: 'zip_code', displayName: 'ZIP Code', description: 'Customer ZIP code' },
+    type: 'string',
+    required: true,
+  })
+
+  addCustomStatusField(customerEntity, ['active', 'inactive', 'suspended', 'pending_verification'], {
+    displayName: 'Customer Status',
+    description: 'Current status of the customer account',
+  })
+
+  customerEntity.addProperty({
+    info: { name: 'customer_type', displayName: 'Customer Type', description: 'Type of customer account' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['individual', 'business', 'trust', 'partnership'],
+    },
+  })
+
+  addCreatedAtField(customerEntity, { description: 'When the customer account was created' })
+  addUpdatedAtField(customerEntity, { description: 'When the customer account was last updated' })
+
+  // KYC Entity
+  const kycEntity = customerModel.addEntity({
+    info: {
+      name: 'kyc',
+      displayName: 'KYC Record',
+      description: 'Know Your Customer verification and documentation',
+    },
+  })
+
+  addIdField(kycEntity, { displayName: 'KYC ID', description: 'Unique identifier for the KYC record' })
+
+  addCustomStatusField(kycEntity, ['pending', 'verified', 'rejected', 'expired'], {
+    displayName: 'KYC Status',
+    description: 'Current status of KYC verification',
+  })
+
+  kycEntity.addProperty({
+    info: { name: 'verification_date', displayName: 'Verification Date', description: 'Date when KYC was verified' },
+    type: 'date',
+  })
+
+  kycEntity.addProperty({
+    info: { name: 'document_type', displayName: 'Document Type', description: 'Type of identification document' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['passport', 'drivers_license', 'national_id', 'utility_bill', 'bank_statement'],
+    },
+  })
+
+  kycEntity.addProperty({
+    info: { name: 'document_number', displayName: 'Document Number', description: 'Document identification number' },
+    type: 'string',
+    required: true,
+  })
+
+  addCreatedAtField(kycEntity, { description: 'When the KYC record was created' })
+
+  // KYC-Customer Association (One-to-One)
+  kycEntity.addAssociation(
+    { key: customerEntity.key },
+    {
+      info: { name: 'customer', displayName: 'Customer', description: 'Customer for this KYC record' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Risk Profile Entity
+  const riskProfileEntity = customerModel.addEntity({
+    info: {
+      name: 'risk_profile',
+      displayName: 'Risk Profile',
+      description: 'Customer risk assessment and scoring',
+    },
+  })
+
+  addIdField(riskProfileEntity, {
+    displayName: 'Risk Profile ID',
+    description: 'Unique identifier for the risk profile',
+  })
+
+  riskProfileEntity.addProperty({
+    info: { name: 'risk_score', displayName: 'Risk Score', description: 'Numerical risk score (1-100)' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 1,
+      maximum: 100,
+    },
+  })
+
+  addCustomStatusField(riskProfileEntity, ['low', 'medium', 'high', 'very_high'], {
+    displayName: 'Risk Level',
+    description: 'Risk level classification',
+  })
+
+  riskProfileEntity.addProperty({
+    info: { name: 'assessment_date', displayName: 'Assessment Date', description: 'Date when risk was assessed' },
+    type: 'date',
+    required: true,
+  })
+
+  addDescriptionField(riskProfileEntity, { description: 'Risk assessment notes and factors' })
+
+  addCreatedAtField(riskProfileEntity, { description: 'When the risk profile was created' })
+
+  // RiskProfile-Customer Association (One-to-One)
+  riskProfileEntity.addAssociation(
+    { key: customerEntity.key },
+    {
+      info: { name: 'customer', displayName: 'Customer', description: 'Customer for this risk profile' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 2. ACCOUNT MANAGEMENT NAMESPACE
+  //
+  const accountManagement = domain.addNamespace({
+    info: {
+      name: 'AccountManagement',
+      displayName: 'Account Management',
+      description: 'Bank accounts, investment accounts, and credit cards',
+    },
+  })
+
+  // Account Model
+  const accountModel = accountManagement.addModel({
+    info: {
+      name: 'Accounts',
+      displayName: 'Account Management',
+      description: 'Financial accounts and products',
+    },
+  })
+
+  // Bank Account Entity
+  const bankAccountEntity = accountModel.addEntity({
+    info: {
+      name: 'bank_account',
+      displayName: 'Bank Account',
+      description: 'Checking and savings accounts',
+    },
+  })
+
+  addIdField(bankAccountEntity, { displayName: 'Account ID', description: 'Unique identifier for the account' })
+
+  bankAccountEntity.addProperty({
+    info: { name: 'account_number', displayName: 'Account Number', description: 'Bank account number' },
+    type: 'string',
+    required: true,
+    unique: true,
+  })
+
+  bankAccountEntity.addProperty({
+    info: { name: 'routing_number', displayName: 'Routing Number', description: 'Bank routing number' },
+    type: 'string',
+    required: true,
+  })
+
+  bankAccountEntity.addProperty({
+    info: { name: 'account_type', displayName: 'Account Type', description: 'Type of bank account' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['checking', 'savings', 'money_market', 'cd'],
+    },
+  })
+
+  addCurrencyAmountField(bankAccountEntity, 'balance', 'Account Balance', {
+    description: 'Current account balance',
+  })
+
+  addCurrencyAmountField(bankAccountEntity, 'available_balance', 'Available Balance', {
+    description: 'Available balance for transactions',
+  })
+
+  addCustomStatusField(bankAccountEntity, ['active', 'inactive', 'frozen', 'closed'], {
+    displayName: 'Account Status',
+    description: 'Current status of the account',
+  })
+
+  addCreatedAtField(bankAccountEntity, { description: 'When the account was created' })
+  addUpdatedAtField(bankAccountEntity, { description: 'When the account was last updated' })
+
+  // BankAccount-Customer Association (Many-to-One)
+  bankAccountEntity.addAssociation(
+    { key: customerEntity.key },
+    {
+      info: { name: 'customer', displayName: 'Account Holder', description: 'Customer who owns this account' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Investment Account Entity
+  const investmentAccountEntity = accountModel.addEntity({
+    info: {
+      name: 'investment_account',
+      displayName: 'Investment Account',
+      description: 'Investment and brokerage accounts',
+    },
+  })
+
+  addIdField(investmentAccountEntity, {
+    displayName: 'Investment Account ID',
+    description: 'Unique identifier for the investment account',
+  })
+
+  investmentAccountEntity.addProperty({
+    info: { name: 'account_number', displayName: 'Account Number', description: 'Investment account number' },
+    type: 'string',
+    required: true,
+    unique: true,
+  })
+
+  investmentAccountEntity.addProperty({
+    info: { name: 'account_type', displayName: 'Account Type', description: 'Type of investment account' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['individual', 'joint', 'ira', '401k', 'roth_ira'],
+    },
+  })
+
+  addCurrencyAmountField(investmentAccountEntity, 'total_value', 'Total Portfolio Value', {
+    description: 'Total value of all investments',
+  })
+
+  addCurrencyAmountField(investmentAccountEntity, 'cash_balance', 'Cash Balance', {
+    description: 'Available cash balance',
+  })
+
+  addCustomStatusField(investmentAccountEntity, ['active', 'inactive', 'suspended', 'closed'], {
+    displayName: 'Account Status',
+    description: 'Current status of the investment account',
+  })
+
+  addCreatedAtField(investmentAccountEntity, { description: 'When the investment account was created' })
+
+  // InvestmentAccount-Customer Association (Many-to-One)
+  investmentAccountEntity.addAssociation(
+    { key: customerEntity.key },
+    {
+      info: {
+        name: 'customer',
+        displayName: 'Account Holder',
+        description: 'Customer who owns this investment account',
+      },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Credit Card Entity
+  const creditCardEntity = accountModel.addEntity({
+    info: {
+      name: 'credit_card',
+      displayName: 'Credit Card',
+      description: 'Credit card accounts and lines of credit',
+    },
+  })
+
+  addIdField(creditCardEntity, { displayName: 'Credit Card ID', description: 'Unique identifier for the credit card' })
+
+  creditCardEntity.addProperty({
+    info: { name: 'card_number', displayName: 'Card Number', description: 'Credit card number (masked)' },
+    type: 'string',
+    required: true,
+    writeOnly: true, // Sensitive data - write only
+  })
+
+  addCurrencyAmountField(creditCardEntity, 'credit_limit', 'Credit Limit', {
+    description: 'Total credit limit',
+  })
+
+  addCurrencyAmountField(creditCardEntity, 'available_credit', 'Available Credit', {
+    description: 'Available credit remaining',
+  })
+
+  addCurrencyAmountField(creditCardEntity, 'current_balance', 'Current Balance', {
+    description: 'Current outstanding balance',
+  })
+
+  creditCardEntity.addProperty({
+    info: { name: 'apr', displayName: 'APR', description: 'Annual Percentage Rate' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+      maximum: 100,
+    },
+  })
+
+  addCustomStatusField(creditCardEntity, ['active', 'inactive', 'suspended', 'closed'], {
+    displayName: 'Card Status',
+    description: 'Current status of the credit card',
+  })
+
+  addCreatedAtField(creditCardEntity, { description: 'When the credit card was created' })
+
+  // CreditCard-Customer Association (Many-to-One)
+  creditCardEntity.addAssociation(
+    { key: customerEntity.key },
+    {
+      info: { name: 'customer', displayName: 'Cardholder', description: 'Customer who owns this credit card' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 3. TRANSACTION PROCESSING NAMESPACE
+  //
+  const transactionProcessing = domain.addNamespace({
+    info: {
+      name: 'TransactionProcessing',
+      displayName: 'Transaction Processing',
+      description: 'Payments, transfers, deposits, and withdrawals',
+    },
+  })
+
+  // Transaction Model
+  const transactionModel = transactionProcessing.addModel({
+    info: {
+      name: 'Transactions',
+      displayName: 'Transaction Management',
+      description: 'Financial transactions and transfers',
+    },
+  })
+
+  // Transaction Entity
+  const transactionEntity = transactionModel.addEntity({
+    info: {
+      name: 'transaction',
+      displayName: 'Transaction',
+      description: 'Financial transaction record',
+    },
+  })
+
+  addIdField(transactionEntity, { displayName: 'Transaction ID', description: 'Unique identifier for the transaction' })
+
+  transactionEntity.addProperty({
+    info: {
+      name: 'transaction_number',
+      displayName: 'Transaction Number',
+      description: 'Human-readable transaction number',
+    },
+    type: 'string',
+    required: true,
+    unique: true,
+  })
+
+  addCustomStatusField(transactionEntity, ['pending', 'processing', 'completed', 'failed', 'cancelled'], {
+    displayName: 'Transaction Status',
+    description: 'Current status of the transaction',
+  })
+
+  transactionEntity.addProperty({
+    info: { name: 'transaction_type', displayName: 'Transaction Type', description: 'Type of financial transaction' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['deposit', 'withdrawal', 'transfer', 'payment', 'fee'],
+    },
+  })
+
+  addCurrencyAmountField(transactionEntity, 'amount', 'Transaction Amount', {
+    description: 'Amount of the transaction',
+  })
+
+  transactionEntity.addProperty({
+    info: { name: 'description', displayName: 'Description', description: 'Transaction description' },
+    type: 'string',
+  })
+
+  transactionEntity.addProperty({
+    info: { name: 'transaction_date', displayName: 'Transaction Date', description: 'Date when transaction occurred' },
+    type: 'date',
+    required: true,
+  })
+
+  transactionEntity.addProperty({
+    info: { name: 'reference_number', displayName: 'Reference Number', description: 'External reference number' },
+    type: 'string',
+  })
+
+  addCreatedAtField(transactionEntity, { description: 'When the transaction was created' })
+
+  // Transaction-Customer Association (Many-to-One)
+  transactionEntity.addAssociation(
+    { key: customerEntity.key },
+    {
+      info: { name: 'customer', displayName: 'Customer', description: 'Customer who initiated the transaction' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Transaction-Account Association (Many-to-One)
+  transactionEntity.addAssociation(
+    { key: bankAccountEntity.key },
+    {
+      info: { name: 'account', displayName: 'Account', description: 'Account involved in the transaction' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Transfer Entity
+  const transferEntity = transactionModel.addEntity({
+    info: {
+      name: 'transfer',
+      displayName: 'Transfer',
+      description: 'Money transfers between accounts',
+    },
+  })
+
+  addIdField(transferEntity, { displayName: 'Transfer ID', description: 'Unique identifier for the transfer' })
+
+  addCustomStatusField(transferEntity, ['pending', 'processing', 'completed', 'failed', 'cancelled'], {
+    displayName: 'Transfer Status',
+    description: 'Current status of the transfer',
+  })
+
+  addCurrencyAmountField(transferEntity, 'amount', 'Transfer Amount', {
+    description: 'Amount being transferred',
+  })
+
+  transferEntity.addProperty({
+    info: { name: 'transfer_date', displayName: 'Transfer Date', description: 'Date when transfer was initiated' },
+    type: 'date',
+    required: true,
+  })
+
+  addCreatedAtField(transferEntity, { description: 'When the transfer was created' })
+
+  // Transfer-From Account Association (Many-to-One)
+  transferEntity.addAssociation(
+    { key: bankAccountEntity.key },
+    {
+      info: { name: 'from_account', displayName: 'From Account', description: 'Source account for the transfer' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Transfer-To Account Association (Many-to-One)
+  transferEntity.addAssociation(
+    { key: bankAccountEntity.key },
+    {
+      info: { name: 'to_account', displayName: 'To Account', description: 'Destination account for the transfer' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 4. INVESTMENT PORTFOLIO NAMESPACE
+  //
+  const investmentPortfolio = domain.addNamespace({
+    info: {
+      name: 'InvestmentPortfolio',
+      displayName: 'Investment Portfolio',
+      description: 'Assets, positions, and performance tracking',
+    },
+  })
+
+  // Portfolio Model
+  const portfolioModel = investmentPortfolio.addModel({
+    info: {
+      name: 'Portfolios',
+      displayName: 'Portfolio Management',
+      description: 'Investment portfolios and assets',
+    },
+  })
+
+  // Asset Entity
+  const assetEntity = portfolioModel.addEntity({
+    info: {
+      name: 'asset',
+      displayName: 'Asset',
+      description: 'Investment asset (stocks, bonds, etc.)',
+    },
+  })
+
+  addIdField(assetEntity, { displayName: 'Asset ID', description: 'Unique identifier for the asset' })
+
+  assetEntity.addProperty({
+    info: { name: 'symbol', displayName: 'Symbol', description: 'Asset symbol/ticker' },
+    type: 'string',
+    required: true,
+    unique: true,
+  })
+
+  addNameField(assetEntity, { displayName: 'Asset Name', description: 'Name of the asset' })
+
+  assetEntity.addProperty({
+    info: { name: 'asset_type', displayName: 'Asset Type', description: 'Type of investment asset' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['stock', 'bond', 'etf', 'mutual_fund', 'commodity', 'crypto'],
+    },
+  })
+
+  addCurrencyAmountField(assetEntity, 'current_price', 'Current Price', {
+    description: 'Current market price of the asset',
+  })
+
+  addCurrencyAmountField(assetEntity, 'market_cap', 'Market Cap', {
+    description: 'Market capitalization',
+  })
+
+  addCreatedAtField(assetEntity, { description: 'When the asset was created' })
+
+  // Position Entity
+  const positionEntity = portfolioModel.addEntity({
+    info: {
+      name: 'position',
+      displayName: 'Position',
+      description: 'Investment position in a portfolio',
+    },
+  })
+
+  addIdField(positionEntity, { displayName: 'Position ID', description: 'Unique identifier for the position' })
+
+  positionEntity.addProperty({
+    info: { name: 'quantity', displayName: 'Quantity', description: 'Number of shares/units held' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 0,
+    },
+  })
+
+  addCurrencyAmountField(positionEntity, 'average_cost', 'Average Cost', {
+    description: 'Average cost per share/unit',
+  })
+
+  addCurrencyAmountField(positionEntity, 'current_value', 'Current Value', {
+    description: 'Current market value of the position',
+  })
+
+  addCurrencyAmountField(positionEntity, 'unrealized_gain_loss', 'Unrealized Gain/Loss', {
+    description: 'Unrealized profit or loss',
+  })
+
+  addCreatedAtField(positionEntity, { description: 'When the position was created' })
+
+  // Position-InvestmentAccount Association (Many-to-One)
+  positionEntity.addAssociation(
+    { key: investmentAccountEntity.key },
+    {
+      info: { name: 'account', displayName: 'Investment Account', description: 'Account holding this position' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Position-Asset Association (Many-to-One)
+  positionEntity.addAssociation(
+    { key: assetEntity.key },
+    {
+      info: { name: 'asset', displayName: 'Asset', description: 'Asset for this position' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  // Performance Entity
+  const performanceEntity = portfolioModel.addEntity({
+    info: {
+      name: 'performance',
+      displayName: 'Performance',
+      description: 'Portfolio performance tracking',
+    },
+  })
+
+  addIdField(performanceEntity, {
+    displayName: 'Performance ID',
+    description: 'Unique identifier for the performance record',
+  })
+
+  performanceEntity.addProperty({
+    info: { name: 'date', displayName: 'Date', description: 'Date of performance measurement' },
+    type: 'date',
+    required: true,
+  })
+
+  addCurrencyAmountField(performanceEntity, 'total_value', 'Total Value', {
+    description: 'Total portfolio value on this date',
+  })
+
+  performanceEntity.addProperty({
+    info: { name: 'return_percentage', displayName: 'Return Percentage', description: 'Percentage return' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: -100,
+      maximum: 1000,
+    },
+  })
+
+  addCreatedAtField(performanceEntity, { description: 'When the performance record was created' })
+
+  // Performance-InvestmentAccount Association (Many-to-One)
+  performanceEntity.addAssociation(
+    { key: investmentAccountEntity.key },
+    {
+      info: { name: 'account', displayName: 'Investment Account', description: 'Account for this performance record' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  //
+  // 5. COMPLIANCE & REPORTING NAMESPACE
+  //
+  const complianceReporting = domain.addNamespace({
+    info: {
+      name: 'ComplianceReporting',
+      displayName: 'Compliance & Reporting',
+      description: 'Regulatory reporting and audit trails',
+    },
+  })
+
+  // Compliance Model
+  const complianceModel = complianceReporting.addModel({
+    info: {
+      name: 'Compliance',
+      displayName: 'Compliance Management',
+      description: 'Regulatory compliance and reporting',
+    },
+  })
+
+  // Audit Trail Entity
+  const auditTrailEntity = complianceModel.addEntity({
+    info: {
+      name: 'audit_trail',
+      displayName: 'Audit Trail',
+      description: 'System audit trail for compliance',
+    },
+  })
+
+  addIdField(auditTrailEntity, { displayName: 'Audit ID', description: 'Unique identifier for the audit record' })
+
+  auditTrailEntity.addProperty({
+    info: { name: 'action', displayName: 'Action', description: 'Action performed' },
+    type: 'string',
+    required: true,
+  })
+
+  auditTrailEntity.addProperty({
+    info: { name: 'entity_type', displayName: 'Entity Type', description: 'Type of entity affected' },
+    type: 'string',
+    required: true,
+  })
+
+  auditTrailEntity.addProperty({
+    info: { name: 'entity_id', displayName: 'Entity ID', description: 'ID of the affected entity' },
+    type: 'string',
+    required: true,
+  })
+
+  auditTrailEntity.addProperty({
+    info: { name: 'user_id', displayName: 'User ID', description: 'User who performed the action' },
+    type: 'string',
+    required: true,
+  })
+
+  auditTrailEntity.addProperty({
+    info: { name: 'ip_address', displayName: 'IP Address', description: 'IP address of the user' },
+    type: 'string',
+  })
+
+  addDescriptionField(auditTrailEntity, { description: 'Additional details about the action' })
+
+  addCreatedAtField(auditTrailEntity, {
+    name: 'timestamp',
+    displayName: 'Timestamp',
+    description: 'When the action occurred',
+  })
+
+  // Regulatory Report Entity
+  const regulatoryReportEntity = complianceModel.addEntity({
+    info: {
+      name: 'regulatory_report',
+      displayName: 'Regulatory Report',
+      description: 'Regulatory reporting requirements',
+    },
+  })
+
+  addIdField(regulatoryReportEntity, { displayName: 'Report ID', description: 'Unique identifier for the report' })
+
+  addNameField(regulatoryReportEntity, { displayName: 'Report Name', description: 'Name of the regulatory report' })
+
+  addCustomStatusField(regulatoryReportEntity, ['draft', 'submitted', 'approved', 'rejected'], {
+    displayName: 'Report Status',
+    description: 'Current status of the report',
+  })
+
+  regulatoryReportEntity.addProperty({
+    info: { name: 'report_type', displayName: 'Report Type', description: 'Type of regulatory report' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['suspicious_activity', 'large_transaction', 'annual_report', 'quarterly_report'],
+    },
+  })
+
+  regulatoryReportEntity.addProperty({
+    info: { name: 'reporting_period', displayName: 'Reporting Period', description: 'Period covered by the report' },
+    type: 'string',
+    required: true,
+  })
+
+  addDescriptionField(regulatoryReportEntity, { description: 'Report content and details' })
+
+  addCreatedAtField(regulatoryReportEntity, { description: 'When the report was created' })
+
+  //
+  // 6. FRAUD DETECTION NAMESPACE
+  //
+  const fraudDetection = domain.addNamespace({
+    info: {
+      name: 'FraudDetection',
+      displayName: 'Fraud Detection',
+      description: 'Transaction monitoring and risk scoring',
+    },
+  })
+
+  // Fraud Detection Model
+  const fraudDetectionModel = fraudDetection.addModel({
+    info: {
+      name: 'FraudDetection',
+      displayName: 'Fraud Detection Management',
+      description: 'Fraud detection and monitoring',
+    },
+  })
+
+  // Fraud Alert Entity
+  const fraudAlertEntity = fraudDetectionModel.addEntity({
+    info: {
+      name: 'fraud_alert',
+      displayName: 'Fraud Alert',
+      description: 'Fraud detection alerts and flags',
+    },
+  })
+
+  addIdField(fraudAlertEntity, { displayName: 'Alert ID', description: 'Unique identifier for the fraud alert' })
+
+  addCustomStatusField(fraudAlertEntity, ['pending', 'investigating', 'resolved', 'false_positive'], {
+    displayName: 'Alert Status',
+    description: 'Current status of the fraud alert',
+  })
+
+  fraudAlertEntity.addProperty({
+    info: { name: 'alert_type', displayName: 'Alert Type', description: 'Type of fraud alert' },
+    type: 'string',
+    required: true,
+    schema: {
+      enum: ['suspicious_transaction', 'unusual_pattern', 'identity_theft', 'account_takeover'],
+    },
+  })
+
+  fraudAlertEntity.addProperty({
+    info: { name: 'risk_score', displayName: 'Risk Score', description: 'Risk score (1-100)' },
+    type: 'number',
+    required: true,
+    schema: {
+      minimum: 1,
+      maximum: 100,
+    },
+  })
+
+  addDescriptionField(fraudAlertEntity, { description: 'Details about the fraud alert' })
+
+  addCreatedAtField(fraudAlertEntity, { description: 'When the fraud alert was created' })
+
+  // FraudAlert-Transaction Association (Many-to-One)
+  fraudAlertEntity.addAssociation(
+    { key: transactionEntity.key },
+    {
+      info: { name: 'transaction', displayName: 'Transaction', description: 'Transaction that triggered the alert' },
+      required: false,
+      multiple: false,
+    }
+  )
+
+  // FraudAlert-Customer Association (Many-to-One)
+  fraudAlertEntity.addAssociation(
+    { key: customerEntity.key },
+    {
+      info: { name: 'customer', displayName: 'Customer', description: 'Customer associated with the alert' },
+      required: true,
+      multiple: false,
+    }
+  )
+
+  return domain
+}