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

package/dist/shared/enumHelpers.js

@@ -0,0 +1,219 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEnumValue = normalizeEnumValue;
+exports.getEnumValue = getEnumValue;
+exports.requireEnumValue = requireEnumValue;
+exports.isValidEnumValue = isValidEnumValue;
+exports.getEnumValues = getEnumValues;
+exports.getEnumKeys = getEnumKeys;
+exports.validateEnumPrefix = validateEnumPrefix;
+exports.transformEnumValue = transformEnumValue;
+/**
+ * Enum transformation utilities for JavaScript developers.
+ * These helpers make it easier to work with enums by providing:
+ * - Case-insensitive enum lookups
+ * - CamelCase to SNAKE_CASE conversion
+ * - Enum validation with helpful error messages
+ * - Support for prefix-aware transformations
+ */
+/**
+ * Converts a string from various formats to the expected enum value format (SCREAMING_SNAKE_CASE)
+ *
+ * @param input - The input string in any case format
+ * @returns The normalized SCREAMING_SNAKE_CASE string
+ *
+ * @example
+ * normalizeEnumValue('buy') // 'BUY'
+ * normalizeEnumValue('marketOrder') // 'MARKET_ORDER'
+ * normalizeEnumValue('STOP_LIMIT') // 'STOP_LIMIT'
+ * normalizeEnumValue('Order_Type_Market') // 'ORDER_TYPE_MARKET'
+ */
+function normalizeEnumValue(input) {
+    if (!input || typeof input !== 'string') {
+        throw new Error('Input must be a non-empty string');
+    }
+    return (input
+        // Convert camelCase to snake_case
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        // Handle existing underscores and hyphens
+        .replace(/[-\s]+/g, '_')
+        // Convert to uppercase
+        .toUpperCase()
+        // Clean up multiple underscores
+        .replace(/_+/g, '_')
+        // Remove leading/trailing underscores
+        .replace(/^_+|_+$/g, ''));
+}
+/**
+ * Safely gets an enum value by normalizing the input and checking if it exists
+ *
+ * @param enumObject - The enum object to search in
+ * @param input - The input value to normalize and find
+ * @param enumName - Optional enum name for better error messages
+ * @returns The matching enum value or undefined if not found
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumValue(OrderSide, 'buy') // OrderSide.Buy
+ * getEnumValue(OrderSide, 'BUY') // OrderSide.Buy
+ * getEnumValue(OrderSide, 'invalid') // undefined
+ */
+function getEnumValue(enumObject, input, enumName) {
+    if (!input || typeof input !== 'string') {
+        return undefined;
+    }
+    const normalizedInput = normalizeEnumValue(input);
+    // Direct value match (input is already the enum value)
+    if (Object.values(enumObject).includes(normalizedInput)) {
+        return normalizedInput;
+    }
+    // Key-based lookup (find enum key that matches)
+    for (const [key, value] of Object.entries(enumObject)) {
+        if (normalizeEnumValue(key) === normalizedInput) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Gets an enum value with strict validation, throwing an error if not found
+ *
+ * @param enumObject - The enum object to search in
+ * @param input - The input value to normalize and find
+ * @param enumName - Optional enum name for better error messages
+ * @returns The matching enum value
+ * @throws Error if the enum value is not found
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * requireEnumValue(OrderSide, 'buy') // OrderSide.Buy
+ * requireEnumValue(OrderSide, 'invalid') // throws Error
+ */
+function requireEnumValue(enumObject, input, enumName) {
+    const result = getEnumValue(enumObject, input, enumName);
+    if (result === undefined) {
+        const enumNameStr = enumName || 'Enum';
+        const validValues = Object.values(enumObject).join(', ');
+        const validKeys = Object.keys(enumObject).join(', ');
+        throw new Error(`Invalid ${enumNameStr} value: "${input}". ` +
+            `Valid values: ${validValues}. ` +
+            `Valid keys: ${validKeys}.`);
+    }
+    return result;
+}
+/**
+ * Checks if a string is a valid enum value (case-insensitive)
+ *
+ * @param enumObject - The enum object to check against
+ * @param input - The input value to validate
+ * @returns True if the input is a valid enum value
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * isValidEnumValue(OrderSide, 'buy') // true
+ * isValidEnumValue(OrderSide, 'BUY') // true
+ * isValidEnumValue(OrderSide, 'invalid') // false
+ */
+function isValidEnumValue(enumObject, input) {
+    return getEnumValue(enumObject, input) !== undefined;
+}
+/**
+ * Gets all possible enum values as an array
+ *
+ * @param enumObject - The enum object
+ * @returns Array of all enum values
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumValues(OrderSide) // ['BUY', 'SELL']
+ */
+function getEnumValues(enumObject) {
+    return Object.values(enumObject);
+}
+/**
+ * Gets all possible enum keys as an array
+ *
+ * @param enumObject - The enum object
+ * @returns Array of all enum keys
+ *
+ * @example
+ * import { OrderSide } from '../model/enums/OrderSide';
+ *
+ * getEnumKeys(OrderSide) // ['Buy', 'Sell']
+ */
+function getEnumKeys(enumObject) {
+    return Object.keys(enumObject);
+}
+/**
+ * Validates that a string has the correct prefix for enum values
+ * Useful for ensuring enum values follow expected patterns
+ *
+ * @param input - The enum value to check
+ * @param expectedPrefix - The expected prefix (e.g., 'ORDER_TYPE_', 'ACTIVITY_TYPE_')
+ * @param strict - If true, requires exact prefix match. If false, allows values without prefix
+ * @returns True if the prefix is correct
+ *
+ * @example
+ * validateEnumPrefix('ORDER_TYPE_MARKET', 'ORDER_TYPE_') // true
+ * validateEnumPrefix('MARKET', 'ORDER_TYPE_', false) // true (non-strict)
+ * validateEnumPrefix('MARKET', 'ORDER_TYPE_', true) // false (strict)
+ */
+function validateEnumPrefix(input, expectedPrefix, strict = false) {
+    if (!input || !expectedPrefix) {
+        return false;
+    }
+    const normalizedInput = normalizeEnumValue(input);
+    const normalizedPrefix = normalizeEnumValue(expectedPrefix);
+    if (strict) {
+        return normalizedInput.startsWith(normalizedPrefix);
+    }
+    // Non-strict: allow values with or without prefix
+    return (normalizedInput.startsWith(normalizedPrefix) ||
+        !normalizedInput.includes('_') ||
+        normalizedInput ===
+            normalizeEnumValue(input.replace(new RegExp(`^${expectedPrefix}`, 'i'), '')));
+}
+/**
+ * Transforms enum input to the correct format, optionally adding a prefix
+ *
+ * @param input - The input string
+ * @param prefix - Optional prefix to add if not present
+ * @returns The transformed enum value
+ *
+ * @example
+ * transformEnumValue('market', 'ORDER_TYPE_') // 'ORDER_TYPE_MARKET'
+ * transformEnumValue('ORDER_TYPE_MARKET', 'ORDER_TYPE_') // 'ORDER_TYPE_MARKET'
+ * transformEnumValue('marketOrder') // 'MARKET_ORDER'
+ */
+function transformEnumValue(input, prefix) {
+    const normalized = normalizeEnumValue(input);
+    if (!prefix) {
+        return normalized;
+    }
+    const normalizedPrefix = normalizeEnumValue(prefix);
+    // If already has the prefix, return as-is
+    if (normalized.startsWith(normalizedPrefix)) {
+        return normalized;
+    }
+    // Add prefix
+    return `${normalizedPrefix}${normalized}`;
+}

package/dist/shared/enumRegistry.js

@@ -0,0 +1,153 @@
+"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.EnumRegistry = void 0;
+/**
+ * Central registry for managing and discovering TypeScript enums
+ */
+// Import all enums dynamically
+const AllEnums = __importStar(require("../model/enums/"));
+/**
+ * Registry for managing discovered enums and providing lookup capabilities
+ */
+class EnumRegistry {
+    constructor() {
+        this.enums = new Map();
+        this.enumsByValue = new Map();
+        this.enumsByKey = new Map();
+        this.populateEnums();
+    }
+    /**
+     * Automatically discover and register all enums from the model/enums directory
+     */
+    populateEnums() {
+        Object.entries(AllEnums).forEach(([enumName, enumObject]) => {
+            if (this.isValidEnum(enumObject)) {
+                this.enums.set(enumName, enumObject);
+                this.indexEnumValues(enumName, enumObject);
+            }
+        });
+    }
+    /**
+     * Check if an object is a valid TypeScript enum
+     */
+    isValidEnum(obj) {
+        return (obj &&
+            typeof obj === 'object' &&
+            Object.values(obj).every((value) => typeof value === 'string'));
+    }
+    /**
+     * Index enum values and keys for fast lookup
+     */
+    indexEnumValues(enumName, enumObject) {
+        Object.entries(enumObject).forEach(([key, value]) => {
+            // Index by value (e.g., "BUY" -> OrderSide)
+            this.enumsByValue.set(value.toLowerCase(), {
+                enum: enumObject,
+                name: enumName,
+            });
+            // Index by key (e.g., "Buy" -> OrderSide)
+            this.enumsByKey.set(key.toLowerCase(), {
+                enum: enumObject,
+                name: enumName,
+            });
+        });
+    }
+    /**
+     * Get a specific enum by name
+     */
+    getEnum(enumName) {
+        return this.enums.get(enumName) || null;
+    }
+    /**
+     * Get all registered enum names
+     */
+    getAllEnumNames() {
+        return Array.from(this.enums.keys());
+    }
+    /**
+     * Find enum by value (exact match)
+     */
+    findEnumByValue(value) {
+        return this.enumsByValue.get(value.toLowerCase()) || null;
+    }
+    /**
+     * Find enum by key (exact match)
+     */
+    findEnumByKey(key) {
+        return this.enumsByKey.get(key.toLowerCase()) || null;
+    }
+    /**
+     * Get statistics about discovered enums
+     */
+    getStats() {
+        return {
+            totalEnums: this.enums.size,
+            totalValues: this.enumsByValue.size,
+            totalKeys: this.enumsByKey.size,
+        };
+    }
+    /**
+     * Get detailed information about all enums
+     */
+    getEnumDetails() {
+        const details = {};
+        this.enums.forEach((enumObject, enumName) => {
+            details[enumName] = {
+                values: Object.values(enumObject),
+                keys: Object.keys(enumObject),
+            };
+        });
+        return details;
+    }
+}
+exports.EnumRegistry = EnumRegistry;
+// Global singleton instance
+exports.enumRegistry = new EnumRegistry();

package/dist/shared/enumValidationCore.js

@@ -0,0 +1,194 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicEnumValidationError = void 0;
+exports.isValueValidForEnum = isValueValidForEnum;
+exports.detectEnumType = detectEnumType;
+exports.analyzeField = analyzeField;
+exports.validateEnumValue = validateEnumValue;
+/**
+ * Core validation logic for enum fields
+ */
+const enumHelpers_1 = require("./enumHelpers");
+const enumPrefixes_1 = require("../model/enumPrefixes");
+const enumRegistry_1 = require("./enumRegistry");
+const fieldMapping_1 = require("./fieldMapping");
+// Sort prefixes by length (longest first) to prevent collision issues
+const ENUM_PREFIXES = [...enumPrefixes_1.GENERATED_ENUM_PREFIXES].sort((a, b) => b.length - a.length);
+/**
+ * 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;
+/**
+ * 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;
+}
+/**
+ * Detects the enum type for a field based on field name patterns and value analysis
+ */
+function detectEnumType(fieldName, value, serviceName) {
+    // Strategy 1: Direct field name to enum name mapping (with service context)
+    const directMapping = (0, fieldMapping_1.getDirectEnumMapping)(fieldName, serviceName);
+    if (directMapping) {
+        const enumObject = enumRegistry_1.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_1.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_1.enumRegistry.findEnumByKey(value);
+    if (enumByKey) {
+        return enumByKey;
+    }
+    return null;
+}
+/**
+ * Find enum by value with automatic prefix handling
+ */
+function findEnumWithPrefixHandling(value) {
+    const normalizedValue = (0, enumHelpers_1.normalizeEnumValue)(value);
+    // Try each prefix
+    for (const prefix of ENUM_PREFIXES) {
+        const prefixedValue = `${prefix}${normalizedValue}`;
+        const enumByPrefixedValue = enumRegistry_1.enumRegistry.findEnumByValue(prefixedValue);
+        if (enumByPrefixedValue) {
+            return enumByPrefixedValue;
+        }
+    }
+    return null;
+}
+/**
+ * Analyzes a single field to determine if it's an enum
+ */
+function analyzeField(fieldName, value, serviceName) {
+    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, serviceName);
+            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, serviceName);
+        if (enumInfo) {
+            return {
+                fieldName,
+                enumName: enumInfo.name,
+                isOptional: false,
+                isArray: false,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Validate and normalize a single enum value
+ */
+function validateEnumValue(value, enumObject, enumName, fieldName, config) {
+    // Direct value match
+    if (Object.values(enumObject).includes(value)) {
+        return { isValid: true, normalizedValue: value };
+    }
+    // Direct key match (convert key to value)
+    const keyEntry = Object.entries(enumObject).find(([key]) => key === value);
+    if (keyEntry) {
+        return { isValid: true, normalizedValue: keyEntry[1] };
+    }
+    if (config.autoNormalize) {
+        // Try normalized value
+        const normalizedValue = (0, enumHelpers_1.normalizeEnumValue)(value);
+        if (Object.values(enumObject).includes(normalizedValue)) {
+            return { isValid: true, normalizedValue };
+        }
+        // Try with prefix normalization
+        for (const prefix of ENUM_PREFIXES) {
+            const withPrefix = `${prefix}${normalizedValue}`;
+            if (Object.values(enumObject).includes(withPrefix)) {
+                return { isValid: true, normalizedValue: withPrefix };
+            }
+        }
+        // Try case-insensitive key match
+        const normalizedKey = Object.keys(enumObject).find((key) => key.toLowerCase() === value.toLowerCase());
+        if (normalizedKey) {
+            return { isValid: true, normalizedValue: enumObject[normalizedKey] };
+        }
+    }
+    // Value is invalid
+    const error = `Invalid ${fieldName} (${enumName}): "${value}". Valid values: ${Object.values(enumObject).join(', ')}. Valid keys: ${Object.keys(enumObject).join(', ')}.`;
+    return { isValid: false, error };
+}

package/dist/shared/enumValidators.js

@@ -0,0 +1,115 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEnumFormat = exports.TransactionEnums = exports.OrderEnums = void 0;
+exports.createEnumValidators = createEnumValidators;
+/**
+ * Convenient enum validators for common Prime API enums.
+ * These provide pre-configured validation for frequently used enum types.
+ *
+ * Note: Most users should use the dynamic validation system instead, which
+ * automatically handles all enums. These validators are useful for explicit
+ * control or when you need to validate individual enum values.
+ */
+const enumHelpers_1 = require("./enumHelpers");
+Object.defineProperty(exports, "toEnumFormat", { enumerable: true, get: function () { return enumHelpers_1.normalizeEnumValue; } });
+// Import specific enums for validation
+const OrderType_1 = require("../model/enums/OrderType");
+const OrderSide_1 = require("../model/enums/OrderSide");
+const OrderStatus_1 = require("../model/enums/OrderStatus");
+const TransactionType_1 = require("../model/enums/TransactionType");
+const TimeInForceType_1 = require("../model/enums/TimeInForceType");
+/**
+ * Order-related enum helpers
+ */
+exports.OrderEnums = {
+    /**
+     * Validates and normalizes order type values
+     * Accepts: 'market', 'limit', 'twap', 'block', 'vwap', 'stopLimit', 'rfq' (case-insensitive)
+     */
+    getOrderType: (input) => (0, enumHelpers_1.getEnumValue)(OrderType_1.OrderType, input, 'OrderType'),
+    requireOrderType: (input) => (0, enumHelpers_1.requireEnumValue)(OrderType_1.OrderType, input, 'OrderType'),
+    isValidOrderType: (input) => (0, enumHelpers_1.isValidEnumValue)(OrderType_1.OrderType, input),
+    /**
+     * Validates and normalizes order side values
+     * Accepts: 'buy', 'sell' (case-insensitive)
+     */
+    getOrderSide: (input) => (0, enumHelpers_1.getEnumValue)(OrderSide_1.OrderSide, input, 'OrderSide'),
+    requireOrderSide: (input) => (0, enumHelpers_1.requireEnumValue)(OrderSide_1.OrderSide, input, 'OrderSide'),
+    isValidOrderSide: (input) => (0, enumHelpers_1.isValidEnumValue)(OrderSide_1.OrderSide, input),
+    /**
+     * Validates and normalizes order status values
+     * Accepts: 'open', 'filled', 'cancelled', 'expired', 'failed', 'pending' (case-insensitive)
+     */
+    getOrderStatus: (input) => (0, enumHelpers_1.getEnumValue)(OrderStatus_1.OrderStatus, input, 'OrderStatus'),
+    requireOrderStatus: (input) => (0, enumHelpers_1.requireEnumValue)(OrderStatus_1.OrderStatus, input, 'OrderStatus'),
+    isValidOrderStatus: (input) => (0, enumHelpers_1.isValidEnumValue)(OrderStatus_1.OrderStatus, input),
+    /**
+     * Validates and normalizes time in force type values
+     * Accepts: 'good_until_cancelled', 'good_until_time', 'immediate_or_cancel', 'fill_or_kill' (case-insensitive)
+     */
+    getTimeInForceType: (input) => (0, enumHelpers_1.getEnumValue)(TimeInForceType_1.TimeInForceType, input, 'TimeInForceType'),
+    requireTimeInForceType: (input) => (0, enumHelpers_1.requireEnumValue)(TimeInForceType_1.TimeInForceType, input, 'TimeInForceType'),
+    isValidTimeInForceType: (input) => (0, enumHelpers_1.isValidEnumValue)(TimeInForceType_1.TimeInForceType, input),
+};
+/**
+ * Transaction-related enum helpers
+ */
+exports.TransactionEnums = {
+    /**
+     * Validates and normalizes transaction type values
+     * Accepts various transaction types like 'deposit', 'withdrawal', 'internalDeposit', etc. (case-insensitive)
+     */
+    getTransactionType: (input) => (0, enumHelpers_1.getEnumValue)(TransactionType_1.TransactionType, input, 'TransactionType'),
+    requireTransactionType: (input) => (0, enumHelpers_1.requireEnumValue)(TransactionType_1.TransactionType, input, 'TransactionType'),
+    isValidTransactionType: (input) => (0, enumHelpers_1.isValidEnumValue)(TransactionType_1.TransactionType, input),
+};
+/**
+ * Utility for creating custom enum validators for any enum type
+ *
+ * @param enumObject - The enum object to create validators for
+ * @param enumName - Name of the enum for error messages
+ * @returns Object with validation methods
+ *
+ * @example
+ * import { WalletType } from '../model/enums/WalletType';
+ *
+ * const WalletValidators = createEnumValidators(WalletType, 'WalletType');
+ * WalletValidators.get('trading'); // Gets WalletType value
+ * WalletValidators.require('custody'); // Gets WalletType value or throws
+ * WalletValidators.isValid('invalid'); // false
+ */
+function createEnumValidators(enumObject, enumName) {
+    return {
+        get: (input) => (0, enumHelpers_1.getEnumValue)(enumObject, input, enumName),
+        require: (input) => (0, enumHelpers_1.requireEnumValue)(enumObject, input, enumName),
+        isValid: (input) => (0, enumHelpers_1.isValidEnumValue)(enumObject, input),
+        values: Object.values(enumObject),
+        keys: Object.keys(enumObject),
+    };
+}
+/**
+ * @deprecated Use the dynamic validation system instead.
+ *
+ * Most users should prefer:
+ * ```javascript
+ * import { dynamicValidateRequest } from '@coinbase/prime-sdk';
+ * const validated = dynamicValidateRequest(request);
+ * ```
+ *
+ * This provides automatic validation for all enum fields without manual configuration.
+ */