@coinbase-sample/prime-sdk-ts 0.6.2 → 0.6.4

package/dist/shared/dynamicEnumValidation.old.js

@@ -0,0 +1,746 @@
+"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,
+    };
+}