@coinbase-sample/prime-sdk-ts 0.8.2 → 0.10.0

package/dist/shared/dynamicEnumValidation.old.js

@@ -1,746 +0,0 @@
-"use strict";
-/**
- * Copyright 2025-present Coinbase Global, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.enumRegistry = exports.DynamicEnumValidationError = void 0;
-exports.validateRequestEnums = validateRequestEnums;
-exports.validateAndNormalizeRequest = validateAndNormalizeRequest;
-exports.setDynamicValidationConfig = setDynamicValidationConfig;
-exports.getDynamicValidationConfig = getDynamicValidationConfig;
-exports.dynamicValidateRequest = dynamicValidateRequest;
-exports.getEnumInfo = getEnumInfo;
-/**
- * Dynamic enum validation system that automatically discovers and validates
- * enum fields in request objects without manual service-specific configuration.
- *
- * This approach is more scalable and maintainable than manual validation rules.
- */
-const enumHelpers_1 = require("./enumHelpers");
-const enumPrefixes_1 = require("../model/enumPrefixes");
-// Import all enums dynamically
-const AllEnums = __importStar(require("../model/enums/"));
-/**
- * Error thrown when a request contains invalid enum values
- */
-class DynamicEnumValidationError extends Error {
-    constructor(field, value, enumName, validValues, validKeys) {
-        const validValuesStr = validValues.join(', ');
-        const validKeysStr = validKeys
-            ? ` Valid keys: ${validKeys.join(', ')}.`
-            : '';
-        super(`Invalid ${field} (${enumName}): "${value}". Valid values: ${validValuesStr}.${validKeysStr} ` +
-            `Consider using enum helpers for automatic normalization.`);
-        this.field = field;
-        this.value = value;
-        this.enumName = enumName;
-        this.validValues = validValues;
-        this.validKeys = validKeys;
-        this.name = 'DynamicEnumValidationError';
-    }
-}
-exports.DynamicEnumValidationError = DynamicEnumValidationError;
-/**
- * Registry of all available enums for dynamic lookup
- */
-class EnumRegistry {
-    constructor() {
-        this.enumMap = new Map();
-        this.enumNameMap = new Map();
-        this.registerAllEnums();
-    }
-    /**
-     * Automatically register all enums from the model/enums directory
-     */
-    registerAllEnums() {
-        Object.entries(AllEnums).forEach(([enumName, enumObject]) => {
-            if (this.isValidEnum(enumObject)) {
-                this.enumMap.set(enumName, enumObject);
-                this.enumNameMap.set(enumObject, enumName);
-            }
-        });
-    }
-    /**
-     * Check if an object is a valid enum
-     */
-    isValidEnum(obj) {
-        return (obj &&
-            typeof obj === 'object' &&
-            Object.values(obj).every((val) => typeof val === 'string') &&
-            Object.keys(obj).length > 0);
-    }
-    /**
-     * Get enum by name
-     */
-    getEnum(enumName) {
-        return this.enumMap.get(enumName);
-    }
-    /**
-     * Get enum name for a given enum object
-     */
-    getEnumName(enumObject) {
-        return this.enumNameMap.get(enumObject);
-    }
-    /**
-     * Find enum that contains a specific value
-     */
-    findEnumByValue(value) {
-        const normalizedValue = (0, enumHelpers_1.normalizeEnumValue)(value);
-        for (const [enumName, enumObject] of this.enumMap) {
-            if (Object.values(enumObject).includes(normalizedValue)) {
-                return { enum: enumObject, name: enumName };
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Find enum that contains a specific key
-     */
-    findEnumByKey(key) {
-        const normalizedKey = (0, enumHelpers_1.normalizeEnumValue)(key);
-        for (const [enumName, enumObject] of this.enumMap) {
-            for (const enumKey of Object.keys(enumObject)) {
-                if ((0, enumHelpers_1.normalizeEnumValue)(enumKey) === normalizedKey) {
-                    return { enum: enumObject, name: enumName };
-                }
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Get all registered enum names
-     */
-    getAllEnumNames() {
-        return Array.from(this.enumMap.keys());
-    }
-    /**
-     * Validate a value against a specific enum with prefix handling
-     */
-    validateEnumValue(enumName, value) {
-        const enumObject = this.getEnum(enumName);
-        if (!enumObject) {
-            return { valid: false, error: `Unknown enum: ${enumName}` };
-        }
-        // Use the enhanced validation with prefix handling
-        return validateEnumValueWithPrefix(enumObject, value);
-    }
-}
-// Global enum registry instance
-const enumRegistry = new EnumRegistry();
-exports.enumRegistry = enumRegistry;
-/**
- * Cache for storing analyzed request types to avoid repeated reflection
- */
-const requestTypeCache = new Map();
-/**
- * Analyzes a request object to identify enum fields dynamically
- * This uses runtime type inspection and pattern matching
- */
-function analyzeRequestObject(request) {
-    // Create a simple cache key based on the field names and types
-    const cacheKey = Object.keys(request || {})
-        .sort()
-        .join(',');
-    if (requestTypeCache.has(cacheKey)) {
-        return requestTypeCache.get(cacheKey);
-    }
-    const enumFields = [];
-    if (!request || typeof request !== 'object') {
-        return enumFields;
-    }
-    Object.entries(request).forEach(([fieldName, value]) => {
-        const fieldInfo = analyzeField(fieldName, value);
-        if (fieldInfo) {
-            enumFields.push(fieldInfo);
-        }
-    });
-    // Cache the result
-    requestTypeCache.set(cacheKey, enumFields);
-    return enumFields;
-}
-/**
- * Analyzes a single field to determine if it's an enum
- */
-function analyzeField(fieldName, value) {
-    if (value === undefined || value === null) {
-        return null;
-    }
-    // Handle array values
-    if (Array.isArray(value)) {
-        const firstNonNullValue = value.find((v) => v !== null && v !== undefined);
-        if (firstNonNullValue && typeof firstNonNullValue === 'string') {
-            const enumInfo = detectEnumType(fieldName, firstNonNullValue);
-            if (enumInfo) {
-                return {
-                    fieldName,
-                    enumName: enumInfo.name,
-                    isOptional: false,
-                    isArray: true,
-                };
-            }
-        }
-        return null;
-    }
-    // Handle string values (potential enums)
-    if (typeof value === 'string') {
-        const enumInfo = detectEnumType(fieldName, value);
-        if (enumInfo) {
-            return {
-                fieldName,
-                enumName: enumInfo.name,
-                isOptional: false,
-                isArray: false,
-            };
-        }
-    }
-    return null;
-}
-/**
- * Detects the enum type for a field based on field name patterns and value analysis
- */
-function detectEnumType(fieldName, value) {
-    // Strategy 1: Direct field name to enum name mapping
-    const directMapping = getDirectEnumMapping(fieldName);
-    if (directMapping) {
-        const enumObject = enumRegistry.getEnum(directMapping);
-        if (enumObject) {
-            // If we have a confident field mapping, use it even if value doesn't match
-            // This allows validation to catch invalid values
-            return { enum: enumObject, name: directMapping };
-        }
-    }
-    // Strategy 2: Find enum by value (exact match)
-    const enumByValue = enumRegistry.findEnumByValue(value);
-    if (enumByValue) {
-        return enumByValue;
-    }
-    // Strategy 3: Find enum by value with prefix normalization
-    const enumByValueWithPrefix = findEnumWithPrefixHandling(value);
-    if (enumByValueWithPrefix) {
-        return enumByValueWithPrefix;
-    }
-    // Strategy 4: Find enum by key (treating value as a potential key)
-    const enumByKey = enumRegistry.findEnumByKey(value);
-    if (enumByKey) {
-        return enumByKey;
-    }
-    return null;
-}
-/**
- * Common enum prefixes that can be automatically added or removed
- * Now sourced from auto-generated analysis of OpenAPI enums
- */
-// Sort prefixes by length (longest first) to prevent collision issues
-// This ensures that "OTHER_ACTIVITY_" is checked before "OTHER_"
-const ENUM_PREFIXES = [...enumPrefixes_1.GENERATED_ENUM_PREFIXES].sort((a, b) => b.length - a.length);
-/**
- * Finds an enum that matches the value with intelligent prefix handling
- */
-function findEnumWithPrefixHandling(value) {
-    const normalizedValue = (0, enumHelpers_1.normalizeEnumValue)(value);
-    // Try to find enums where adding common prefixes makes a match
-    for (const enumName of enumRegistry.getAllEnumNames()) {
-        const enumObject = enumRegistry.getEnum(enumName);
-        if (!enumObject)
-            continue;
-        const enumValues = Object.values(enumObject);
-        // Check if any enum value matches when we add a prefix to the input
-        for (const prefix of ENUM_PREFIXES) {
-            const prefixedValue = `${prefix}${normalizedValue}`;
-            if (enumValues.includes(prefixedValue)) {
-                return { enum: enumObject, name: enumName };
-            }
-        }
-        // Check if any enum value matches when we remove a prefix from enum values
-        for (const enumValue of enumValues) {
-            for (const prefix of ENUM_PREFIXES) {
-                if (enumValue.startsWith(prefix)) {
-                    const unprefixedEnumValue = enumValue.substring(prefix.length);
-                    if (unprefixedEnumValue === normalizedValue) {
-                        return { enum: enumObject, name: enumName };
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}
-/**
- * Enhanced enum validation that handles prefix normalization
- */
-function validateEnumValueWithPrefix(enumObject, value) {
-    const normalizedInput = (0, enumHelpers_1.normalizeEnumValue)(value);
-    // Direct value match (no prefix handling needed)
-    if (Object.values(enumObject).includes(normalizedInput)) {
-        return { valid: true, normalizedValue: normalizedInput };
-    }
-    // Key-based lookup (no prefix handling needed)
-    for (const [key, enumValue] of Object.entries(enumObject)) {
-        if ((0, enumHelpers_1.normalizeEnumValue)(key) === normalizedInput) {
-            return { valid: true, normalizedValue: enumValue };
-        }
-    }
-    // Prefix-aware validation
-    const enumValues = Object.values(enumObject);
-    // Try adding prefixes to the input value
-    for (const prefix of ENUM_PREFIXES) {
-        const prefixedValue = `${prefix}${normalizedInput}`;
-        if (enumValues.includes(prefixedValue)) {
-            return { valid: true, normalizedValue: prefixedValue };
-        }
-    }
-    // Try removing prefixes from enum values to match input
-    for (const enumValue of enumValues) {
-        for (const prefix of ENUM_PREFIXES) {
-            if (enumValue.startsWith(prefix)) {
-                const unprefixedEnumValue = enumValue.substring(prefix.length);
-                if (unprefixedEnumValue === normalizedInput) {
-                    return { valid: true, normalizedValue: enumValue };
-                }
-            }
-        }
-    }
-    return {
-        valid: false,
-        error: `No match found for "${value}" (tried with/without prefixes)`,
-    };
-}
-/**
- * Maps common field names to their corresponding enum types
- */
-function getDirectEnumMapping(fieldName) {
-    const fieldNameLower = fieldName.toLowerCase();
-    // First try dynamic enum name matching
-    const dynamicMatch = findEnumByFieldName(fieldNameLower);
-    if (dynamicMatch) {
-        return dynamicMatch;
-    }
-    // Fall back to essential manual mappings for common patterns that don't follow naming conventions
-    // These should be conservative and only include non-ambiguous cases
-    const essentialMappings = {
-        // Common trading/order fields (most frequent use case)
-        side: 'OrderSide',
-        status: 'OrderStatus', // Default to OrderStatus, validation will catch mismatches
-        role: 'UserRole',
-        action: 'Action',
-        direction: 'SortDirection',
-        // Specific compound fields to prevent wrong mappings
-        orderside: 'OrderSide',
-        ordertype: 'OrderType',
-        orderstatus: 'OrderStatus',
-        wallettype: 'WalletType',
-        transactiontype: 'TransactionType',
-        activitytype: 'CustodyActivityType',
-        activitystatus: 'ActivityStatus',
-        // Note: 'type' still removed (too ambiguous - let value-based detection handle it)
-    };
-    return essentialMappings[fieldNameLower] || null;
-}
-/**
- * Generate intelligent field name variations for plural/singular matching
- */
-function getFieldNameVariations(fieldName) {
-    const variations = [fieldName];
-    // Handle irregular plurals and common patterns
-    const irregularPlurals = {
-        categories: 'category',
-        statuses: 'status',
-        activities: 'activity',
-        entities: 'entity',
-        currencies: 'currency',
-        portfolios: 'portfolio',
-    };
-    const irregularSingulars = {
-        category: 'categories',
-        status: 'statuses',
-        activity: 'activities',
-        entity: 'entities',
-        currency: 'currencies',
-        portfolio: 'portfolios',
-    };
-    // Check irregular mappings first
-    if (irregularPlurals[fieldName]) {
-        variations.push(irregularPlurals[fieldName]);
-    }
-    if (irregularSingulars[fieldName]) {
-        variations.push(irregularSingulars[fieldName]);
-    }
-    // Handle regular -s plurals only if not already handled by irregular rules
-    if (!irregularPlurals[fieldName] && !irregularSingulars[fieldName]) {
-        if (fieldName.endsWith('s') && fieldName.length > 3) {
-            // Only remove 's' if it's likely a regular plural (not words ending in 's')
-            const withoutS = fieldName.slice(0, -1);
-            // Avoid false positives like "address" → "addres"
-            if (!fieldName.endsWith('ss') && !fieldName.endsWith('us')) {
-                variations.push(withoutS);
-            }
-        }
-        else {
-            // Add regular plural
-            variations.push(fieldName + 's');
-        }
-    }
-    return variations;
-}
-/**
- * Check if a value is valid for a specific enum (includes normalization)
- */
-function isValueValidForEnum(value, enumObject) {
-    if (!value || !enumObject)
-        return false;
-    // Direct value match
-    if (Object.values(enumObject).includes(value))
-        return true;
-    // Direct key match
-    if (Object.keys(enumObject).includes(value))
-        return true;
-    // Normalized value matches
-    const normalizedValue = (0, enumHelpers_1.normalizeEnumValue)(value);
-    if (Object.values(enumObject).includes(normalizedValue))
-        return true;
-    // Check with prefix normalization
-    for (const prefix of ENUM_PREFIXES) {
-        const withPrefix = `${prefix}${normalizedValue}`;
-        if (Object.values(enumObject).includes(withPrefix))
-            return true;
-    }
-    return false;
-}
-/**
- * Find enum with context awareness to resolve collisions
- * Handles cases where multiple enums could match (e.g., ActivityStatus vs OrderStatus vs TransactionStatus)
- */
-function findEnumWithContext(fieldName, allEnumNames) {
-    // Handle ambiguous suffixes that appear in multiple enums
-    const ambiguousSuffixes = ['status', 'type', 'category'];
-    const fieldLower = fieldName.toLowerCase();
-    // Check if this is an ambiguous field name
-    const isAmbiguous = ambiguousSuffixes.some((suffix) => fieldLower.endsWith(suffix) || fieldLower === suffix);
-    if (isAmbiguous) {
-        // For ambiguous cases, look for context clues in the field name
-        const contextClues = extractContextClues(fieldName);
-        // Find enum that best matches the context
-        const matches = allEnumNames.filter((enumName) => {
-            const enumLower = enumName.toLowerCase();
-            // Exact compound match (e.g., "activitystatus" → "ActivityStatus")
-            if (enumLower === fieldLower)
-                return true;
-            // Context-based matching
-            for (const clue of contextClues) {
-                if (enumLower.includes(clue) &&
-                    enumLower.endsWith(fieldLower.split(/(?=[a-z])/).pop() || '')) {
-                    return true;
-                }
-            }
-            return false;
-        });
-        // Return the most specific match
-        if (matches.length === 1) {
-            return matches[0];
-        }
-        // If multiple matches, prefer the longest/most specific one
-        if (matches.length > 1) {
-            return matches.reduce((longest, current) => current.length > longest.length ? current : longest);
-        }
-    }
-    // Non-ambiguous cases: use careful substring matching
-    // Sort enums by name length (shortest first) to prefer simpler matches
-    const sortedEnumNames = allEnumNames
-        .slice()
-        .sort((a, b) => a.length - b.length);
-    for (const enumName of sortedEnumNames) {
-        const enumNameLower = enumName.toLowerCase();
-        // Only match if field name is a meaningful part of the enum name
-        // Avoid greedy matches like "side" matching "FcmPositionSide"
-        if (enumNameLower === fieldLower) {
-            return enumName; // Exact match
-        }
-        // Check if field name appears as a word boundary in enum name
-        // e.g., "side" should match "OrderSide" but not "FcmPositionSide"
-        const wordBoundaryRegex = new RegExp(`\\b${fieldLower}\\b`, 'i');
-        if (wordBoundaryRegex.test(enumName)) {
-            return enumName;
-        }
-        // Check for field name at the end of enum name (most common pattern)
-        if (enumNameLower.endsWith(fieldLower) && enumNameLower !== fieldLower) {
-            // Ensure it's not a substring within a word
-            const beforeField = enumNameLower.slice(0, -fieldLower.length);
-            if (beforeField.length > 0 && /[a-z]$/.test(beforeField)) {
-                continue; // Skip if it's part of a word
-            }
-            return enumName;
-        }
-    }
-    return null;
-}
-/**
- * Extract context clues from field names to resolve enum ambiguity
- */
-function extractContextClues(fieldName) {
-    const clues = [];
-    const fieldLower = fieldName.toLowerCase();
-    // Extract prefix context (e.g., "activitystatus" → ["activity"])
-    const prefixMatch = fieldLower.match(/^([a-z]+?)(?:status|type|category)$/);
-    if (prefixMatch) {
-        clues.push(prefixMatch[1]);
-    }
-    // Extract camelCase components (e.g., "activityStatus" → ["activity"])
-    const camelComponents = fieldName
-        .replace(/([A-Z])/g, '_$1')
-        .toLowerCase()
-        .split('_')
-        .filter(Boolean);
-    clues.push(...camelComponents.slice(0, -1)); // Exclude the last component (status/type/category)
-    // Extract underscore/dash separated components
-    const separatedComponents = fieldName.toLowerCase().split(/[_-]+/);
-    clues.push(...separatedComponents.slice(0, -1));
-    return [...new Set(clues)]; // Remove duplicates
-}
-/**
- * Dynamically find enum name based on field name patterns
- * Uses the enum registry to match field names to actual enum names
- */
-function findEnumByFieldName(fieldName) {
-    const allEnumNames = enumRegistry.getAllEnumNames();
-    // Strategy 1: Direct name match (e.g., "ActivityCategory" field → "ActivityCategory" enum)
-    const exactMatch = allEnumNames.find((enumName) => enumName.toLowerCase() === fieldName.toLowerCase());
-    if (exactMatch)
-        return exactMatch;
-    // Strategy 2: Smart plural/singular variations
-    const variations = getFieldNameVariations(fieldName);
-    for (const enumName of allEnumNames) {
-        const enumNameLower = enumName.toLowerCase();
-        if (variations.includes(enumNameLower)) {
-            return enumName;
-        }
-    }
-    // Strategy 3: Context-aware enum matching (handles collisions)
-    const contextMatch = findEnumWithContext(fieldName, allEnumNames);
-    if (contextMatch) {
-        return contextMatch;
-    }
-    // Strategy 4: Smart pattern matching for compound field names
-    // Handle cases like "activitycategory" → "ActivityCategory"
-    for (const enumName of allEnumNames) {
-        const enumWords = enumName
-            .toLowerCase()
-            .replace(/([A-Z])/g, ' $1')
-            .trim()
-            .split(' ');
-        const fieldWords = fieldName
-            .replace(/([A-Z])/g, ' $1')
-            .trim()
-            .split(/[\s_-]+/);
-        // Check if all field words are contained in enum words
-        const allWordsMatch = fieldWords.every((word) => enumWords.some((enumWord) => enumWord.includes(word) || word.includes(enumWord)));
-        if (allWordsMatch && fieldWords.length > 1) {
-            return enumName;
-        }
-    }
-    return null;
-}
-/**
- * Validates and normalizes enum fields in a request object
- */
-function validateRequestEnums(request, options = {}) {
-    const { strict = true, autoNormalize = true } = options;
-    if (!request || typeof request !== 'object') {
-        return { validatedRequest: request, errors: [] };
-    }
-    const validatedRequest = Object.assign({}, request);
-    const errors = [];
-    // Analyze the request to find enum fields
-    const enumFields = analyzeRequestObject(request);
-    // Validate each enum field
-    enumFields.forEach((fieldInfo) => {
-        const { fieldName, enumName, isArray } = fieldInfo;
-        const fieldValue = request[fieldName];
-        if (fieldValue === undefined || fieldValue === null) {
-            return; // Skip undefined/null values
-        }
-        if (!enumName) {
-            return; // Skip if we couldn't determine the enum type
-        }
-        try {
-            if (isArray && Array.isArray(fieldValue)) {
-                // Handle array of enum values
-                const validatedArray = [];
-                fieldValue.forEach((item, index) => {
-                    if (typeof item === 'string') {
-                        const validation = enumRegistry.validateEnumValue(enumName, item);
-                        if (validation.valid && validation.normalizedValue) {
-                            validatedArray.push(autoNormalize ? validation.normalizedValue : item);
-                        }
-                        else if (strict) {
-                            errors.push(`${fieldName}[${index}]: ${validation.error}`);
-                        }
-                    }
-                });
-                if (autoNormalize) {
-                    validatedRequest[fieldName] = validatedArray;
-                }
-            }
-            else if (typeof fieldValue === 'string') {
-                // Handle single enum value
-                const validation = enumRegistry.validateEnumValue(enumName, fieldValue);
-                if (validation.valid && validation.normalizedValue) {
-                    if (autoNormalize) {
-                        validatedRequest[fieldName] = validation.normalizedValue;
-                    }
-                }
-                else if (strict) {
-                    const enumObject = enumRegistry.getEnum(enumName);
-                    if (enumObject) {
-                        throw new DynamicEnumValidationError(fieldName, fieldValue, enumName, Object.values(enumObject), Object.keys(enumObject));
-                    }
-                    else {
-                        errors.push(`${fieldName}: ${validation.error}`);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            if (error instanceof DynamicEnumValidationError) {
-                throw error; // Re-throw enum validation errors
-            }
-            errors.push(`${fieldName}: Unexpected validation error: ${error}`);
-        }
-    });
-    return { validatedRequest, errors };
-}
-/**
- * Simplified validation function that throws on first error
- */
-function validateAndNormalizeRequest(request) {
-    const result = validateRequestEnums(request, {
-        strict: true,
-        autoNormalize: true,
-    });
-    if (result.errors.length > 0) {
-        throw new DynamicEnumValidationError('request', 'multiple fields', 'various', [], result.errors);
-    }
-    return result.validatedRequest;
-}
-const defaultConfig = {
-    enabled: true,
-    strict: true,
-    autoNormalize: true,
-    logWarnings: true,
-};
-let globalConfig = Object.assign({}, defaultConfig);
-/**
- * Set global dynamic validation configuration
- */
-function setDynamicValidationConfig(config) {
-    globalConfig = Object.assign(Object.assign({}, globalConfig), config);
-}
-/**
- * Get current dynamic validation configuration
- */
-function getDynamicValidationConfig() {
-    return Object.assign({}, globalConfig);
-}
-/**
- * Type-safe dynamic enum validation function
- *
- * Automatically validates and normalizes enum values in request objects
- * using the auto-generated prefix patterns from the OpenAPI specification.
- *
- * @param request - The request object to validate and normalize
- * @param config - Optional validation configuration
- * @returns The validated request with normalized enum values
- *
- * @example
- * ```typescript
- * const validated = dynamicValidateRequest<CreateOrderRequest>({
- *   portfolioId: 'portfolio-123',
- *   side: 'buy',      // → 'BUY'
- *   type: 'market'    // → 'MARKET'
- * });
- * ```
- */
-function dynamicValidateRequest(request, config) {
-    const effectiveConfig = Object.assign(Object.assign({}, globalConfig), config);
-    if (!effectiveConfig.enabled) {
-        return request;
-    }
-    try {
-        return validateAndNormalizeRequest(request);
-    }
-    catch (error) {
-        if (!effectiveConfig.strict &&
-            error instanceof DynamicEnumValidationError) {
-            if (effectiveConfig.logWarnings) {
-                console.warn(`[Prime SDK] Dynamic enum validation warning: ${error.message}`);
-            }
-            return request; // Return original request with warning
-        }
-        throw error;
-    }
-}
-/**
- * Utility function to get information about available enums
- */
-function getEnumInfo() {
-    const enumNames = enumRegistry.getAllEnumNames();
-    const enumDetails = {};
-    enumNames.forEach((name) => {
-        const enumObject = enumRegistry.getEnum(name);
-        if (enumObject) {
-            enumDetails[name] = {
-                values: Object.values(enumObject),
-                keys: Object.keys(enumObject),
-            };
-        }
-    });
-    return {
-        enumNames,
-        totalEnums: enumNames.length,
-        enumDetails,
-    };
-}