@api-client/core 0.18.21 → 0.18.22

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

@@ -0,0 +1,744 @@
+/**
+ * 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';
+function createDomain() {
+    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 = {}) {
+    // 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;
+}
+//# sourceMappingURL=financial-services-domain.js.map