@wildo-ai/saas-models 1.0.1

package/dist/esm/resources/utils/resources-config-operations.dtos-builder.utils.js

@@ -0,0 +1,2180 @@
+import { z } from 'zod';
+import { CoreResourceOperation } from '../resources.shared.core.definitions.js';
+import { Resouces_BulkOperationBaseSchema, DataMode, OPERATION_VARIANT_KEY, Resouces_PaginationResponseMetadataSchema, getChildDirectionRelationships, getParentDirectionRelationships } from '../resources-config.shared.schemas.js';
+import { ResourceRelationshipCardinality, isOneToOneCardinality, isArrayCardinality, getDefaultResponseSchemaForOperation, operationShouldHaveRequestDto, DefaultBulkDeleteResponseSchema } from '../resources.shared.schemas.js';
+import { Resources_SharedUtils } from '../resources.shared.utils.js';
+import { getCustomFieldMetadata, ZodDecorator, getZodType, hasZodType, isZodObject, isZodArray, isZodOptional, isZodDefault, getZodObjectShape, getZodDefSchemaProperty, getZodDefArrayProperty, getZodDefStringProperty, getZodDefProperty, isZodTypeAny, getEnumValues, isExcludedFromCreate, isExcludedFromUpdate, isVirtualField, isPrimaryKey, isBackendOnlyField, getBackendOnlyParams, isDiscriminatorField, unwrapSchema } from '@wildo-ai/zod-decorators';
+import { ResourcesSummaryUtils } from './resources-summary.utils.js';
+import { RepositoryDtoBuilderUtils } from './repository-dto-builder.utils.js';
+/**
+ * Type guard to check if schema is a ZodAny
+ * In Zod v4, any schemas have type: "any"
+ */
+function isZodAny(schema) {
+    return hasZodType(schema, 'any');
+}
+export class ResourcesConfigOperationsDtosBuilderUtils {
+    /**
+     * Rebuild an object schema, optionally preserving schema-level checks.
+     *
+     * DTO derivation frequently needs to rebuild object shapes for omission,
+     * backend-only stripping, and date coercion. In Zod 4 those rebuilds would
+     * otherwise discard `.refine()` / `.superRefine()` checks. Preserve them when
+     * the field set stays semantically equivalent; skip them when fields were
+     * omitted because the original cross-field logic may no longer be valid.
+     */
+    static rebuildObjectSchema(schema, rebuiltShape, options) {
+        let rebuiltSchema = z.object(rebuiltShape);
+        if (options?.preserveChecks === false) {
+            return rebuiltSchema;
+        }
+        const checks = getZodDefArrayProperty(schema, 'checks');
+        for (const check of checks ?? []) {
+            rebuiltSchema = rebuiltSchema.check(check);
+        }
+        return rebuiltSchema;
+    }
+    /**
+     * Omit fields from an object schema while staying compatible with Zod 4
+     * refined objects.
+     *
+     * Zod 4 throws when `.omit()` is used on object schemas that already carry
+     * schema-level checks (`.refine()` / `.superRefine()`). DTO derivation must
+     * still be able to remove transport-managed fields from those schemas, so we
+     * fall back to rebuilding the object shape and reapplying the existing checks.
+     */
+    static omitObjectFields(schema, omitObj) {
+        if (Object.keys(omitObj).length === 0) {
+            return schema;
+        }
+        try {
+            return schema.omit(omitObj);
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !error.message.includes('containing refinements')) {
+                throw error;
+            }
+            const originalShape = getZodObjectShape(schema);
+            const rebuiltShape = {};
+            for (const [fieldName, fieldSchema] of Object.entries(originalShape)) {
+                if (!omitObj[fieldName]) {
+                    rebuiltShape[fieldName] = fieldSchema;
+                }
+            }
+            return this.rebuildObjectSchema(schema, rebuiltShape, {
+                preserveChecks: false,
+            });
+        }
+    }
+    /**
+     * Rebuild all operation DTOs once the full registry is available.
+     *
+     * Resource factories only know about their own config at declaration time, so
+     * nested child DTOs cannot be fully derived there. Registry startup is the
+     * authoritative compilation boundary for operation DTOs.
+     */
+    static rebuildResourceConfigurationsOperationDtos(resourceConfigurations) {
+        const resourceRegistry = new Map(Object.entries(resourceConfigurations));
+        for (const config of Object.values(resourceConfigurations)) {
+            config.operations = config.operations.map((operation) => this.buildAllOperationDtos(operation, config, resourceRegistry));
+        }
+    }
+    /**
+     * Build all DTO variants for an operation.
+     * This is the main entry point called by the factory.
+     *
+     * @param operation - Operation configuration
+     * @param resourceConfig - Full resource configuration (for inheritance reference)
+     * @param registry - Resource registry
+     * @returns Operation with all DTOs pre-computed and stored
+     */
+    static buildAllOperationDtos(operation, resourceConfig, registry) {
+        // 1. Apply inheritance to mainSchema (from resourceConfig.inheritenceSchemaDefinition)
+        const inheritenceSchemaDefinition = resourceConfig.inheritenceSchemaDefinition;
+        const enhancedMainSchema = (inheritenceSchemaDefinition
+            ? this.applyInheritanceToSchema(operation.mainSchema, inheritenceSchemaDefinition, new Map())
+            : operation.mainSchema);
+        // Determine the effective operation identifier for DTO building
+        const effectiveOperation = operation.resourceOperationLike || operation.operationIdentifier;
+        // IMPORTANT: Temporary DTOs from factory are built from mainSchema WITHOUT inheritance.
+        // buildEnhancedRequestDto/buildEnhancedResponseDto check for existing DTOs first and
+        // return them if meaningful (line 330, 388), which would skip inheritance application.
+        //
+        // Strategy: Store original DTOs to detect custom ones, then clear temporary DTOs to force
+        // rebuild from enhancedMainSchema (with inheritance). Custom DTOs will be preserved and
+        // only have transformations applied (date coercion), while auto-derived DTOs will be
+        // rebuilt with inheritance and transformations.
+        //
+        // Custom DTOs are detected by comparing the rebuilt DTO structure to the original.
+        // If they're significantly different, we preserve the original (it's custom).
+        // Otherwise, we use the rebuilt one (with inheritance).
+        const originalRequestDto = operation.requestDto;
+        const originalResponseDto = operation.responseDto;
+        const operationWithEnhancedSchema = {
+            ...operation,
+            mainSchema: enhancedMainSchema,
+            requestDto: undefined, // Clear to force rebuild with inheritance
+            responseDto: undefined // Clear to force rebuild with inheritance
+        };
+        // 2. Build requestDto:
+        //    - Rebuild from enhancedMainSchema (with inheritance applied)
+        //    - If original was explicitly provided (custom), preserve it but apply transformations
+        //    - Otherwise use rebuilt DTO (with inheritance)
+        //    - Apply date coercion
+        //    - Backend-only fields already excluded in buildEnhancedRequestDto
+        let requestDto = this.buildEnhancedRequestDto(operationWithEnhancedSchema, effectiveOperation);
+        // Check if original DTO was explicitly provided (custom DTO from variantParams.requestDto)
+        // Custom DTOs are complete schemas that should be preserved as-is, but still need
+        // transformations (date coercion). We detect custom DTOs by checking if they're
+        // significantly different from what would be auto-derived, OR if they're the same
+        // structure but the user explicitly provided them (we can't distinguish this easily,
+        // so we use a heuristic: if different, preserve; if same, use rebuilt with inheritance).
+        const rebuiltRequestInfo = this.analyzeDtoSchema(requestDto);
+        const originalRequestInfo = originalRequestDto ? this.analyzeDtoSchema(originalRequestDto) : null;
+        // If original exists and is significantly different from rebuilt, it's likely custom
+        // Preserve it but apply transformations (date coercion)
+        // Note: Custom DTOs are complete schemas that don't need inheritance - they're provided
+        // as-is by the user. However, they still need date coercion for API communication.
+        if (originalRequestDto && originalRequestInfo &&
+            originalRequestInfo !== rebuiltRequestInfo &&
+            originalRequestInfo !== '📄 {} (empty object)' &&
+            !isZodAny(originalRequestDto)) {
+            // Custom DTO: preserve structure but apply date coercion
+            requestDto = this.applyDateCoercion(originalRequestDto);
+        }
+        else {
+            // Auto-derived DTO: use rebuilt (with inheritance) and apply transformations
+            requestDto = this.applyDateCoercion(requestDto);
+        }
+        // 3. Build responseDto first (repositoryDto depends on it)
+        //    - Rebuild from enhancedMainSchema (with inheritance applied)
+        //    - If original was custom (significantly different), preserve it but apply transformations
+        //    - Otherwise use rebuilt DTO (with inheritance)
+        //    - Strip backend-only fields (except isReturnedAtCreation for CREATE)
+        //    - Apply date coercion
+        //    - Exclude virtual fields (they're computed, not stored)
+        let responseDtoInternal = this.buildEnhancedResponseDto(operationWithEnhancedSchema, effectiveOperation);
+        let responseDto = responseDtoInternal;
+        // Check if original DTO was explicitly provided (custom DTO from customResponseDto)
+        // Custom DTOs are complete schemas that should be preserved as-is, but still need
+        // transformations (backend-only stripping, date coercion).
+        const hasExplicitCustomResponseDto = operation.hasCustomResponseDto === true;
+        const rebuiltResponseInfo = this.analyzeDtoSchema(responseDtoInternal);
+        const originalResponseInfo = originalResponseDto ? this.analyzeDtoSchema(originalResponseDto) : null;
+        // If hasCustomResponseDto flag is set, always preserve the original (skip heuristic).
+        // Otherwise, fall back to analyzeDtoSchema heuristic for backward compatibility.
+        const isCustomResponseDto = hasExplicitCustomResponseDto
+            ? (originalResponseDto && !isZodAny(originalResponseDto))
+            : (originalResponseDto && originalResponseInfo &&
+                originalResponseInfo !== rebuiltResponseInfo &&
+                originalResponseInfo !== '📄 {} (empty object)' &&
+                !isZodAny(originalResponseDto));
+        if (isCustomResponseDto && originalResponseDto) {
+            // Custom DTO: preserve structure but apply transformations
+            // Still need to strip backend-only fields and apply date coercion
+            const isCreateOperation = effectiveOperation === CoreResourceOperation.CREATE ||
+                effectiveOperation === CoreResourceOperation.CREATE_MANY;
+            responseDtoInternal = this.applyDateCoercion(originalResponseDto);
+            responseDto = this.stripBackendOnlyFields(responseDtoInternal, {
+                respectIsReturnedAtCreation: isCreateOperation,
+                operationType: isCreateOperation ? CoreResourceOperation.CREATE : undefined
+            });
+        }
+        else {
+            // Auto-derived DTO: use rebuilt (with inheritance) and apply transformations
+            // Strip backend-only fields (respect isReturnedAtCreation for CREATE)
+            const isCreateOperation = effectiveOperation === CoreResourceOperation.CREATE ||
+                effectiveOperation === CoreResourceOperation.CREATE_MANY;
+            responseDtoInternal = this.applyDateCoercion(responseDtoInternal);
+            responseDto = this.stripBackendOnlyFields(responseDtoInternal, {
+                respectIsReturnedAtCreation: isCreateOperation,
+                operationType: isCreateOperation ? CoreResourceOperation.CREATE : undefined
+            });
+        }
+        // Note: Virtual fields are already excluded in buildEnhancedResponseDto
+        // 4. Add nested operations DTOs if configured (child + self relationships)
+        const resourceRelationships = operation.resourceRelationships;
+        const childDirRels = resourceRelationships ? getChildDirectionRelationships(resourceRelationships) : [];
+        if (childDirRels.length > 0) {
+            // Build request DTO with nested children for create/update operations,
+            // including bulk variants. Runtime bulk orchestration is handled in the
+            // services layer by applying the same nested-processing principles per
+            // parent result.
+            if (effectiveOperation === CoreResourceOperation.CREATE || effectiveOperation === CoreResourceOperation.CREATE_MANY ||
+                effectiveOperation === CoreResourceOperation.UPDATE || effectiveOperation === CoreResourceOperation.UPDATE_MANY) {
+                requestDto = this.buildRequestDtoWithNested(effectiveOperation, requestDto, childDirRels, registry);
+            }
+            // Build response DTO with nested children (for READ)
+            if (effectiveOperation === CoreResourceOperation.READ) {
+                responseDtoInternal = this.buildResponseDtoWithNested(responseDtoInternal, childDirRels, registry);
+                responseDto = this.buildResponseDtoWithNested(responseDto, childDirRels, registry);
+            }
+        }
+        // 5. Build summaryDto (WITH backend-only fields for internal processing):
+        //    - Extract summary fields (isSummaryField)
+        //    - If no summary fields defined, fall back to mainSchema (same as RAW)
+        //    - DO NOT strip backend-only fields yet (needed for repositoryDto)
+        //    - Apply date coercion (already applied in extractSummaryFields)
+        //    - Handle discriminated unions
+        let summaryDtoInternal = this.extractSummaryFields(enhancedMainSchema);
+        // If no summary fields are defined, use full schema (same as RAW mode)
+        // Check if summaryDtoInternal is empty (z.object({}))
+        if (isZodObject(summaryDtoInternal)) {
+            const summaryShape = getZodObjectShape(summaryDtoInternal);
+            if (Object.keys(summaryShape).length === 0) {
+                // No summary fields defined - use full mainSchema as fallback
+                // This ensures SUMMARY mode works even without explicit isSummaryField decorators
+                summaryDtoInternal = this.excludeVirtualFieldsFromSchema(enhancedMainSchema);
+            }
+        }
+        // Build stripped version for frontend (summaryDto)
+        const summaryDto = this.stripBackendOnlyFields(summaryDtoInternal);
+        // Note: Date coercion is already applied in extractSummaryFields
+        // 6. Build contextDto:
+        //    - Start with responseDto
+        //    - Add relationship placeholders
+        //    - Date coercion already applied to responseDto
+        const contextDto = this.addRelationshipPlaceholders(responseDto, operation.resourceRelationships, registry);
+        // 7. Build internalDto base (before variant overrides):
+        //    - Start with mainSchema (with inheritance)
+        //    - Include backend-only fields (DO NOT strip)
+        //    - Exclude virtual fields (they're computed)
+        let internalDtoProcessed = effectiveOperation === CoreResourceOperation.READ
+            ? responseDtoInternal
+            : enhancedMainSchema;
+        // Exclude virtual fields from internalDto
+        if (isZodObject(internalDtoProcessed)) {
+            const shape = getZodObjectShape(internalDtoProcessed);
+            const omitObj = {};
+            for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+                if (isVirtualField(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+            }
+            if (Object.keys(omitObj).length > 0) {
+                internalDtoProcessed = this.omitObjectFields(internalDtoProcessed, omitObj);
+            }
+        }
+        // 8. Build repositoryDto first (before variant overrides):
+        //    - For default operations, derive from responseDto
+        //    - Include backend-only fields (for internal processing)
+        //    - Exclude virtual fields but include their dependencies
+        let repositoryDto = RepositoryDtoBuilderUtils.deriveRepositoryDto(responseDto, enhancedMainSchema);
+        // 9. For default operations (no variantKey), wrap internalDto in pagination for LIST/SEARCH:
+        const isListOrSearch = effectiveOperation === CoreResourceOperation.LIST
+            || effectiveOperation === CoreResourceOperation.SEARCH;
+        if (!operation.variantKey && isListOrSearch) {
+            // Default LIST/SEARCH operations: wrap internalDto in pagination
+            internalDtoProcessed = z.object({
+                data: z.array(internalDtoProcessed),
+                pagination: Resouces_PaginationResponseMetadataSchema
+            });
+        }
+        // 10. Override responseDto, repositoryDto, and internalDto for variant operations:
+        //    - For SUMMARY variants: use summaryDto (wrapped in pagination for LIST/SEARCH)
+        //    - For CONTEXT variants: use contextDto (wrapped in pagination for LIST/SEARCH)
+        //    - For custom variants with customResponseDto: use the custom schema for internalDto too
+        //    - Build repositoryDto from INTERNAL versions (with backend-only fields)
+        //    - Build internalDto for service-layer validation (pagination wrapper with backend-only items)
+        if (operation.variantKey) {
+            if (operation.variantKey === OPERATION_VARIANT_KEY.SUMMARY) {
+                // For SUMMARY variants, build repositoryDto from INTERNAL version (has backend-only fields)
+                repositoryDto = RepositoryDtoBuilderUtils.deriveRepositoryDto(summaryDtoInternal, enhancedMainSchema);
+                if (isListOrSearch) {
+                    // Build internalDto for service-layer validation (pagination wrapper with backend-only items)
+                    internalDtoProcessed = z.object({
+                        data: z.array(summaryDtoInternal),
+                        pagination: Resouces_PaginationResponseMetadataSchema
+                    });
+                    // Wrap summaryDto (frontend version, backend-only stripped) in pagination for responseDto
+                    responseDto = z.object({
+                        data: z.array(summaryDto),
+                        pagination: Resouces_PaginationResponseMetadataSchema
+                    });
+                }
+                else {
+                    // For READ operations, use summaryDto versions
+                    internalDtoProcessed = summaryDtoInternal;
+                    responseDto = summaryDto;
+                }
+            }
+            else if (operation.variantKey === OPERATION_VARIANT_KEY.CONTEXT) {
+                // For CONTEXT variants, build from contextDto versions
+                // contextDto is built from responseDto which already has backend-only stripped, so we need internal version
+                const contextDtoInternal = this.addRelationshipPlaceholders(this.excludeVirtualFieldsFromSchema(enhancedMainSchema), operation.resourceRelationships, registry);
+                repositoryDto = RepositoryDtoBuilderUtils.deriveRepositoryDto(contextDtoInternal, enhancedMainSchema);
+                if (isListOrSearch) {
+                    // Build internalDto for service-layer validation (pagination wrapper with backend-only items)
+                    internalDtoProcessed = z.object({
+                        data: z.array(contextDtoInternal),
+                        pagination: Resouces_PaginationResponseMetadataSchema
+                    });
+                    // Wrap contextDto (frontend version, backend-only stripped) in pagination for responseDto
+                    responseDto = z.object({
+                        data: z.array(contextDto),
+                        pagination: Resouces_PaginationResponseMetadataSchema
+                    });
+                }
+                else {
+                    // For READ operations, use contextDto versions
+                    internalDtoProcessed = contextDtoInternal;
+                    responseDto = contextDto;
+                }
+            }
+            else if (originalResponseDto && !isZodAny(originalResponseDto)) {
+                // For custom variants with customResponseDto (e.g., 'context_old'):
+                // The internalDto should also use the custom schema to preserve enriched fields.
+                // This ensures that custom implementations can return additional fields that won't be stripped.
+                // Apply date coercion to the custom schema for internal processing.
+                internalDtoProcessed = this.applyDateCoercion(originalResponseDto);
+                repositoryDto = RepositoryDtoBuilderUtils.deriveRepositoryDto(originalResponseDto, enhancedMainSchema);
+            }
+        }
+        // 11. Finalize internalDto with date coercion:
+        const internalDtoFinal = this.applyDateCoercion(internalDtoProcessed);
+        // 12. Return operation with all DTOs stored
+        return {
+            ...operation,
+            requestDto,
+            responseDto,
+            summaryDto,
+            contextDto,
+            internalDto: internalDtoFinal,
+            repositoryDto
+        };
+    }
+    /**
+     * Main entry point to build DTOs for all operations of a resource
+     * This replaces the minimal DTOs set during initialization with comprehensive ones
+     *
+     * INHERITANCE APPROACH:
+     * - Inheritance is applied to mainSchema (not relationship cascading)
+     * - Creates discriminated union schemas based on inheritance definitions
+     * - Inheritance logic is transferred to DTO building process
+     *
+     * NOTE: TDatabaseSchema has been removed. Backend-only fields are now marked with
+     * the `isBackendOnly` decorator on mainSchema and stripped at the service layer.
+     *
+     * IMPORTANT: Each operation represents ONE flattened variant, not multiple variants
+     */
+    static buildOperationDtos(operations, resourceRegistry, // Full resource registry for cross-references
+    processedInheritanceSchemas = new Map() // Cache for inheritance schemas
+    ) {
+        // Process each flattened operation individually
+        const enhancedOperations = operations.map((operation, index) => {
+            return this.buildOperationDto(operation, resourceRegistry, processedInheritanceSchemas);
+        });
+        return enhancedOperations;
+    }
+    /**
+     * Build DTO for a single flattened operation with enhanced inheritance handling
+     */
+    static buildOperationDto(operation, resourceRegistry, processedInheritanceSchemas, resourceConfig) {
+        // Determine the effective operation identifier for DTO building
+        const effectiveOperation = operation.resourceOperationLike || operation.operationIdentifier;
+        // Apply inheritance to mainSchema if inheritance definition exists
+        // Use resource-level inheritance (resourceConfig.inheritenceSchemaDefinition) instead of operation-level
+        const inheritenceSchemaDefinition = resourceConfig?.inheritenceSchemaDefinition;
+        const enhancedMainSchema = this.applyInheritanceToSchema(operation.mainSchema, inheritenceSchemaDefinition, processedInheritanceSchemas);
+        // Create operation with inherited schema
+        const operationWithInheritance = {
+            ...operation,
+            mainSchema: enhancedMainSchema
+        };
+        // Build enhanced request DTO based on operation type and inherited schemas
+        let enhancedRequestDto = this.buildEnhancedRequestDto(operationWithInheritance, effectiveOperation);
+        // Build enhanced response DTO based on operation type and inherited schemas
+        let enhancedResponseDto = this.buildEnhancedResponseDto(operationWithInheritance, effectiveOperation);
+        // Add nested operations DTOs if configured (child + self relationships)
+        const resourceRelationships = operationWithInheritance.resourceRelationships;
+        const childDirRels = resourceRelationships ? getChildDirectionRelationships(resourceRelationships) : [];
+        if (childDirRels.length > 0) {
+            // Build request DTO with nested children for create/update operations,
+            // including bulk variants. Runtime bulk orchestration is handled in the
+            // services layer by applying the same nested-processing principles per
+            // parent result.
+            if (effectiveOperation === CoreResourceOperation.CREATE || effectiveOperation === CoreResourceOperation.CREATE_MANY ||
+                effectiveOperation === CoreResourceOperation.UPDATE || effectiveOperation === CoreResourceOperation.UPDATE_MANY) {
+                enhancedRequestDto = this.buildRequestDtoWithNested(effectiveOperation, enhancedRequestDto, childDirRels, resourceRegistry);
+            }
+            // Build response DTO with nested children (for READ)
+            if (effectiveOperation === CoreResourceOperation.READ) {
+                enhancedResponseDto = this.buildResponseDtoWithNested(enhancedResponseDto, childDirRels, resourceRegistry);
+            }
+        }
+        const result = {
+            ...operationWithInheritance,
+            requestDto: enhancedRequestDto,
+            responseDto: enhancedResponseDto,
+        };
+        return result;
+    }
+    /**
+     * Build enhanced request DTO based on operation type and existing DTOs.
+     *
+     * Decorator-aware DTO building:
+     * - For CREATE operations: excludes fields with `excludeFromCreate` decorator
+     * - For UPDATE operations: excludes fields with `excludeFromUpdate` decorator
+     * - For ALL operations: excludes fields with `isVirtual` decorator (computed fields)
+     */
+    static buildEnhancedRequestDto(operation, effectiveOperation) {
+        // Check if operation already has a meaningful requestDto (not z.any() and not empty)
+        const isZAny = operation.requestDto && isZodAny(operation.requestDto);
+        const currentRequestInfo = this.analyzeDtoSchema(operation.requestDto);
+        if (operation.requestDto && !isZAny && currentRequestInfo !== '📄 {} (empty object)') {
+            return operation.requestDto;
+        }
+        const searchQueryRequestSchema = operation.searchQueryRequestSchema;
+        if (effectiveOperation === CoreResourceOperation.SEARCH
+            && searchQueryRequestSchema
+            && !isZodAny(searchQueryRequestSchema)) {
+            return searchQueryRequestSchema;
+        }
+        // For operations that shouldn't have request DTOs, return empty object
+        const shouldHaveRequestDto = operationShouldHaveRequestDto(effectiveOperation);
+        if (!shouldHaveRequestDto) {
+            return z.object({});
+        }
+        // Apply bulk operation decorator if needed (only for API_CALL operations)
+        // For bulk operations, we need to wrap the underlying operation's requestDto
+        // with Resouces_BulkOperationBaseSchema
+        if ('isBulkOperation' in operation && operation.isBulkOperation) {
+            // Rebuild the underlying (non-bulk) requestDto by temporarily treating as non-bulk
+            const underlyingOperation = {
+                ...operation,
+                isBulkOperation: false,
+                requestDto: undefined // Clear to force rebuild
+            };
+            const underlyingRequestDto = this.buildEnhancedRequestDto(underlyingOperation, effectiveOperation);
+            // Wrap with bulk operation base schema
+            if (underlyingRequestDto && !isZodAny(underlyingRequestDto)) {
+                const underlyingInfo = this.analyzeDtoSchema(underlyingRequestDto);
+                if (underlyingInfo !== '📄 {} (empty object)') {
+                    if (effectiveOperation === CoreResourceOperation.CREATE_MANY) {
+                        return z.object({
+                            data: z.array(underlyingRequestDto),
+                        });
+                    }
+                    if (isZodObject(underlyingRequestDto)) {
+                        return Resouces_BulkOperationBaseSchema.extend(getZodObjectShape(underlyingRequestDto));
+                    }
+                    return Resouces_BulkOperationBaseSchema.and(underlyingRequestDto);
+                }
+            }
+            return effectiveOperation === CoreResourceOperation.CREATE_MANY
+                ? z.object({
+                    data: z.array(z.object({})),
+                })
+                : Resouces_BulkOperationBaseSchema;
+        }
+        // For create operations, use decorator-aware DTO building
+        if (effectiveOperation === CoreResourceOperation.CREATE || effectiveOperation === CoreResourceOperation.CREATE_MANY) {
+            return this.createRequestDtoForCreate(operation.mainSchema);
+        }
+        // For update operations, use decorator-aware DTO building
+        if (effectiveOperation === CoreResourceOperation.UPDATE || effectiveOperation === CoreResourceOperation.UPDATE_MANY) {
+            return this.createRequestDtoForUpdate(operation.mainSchema);
+        }
+        // Default: use mainSchema as-is (but still exclude virtual fields)
+        return this.excludeVirtualFieldsFromSchema(operation.mainSchema);
+    }
+    /**
+     * Build enhanced response DTO based on operation type and mainSchema
+     */
+    static buildEnhancedResponseDto(operation, effectiveOperation) {
+        // Check if operation already has a meaningful responseDto (not z.any() and not empty)
+        const isZAny = operation.responseDto && isZodAny(operation.responseDto);
+        const currentResponseInfo = this.analyzeDtoSchema(operation.responseDto);
+        if (operation.responseDto && !isZAny && currentResponseInfo !== '📄 {} (empty object)') {
+            return operation.responseDto;
+        }
+        // Apply bulk operation decorator for bulk operations (only for API_CALL operations)
+        if ('isBulkOperation' in operation && operation.isBulkOperation) {
+            switch (effectiveOperation) {
+                case CoreResourceOperation.DELETE:
+                case CoreResourceOperation.DELETE_MANY:
+                    return DefaultBulkDeleteResponseSchema;
+                case CoreResourceOperation.UPDATE:
+                case CoreResourceOperation.UPDATE_MANY:
+                case CoreResourceOperation.CREATE:
+                case CoreResourceOperation.CREATE_MANY:
+                    // Bulk create/update responses are arrays of resource items at runtime.
+                    // The controller validates array responses item-by-item against responseDto,
+                    // so bulk mutations must expose the per-item schema here, not a count wrapper.
+                    return operation.mainSchema;
+                default:
+                    return z.array(operation.mainSchema);
+            }
+        }
+        // Apply pagination decorator for list/search operations
+        if (effectiveOperation === CoreResourceOperation.LIST || effectiveOperation === CoreResourceOperation.SEARCH) {
+            return this.createPaginatedResponseSchema(operation.mainSchema, 50);
+        }
+        // Apply operation-specific default patterns
+        const defaultResponse = getDefaultResponseSchemaForOperation(effectiveOperation, operation.mainSchema);
+        return defaultResponse;
+    }
+    /**
+     * Create request DTO for CREATE operations.
+     *
+     * Excludes:
+     * - Standard auto-populated fields (_id, createdAt, etc.)
+     * - Fields with `excludeFromCreate` decorator
+     * - Fields with `isVirtual` decorator (computed fields)
+     *
+     * Handles discriminated unions by applying omissions to each variant.
+     */
+    static createRequestDtoForCreate(mainSchema) {
+        // Check if it's a discriminated union - need to handle each variant
+        const zodType = getZodType(mainSchema);
+        if (zodType === 'union') {
+            const discriminator = getZodDefStringProperty(mainSchema, 'discriminator');
+            const options = getZodDefArrayProperty(mainSchema, 'options');
+            if (discriminator && options && options.length > 0) {
+                // Apply omissions to each variant in the union
+                const modifiedOptions = options.map(option => this.applyCreateOmissionsToSchema(option));
+                // Recreate discriminated union with modified variants
+                if (modifiedOptions.length >= 2) {
+                    return z.discriminatedUnion(discriminator, modifiedOptions);
+                }
+                else if (modifiedOptions.length === 1) {
+                    return modifiedOptions[0];
+                }
+            }
+        }
+        // Regular object schema - apply omissions directly
+        return this.applyCreateOmissionsToSchema(mainSchema);
+    }
+    /**
+     * Check if a field is a non-discriminator literal.
+     * Non-discriminator literals are fixed values that should be auto-populated by the backend.
+     * Discriminator literals are used for variant selection and should be shown in CREATE forms.
+     *
+     * Handles wrapped types (optional, default, etc.) by unwrapping before type check.
+     */
+    static isNonDiscriminatorLiteral(fieldSchema) {
+        // Unwrap to handle z.literal("value").optional() etc.
+        const unwrapped = unwrapSchema(fieldSchema);
+        const zodType = getZodType(unwrapped);
+        // Check if it's a literal type and NOT marked as discriminator
+        // isDiscriminatorField already handles unwrapping via getMetadataRecursive
+        return zodType === 'literal' && !isDiscriminatorField(fieldSchema);
+    }
+    /**
+     * Apply CREATE operation omissions to a single schema (object or other).
+     */
+    static applyCreateOmissionsToSchema(schema) {
+        if (!isZodObject(schema)) {
+            return schema;
+        }
+        // Standard auto-generated fields to omit from create request DTOs
+        // Note: _id is handled via isPrimaryKey decorator which implies excludeFromCreate
+        // Primary scope fields (organizationId, userId, etc.) are auto-populated from context
+        // W7.3a: anonymousUserId is backend-injected from EC context, never client-supplied
+        const fieldsToOmit = ['id', 'createdAt', 'updatedAt', 'createdByUserId', 'organizationId', 'userId', 'applicationId', 'anonymousUserId'];
+        try {
+            const omitObj = {};
+            const shape = getZodObjectShape(schema);
+            // Add standard fields to omit
+            fieldsToOmit.forEach(field => {
+                if (shape[field]) {
+                    omitObj[field] = true;
+                }
+            });
+            // Add fields with excludeFromCreate decorator (includes isPrimaryKey which implies excludeFromCreate)
+            for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+                if (isExcludedFromCreate(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+                // Exclude virtual fields - they are computed, not submitted
+                if (isVirtualField(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+                // Exclude backend-only fields - they are managed internally
+                if (isBackendOnlyField(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+                // Exclude non-discriminator literals - they are auto-populated by backend
+                // Discriminator literals are KEPT for variant selection in CREATE forms
+                if (this.isNonDiscriminatorLiteral(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+            }
+            // If we have fields to omit, create omitted schema
+            if (Object.keys(omitObj).length > 0) {
+                const omittedSchema = this.omitObjectFields(schema, omitObj);
+                return omittedSchema;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to create request DTO for CREATE: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return schema;
+    }
+    /**
+     * Create request DTO for UPDATE operations.
+     *
+     * Excludes:
+     * - Standard auto-populated fields (_id, createdAt, etc.)
+     * - Fields with `excludeFromUpdate` decorator
+     * - Fields with `isVirtual` decorator (computed fields)
+     *
+     * Handles discriminated unions by applying omissions to each variant.
+     */
+    static createRequestDtoForUpdate(mainSchema) {
+        // Check if it's a discriminated union - need to handle each variant
+        const zodType = getZodType(mainSchema);
+        if (zodType === 'union') {
+            const discriminator = getZodDefStringProperty(mainSchema, 'discriminator');
+            const options = getZodDefArrayProperty(mainSchema, 'options');
+            if (discriminator && options && options.length > 0) {
+                // Apply omissions to each variant in the union
+                const modifiedOptions = options.map(option => this.applyUpdateOmissionsToSchema(option));
+                // Recreate discriminated union with modified variants
+                if (modifiedOptions.length >= 2) {
+                    return z.discriminatedUnion(discriminator, modifiedOptions);
+                }
+                else if (modifiedOptions.length === 1) {
+                    return modifiedOptions[0];
+                }
+            }
+        }
+        // Regular object schema - apply omissions directly
+        return this.applyUpdateOmissionsToSchema(mainSchema);
+    }
+    /**
+     * Check if a field is any kind of literal (discriminator or non-discriminator).
+     * All literals are excluded from UPDATE DTOs as they are immutable after creation.
+     *
+     * Handles wrapped types (optional, default, etc.) by unwrapping before type check.
+     */
+    static isLiteralField(fieldSchema) {
+        // Unwrap to handle z.literal("value").optional() etc.
+        const unwrapped = unwrapSchema(fieldSchema);
+        return getZodType(unwrapped) === 'literal';
+    }
+    /**
+     * Apply UPDATE operation omissions to a single schema (object or other).
+     */
+    static applyUpdateOmissionsToSchema(schema) {
+        if (!isZodObject(schema)) {
+            return schema;
+        }
+        // Standard auto-generated fields to omit from update request DTOs
+        // Note: Primary keys are passed as route params, not in request body
+        // Primary scope fields (organizationId, userId, etc.) are immutable after creation
+        // W7.3a: anonymousUserId is managed by transposition, never client-updatable
+        const fieldsToOmit = ['id', 'createdAt', 'updatedAt', 'createdByUserId', 'organizationId', 'userId', 'applicationId', 'anonymousUserId'];
+        try {
+            const omitObj = {};
+            const shape = getZodObjectShape(schema);
+            // Add standard fields to omit
+            fieldsToOmit.forEach(field => {
+                if (shape[field]) {
+                    omitObj[field] = true;
+                }
+            });
+            // Add fields with excludeFromUpdate decorator or isPrimaryKey (passed as route param)
+            for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+                if (isExcludedFromUpdate(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+                // Primary keys are passed as route params, not in request body
+                if (isPrimaryKey(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+                // Exclude virtual fields - they are computed, not submitted
+                if (isVirtualField(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+                // Exclude backend-only fields - they are managed internally
+                if (isBackendOnlyField(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+                // Exclude ALL literal fields - both discriminator and non-discriminator
+                // Literals are immutable after creation (discriminators define the variant,
+                // non-discriminators are fixed values)
+                if (this.isLiteralField(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+            }
+            // If we have fields to omit, create omitted schema
+            if (Object.keys(omitObj).length > 0) {
+                const omittedSchema = this.omitObjectFields(schema, omitObj);
+                return omittedSchema;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to create request DTO for UPDATE: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return schema;
+    }
+    /**
+     * Exclude virtual fields from a schema.
+     * Virtual fields are computed at runtime and should not appear in request DTOs.
+     *
+     * Handles discriminated unions by applying omissions to each variant.
+     */
+    static excludeVirtualFieldsFromSchema(mainSchema) {
+        // Check if it's a discriminated union - need to handle each variant
+        const zodType = getZodType(mainSchema);
+        if (zodType === 'union') {
+            const discriminator = getZodDefStringProperty(mainSchema, 'discriminator');
+            const options = getZodDefArrayProperty(mainSchema, 'options');
+            if (discriminator && options && options.length > 0) {
+                // Apply virtual field exclusion to each variant
+                const modifiedOptions = options.map(option => this.applyVirtualFieldExclusionToSchema(option));
+                // Recreate discriminated union with modified variants
+                if (modifiedOptions.length >= 2) {
+                    return z.discriminatedUnion(discriminator, modifiedOptions);
+                }
+                else if (modifiedOptions.length === 1) {
+                    return modifiedOptions[0];
+                }
+            }
+        }
+        // Regular object schema - apply exclusion directly
+        return this.applyVirtualFieldExclusionToSchema(mainSchema);
+    }
+    /**
+     * Apply virtual field exclusion to a single schema (object or other).
+     */
+    static applyVirtualFieldExclusionToSchema(schema) {
+        if (!isZodObject(schema)) {
+            return schema;
+        }
+        try {
+            const omitObj = {};
+            const shape = getZodObjectShape(schema);
+            // Find and exclude virtual fields
+            for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+                if (isVirtualField(fieldSchema)) {
+                    omitObj[fieldName] = true;
+                }
+            }
+            // If we have fields to omit, create omitted schema
+            if (Object.keys(omitObj).length > 0) {
+                const omittedSchema = this.omitObjectFields(schema, omitObj);
+                return omittedSchema;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to exclude virtual fields from schema: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return schema;
+    }
+    // TODO: Implement cascading relationships logic in future iteration
+    /**
+     * Create paginated response schema using shared pagination metadata schema
+     */
+    static createPaginatedResponseSchema(dataSchema, maxResultsPerPageLimit = 50) {
+        return z.object({
+            data: z.array(dataSchema).max(maxResultsPerPageLimit),
+            pagination: Resouces_PaginationResponseMetadataSchema
+        });
+    }
+    /**
+     * Analyze a DTO schema with full recursive object display
+     * Public method to get detailed recursive schema analysis
+     */
+    static analyzeSchemaRecursive(schema, maxDepth = 5) {
+        return this.analyzeDtoSchemaRecursive(schema, '', maxDepth);
+    }
+    /**
+     * Debug helper to display a single schema with full recursive analysis
+     * Useful for detailed inspection of specific DTOs
+     */
+    static debugDisplaySingleSchema(schemaName, schema, maxDepth = 5) {
+        console.log(`\n🔍 === SCHEMA DEBUG: ${schemaName} ===`);
+        const analysis = this.analyzeDtoSchemaRecursive(schema, '', maxDepth);
+        console.log(analysis);
+        console.log(`=== END SCHEMA DEBUG ===\n`);
+    }
+    /**
+     * Convenience method to display DTOs with full recursive object details
+     * Shows complete nested structures for better understanding
+     */
+    static debugDisplayGeneratedDtosWithFullDetails(resourceConfigurations, resourceFilter = [], maxDepth = 4) {
+        console.log(`\n🔍 === FULL RECURSIVE DTO ANALYSIS (depth: ${maxDepth}) ===\n`);
+        this.debugDisplayGeneratedDtos(resourceConfigurations, resourceFilter, true, // Always use recursive analysis
+        maxDepth);
+    }
+    /**
+     * Debug function to display DTOs for specific resources
+     * @param resourceConfigurations - All resource configurations
+     * @param resourceFilter - Array of resource types to filter (empty = show all)
+     * @param useRecursiveAnalysis - Whether to show full recursive object structures (default: true now)
+     * @param maxRecursionDepth - Maximum depth for recursive object analysis (default: 3)
+     */
+    static debugDisplayGeneratedDtos(resourceConfigurations, resourceFilter = [], useRecursiveAnalysis = true, maxRecursionDepth = 3) {
+        console.log('\n=== 📋 GENERATED DTOS DEBUG DISPLAY ===\n');
+        const resourceTypes = Object.keys(resourceConfigurations).sort();
+        let totalOperations = 0;
+        let totalDtosProcessed = 0;
+        let filteredResourceTypes = resourceFilter.length > 0
+            ? resourceTypes.filter(type => resourceFilter.includes(type))
+            : resourceTypes;
+        if (resourceFilter.length > 0) {
+            console.log(`🔍 Filtering for resources: ${resourceFilter.join(', ')}\n`);
+        }
+        if (useRecursiveAnalysis) {
+            console.log(`🔄 Using recursive object analysis (full nested structures, max depth: ${maxRecursionDepth})\n`);
+        }
+        for (const resourceType of filteredResourceTypes) {
+            const resourceConfig = resourceConfigurations[resourceType];
+            if (!resourceConfig || !resourceConfig.operations) {
+                console.log(`⚠️  Resource ${resourceType}: No operations found`);
+                continue;
+            }
+            const operations = resourceConfig.operations;
+            console.log(`\n📦 Resource: ${resourceType}`);
+            console.log(`   Operations: ${operations.length}`);
+            // Group operations by operation identifier for cleaner display
+            const operationGroups = new Map();
+            operations.forEach((op) => {
+                const key = op.operationIdentifier;
+                if (!operationGroups.has(key)) {
+                    operationGroups.set(key, []);
+                }
+                operationGroups.get(key).push(op);
+            });
+            for (const [operationIdentifier, ops] of operationGroups.entries()) {
+                console.log(`\n   🔧 Operation: ${operationIdentifier} (${ops.length} variants)`);
+                ops.forEach((operation, index) => {
+                    totalOperations++;
+                    const variantInfo = operation.variantType +
+                        (operation.isBulkOperation ? ' [BULK]' : '') +
+                        (operation.isOperationDefault ? ' [DEFAULT]' : '') +
+                        (operation.variantKey ? ` [${operation.variantKey}]` : '');
+                    console.log(`     └─ Variant ${index + 1}: ${variantInfo}`);
+                    // Display Request DTO
+                    const requestDtoInfo = useRecursiveAnalysis
+                        ? this.analyzeDtoSchemaRecursive(operation.requestDto, '', maxRecursionDepth)
+                        : this.analyzeDtoSchema(operation.requestDto);
+                    console.log(`        📤 Request:  ${requestDtoInfo}`);
+                    totalDtosProcessed++;
+                    // Display Response DTO
+                    const responseDtoInfo = useRecursiveAnalysis
+                        ? this.analyzeDtoSchemaRecursive(operation.responseDto, '', maxRecursionDepth)
+                        : this.analyzeDtoSchema(operation.responseDto);
+                    console.log(`        📥 Response: ${responseDtoInfo}`);
+                    totalDtosProcessed++;
+                    // NOTE: Cascade mode logging removed - lifecycle operations are now on relationships
+                    // See childOperations.lifecycle.onParentDelete on ResourceRelationship
+                    // NOTE: inheritenceSchemaConfiguration removed - conditional relationships now use
+                    // discriminator field on ResourceRelationship instead
+                });
+            }
+        }
+        console.log(`\n=== 📊 DTO DEBUG SUMMARY ===`);
+        console.log(`Resources processed: ${filteredResourceTypes.length}/${resourceTypes.length}`);
+        console.log(`Total operations: ${totalOperations}`);
+        console.log(`Total DTOs processed: ${totalDtosProcessed}`);
+        if (resourceFilter.length > 0) {
+            console.log(`Filter applied: [${resourceFilter.join(', ')}]`);
+        }
+        if (useRecursiveAnalysis) {
+            console.log(`Analysis mode: Recursive (full nested structures, depth: ${maxRecursionDepth})`);
+        }
+        console.log(`=================================\n`);
+    }
+    /**
+     * Get field count and names from a Zod object schema (Zod-compliant)
+     */
+    static getZodObjectFields(schema) {
+        if (!isZodObject(schema)) {
+            return { fieldCount: 0, fieldNames: [] };
+        }
+        try {
+            // Use public .shape property (Zod v4 API)
+            const shape = getZodObjectShape(schema);
+            const fieldNames = Object.keys(shape);
+            return { fieldCount: fieldNames.length, fieldNames };
+        }
+        catch (error) {
+            return { fieldCount: 0, fieldNames: [] };
+        }
+    }
+    /**
+     * Analyze a DTO schema and return a detailed human-readable summary (Zod-compliant)
+     */
+    static analyzeDtoSchema(schema, indent = '') {
+        if (!schema) {
+            return '❌ null/undefined';
+        }
+        // Check if it's a z.any()
+        if (isZodAny(schema)) {
+            return '⚪ z.any() [NEEDS ENHANCEMENT]';
+        }
+        // Check if it's a ZodObject - use proper field detection
+        if (isZodObject(schema)) {
+            const { fieldCount, fieldNames } = this.getZodObjectFields(schema);
+            if (fieldCount === 0) {
+                return '📄 {} (empty object)';
+            }
+            // Check if this is a decorated schema
+            let decorationInfo = '';
+            // Use the new Symbol-based metadata approach (preserves description for API docs)
+            const metadata = getCustomFieldMetadata(schema);
+            const decorations = [];
+            if (metadata[ZodDecorator.IS_DB_INDEXED])
+                decorations.push('indexed');
+            if (metadata[ZodDecorator.IS_FOREIGN_KEY])
+                decorations.push('reference');
+            if (decorations.length > 0) {
+                decorationInfo = ` [${decorations.join(', ')}]`;
+            }
+            // Return with detailed field information inline
+            let result = `📋 Object (${fieldCount} fields)${decorationInfo}`;
+            // Always show ALL field details without truncation
+            if (fieldCount > 0) {
+                try {
+                    const shape = getZodObjectShape(schema);
+                    result += ':\n';
+                    fieldNames.forEach((fieldName, index) => {
+                        const fieldSchema = shape[fieldName];
+                        const fieldType = this.getFieldTypeRecursive(fieldSchema, indent + '        │  ', 3, // Max depth for nested objects
+                        0, new Set());
+                        const isOptional = this.isFieldOptional(fieldSchema);
+                        const optionalMark = isOptional ? '?' : '';
+                        result += `${indent}        │  ${fieldName}${optionalMark}: ${fieldType}`;
+                        if (index < fieldNames.length - 1)
+                            result += '\n';
+                    });
+                }
+                catch (error) {
+                    result += ` (field details unavailable: ${error})`;
+                }
+            }
+            return result;
+        }
+        // Check if it's an array
+        if (isZodArray(schema)) {
+            const element = getZodDefSchemaProperty(schema, 'element');
+            if (!element)
+                return '📚 Array[unknown]';
+            const elementType = this.getFieldTypeRecursive(element, indent, 3, // Max depth for array elements
+            0, new Set());
+            return `📚 Array[${elementType}]`;
+        }
+        // Check if it's a union (regular or discriminated)
+        const zodType = getZodType(schema);
+        if (zodType === 'union') {
+            const options = getZodDefArrayProperty(schema, 'options');
+            const optionCount = options?.length || 0;
+            // In Zod v4, discriminated unions extend union and have a discriminator property
+            const discriminator = getZodDefStringProperty(schema, 'discriminator');
+            if (discriminator) {
+                return `🔀 DiscriminatedUnion (${optionCount} options, discriminator: "${discriminator}")`;
+            }
+            return `🔀 Union (${optionCount} options)`;
+        }
+        // Check if it's a merge/intersection
+        if (zodType === 'intersection') {
+            return '🔗 Merged schema';
+        }
+        // Check if it's an optional wrapper
+        if (isZodOptional(schema)) {
+            const innerType = getZodDefSchemaProperty(schema, 'innerType');
+            if (!innerType)
+                return 'unknown (optional)';
+            return this.analyzeDtoSchema(innerType, indent) + ' (optional)';
+        }
+        // Check if it's a pipe (from .transform(), .pipe(), etc.)
+        // In Zod v4, transforms create pipe types with 'in' and 'out' schemas
+        if (zodType === 'pipe') {
+            const inSchema = getZodDefSchemaProperty(schema, 'in');
+            if (!inSchema)
+                return '🔧 Pipe[unknown]';
+            return `🔧 Pipe[${this.analyzeDtoSchema(inSchema, indent)}]`;
+        }
+        // Check if it's a transform (standalone transform, no underlying schema)
+        if (zodType === 'transform') {
+            return '🔧 Transform';
+        }
+        // Check if it's a custom (from .refine(), .superRefine(), etc.)
+        // Custom types don't wrap schemas - refinements are stored as checks on the schema
+        if (zodType === 'custom') {
+            return '🔧 Custom';
+        }
+        // Check if it's a ZodDefault (has default value)
+        if (isZodDefault(schema)) {
+            const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+            if (!innerSchema)
+                return 'unknown (with default)';
+            return this.analyzeDtoSchema(innerSchema, indent) + ' (with default)';
+        }
+        // Default case
+        return `🔍 ${zodType || 'Unknown'}`;
+    }
+    /**
+     * Analyze a DTO schema with full recursive object display
+     * This method shows complete nested object structures instead of just summaries
+     */
+    static analyzeDtoSchemaRecursive(schema, indent = '', maxDepth = 5, currentDepth = 0, visitedSchemas = new Set()) {
+        if (!schema) {
+            return '❌ null/undefined';
+        }
+        // Prevent infinite recursion
+        if (currentDepth >= maxDepth) {
+            return `🔄 [Max depth ${maxDepth} reached]`;
+        }
+        // Prevent circular references
+        if (visitedSchemas.has(schema)) {
+            return '🔄 [Circular reference]';
+        }
+        visitedSchemas.add(schema);
+        // Check if it's a z.any()
+        if (isZodAny(schema)) {
+            visitedSchemas.delete(schema);
+            return '⚪ z.any() [NEEDS ENHANCEMENT]';
+        }
+        // Check if it's a ZodObject - use proper field detection with full recursion
+        if (isZodObject(schema)) {
+            const { fieldCount, fieldNames } = this.getZodObjectFields(schema);
+            if (fieldCount === 0) {
+                visitedSchemas.delete(schema);
+                return '📄 {} (empty object)';
+            }
+            // Check if this is a decorated schema
+            let decorationInfo = '';
+            // Use the new Symbol-based metadata approach (preserves description for API docs)
+            const metadata = getCustomFieldMetadata(schema);
+            const decorations = [];
+            if (metadata[ZodDecorator.IS_DB_INDEXED])
+                decorations.push('indexed');
+            if (metadata[ZodDecorator.IS_FOREIGN_KEY])
+                decorations.push('reference');
+            if (decorations.length > 0) {
+                decorationInfo = ` [${decorations.join(', ')}]`;
+            }
+            // Return with detailed field information inline with full recursion
+            let result = `📋 Object (${fieldCount} fields)${decorationInfo}`;
+            // Always show ALL field details with recursion
+            if (fieldCount > 0) {
+                try {
+                    const shape = getZodObjectShape(schema);
+                    result += ':\n';
+                    fieldNames.forEach((fieldName, index) => {
+                        const fieldSchema = shape[fieldName];
+                        const fieldType = this.getFieldTypeRecursive(fieldSchema, indent + '        │  ', maxDepth, currentDepth + 1, new Set(visitedSchemas));
+                        const isOptional = this.isFieldOptional(fieldSchema);
+                        const optionalMark = isOptional ? '?' : '';
+                        result += `${indent}        │  ${fieldName}${optionalMark}: ${fieldType}`;
+                        if (index < fieldNames.length - 1)
+                            result += '\n';
+                    });
+                }
+                catch (error) {
+                    result += ` (field details unavailable: ${error})`;
+                }
+            }
+            visitedSchemas.delete(schema);
+            return result;
+        }
+        // Check if it's an array with recursive element analysis
+        if (isZodArray(schema)) {
+            const element = getZodDefSchemaProperty(schema, 'element');
+            if (!element) {
+                visitedSchemas.delete(schema);
+                return '📚 Array[unknown]';
+            }
+            const elementType = this.getFieldTypeRecursive(element, indent, maxDepth, currentDepth + 1, new Set(visitedSchemas));
+            visitedSchemas.delete(schema);
+            return `📚 Array[${elementType}]`;
+        }
+        // Check if it's a union (regular or discriminated)
+        const zodType = getZodType(schema);
+        if (zodType === 'union') {
+            const options = getZodDefArrayProperty(schema, 'options');
+            const optionCount = options?.length || 0;
+            // In Zod v4, discriminated unions extend union and have a discriminator property
+            const discriminator = getZodDefStringProperty(schema, 'discriminator');
+            visitedSchemas.delete(schema);
+            if (discriminator) {
+                return `🔀 DiscriminatedUnion (${optionCount} options, discriminator: "${discriminator}")`;
+            }
+            return `🔀 Union (${optionCount} options)`;
+        }
+        // Check if it's a merge/intersection
+        if (zodType === 'intersection') {
+            visitedSchemas.delete(schema);
+            return '🔗 Merged schema';
+        }
+        // Check if it's an optional wrapper
+        if (isZodOptional(schema)) {
+            const innerType = getZodDefSchemaProperty(schema, 'innerType');
+            if (!innerType) {
+                visitedSchemas.delete(schema);
+                return 'unknown (optional)';
+            }
+            const result = this.analyzeDtoSchemaRecursive(innerType, indent, maxDepth, currentDepth, new Set(visitedSchemas)) + ' (optional)';
+            visitedSchemas.delete(schema);
+            return result;
+        }
+        // Check if it's a pipe (from .transform(), .pipe(), etc.)
+        // In Zod v4, transforms create pipe types with 'in' and 'out' schemas
+        if (zodType === 'pipe') {
+            const inSchema = getZodDefSchemaProperty(schema, 'in');
+            if (!inSchema) {
+                visitedSchemas.delete(schema);
+                return '🔧 Pipe[unknown]';
+            }
+            const result = `🔧 Pipe[${this.analyzeDtoSchemaRecursive(inSchema, indent, maxDepth, currentDepth, new Set(visitedSchemas))}]`;
+            visitedSchemas.delete(schema);
+            return result;
+        }
+        // Check if it's a transform (standalone transform, no underlying schema)
+        if (zodType === 'transform') {
+            visitedSchemas.delete(schema);
+            return '🔧 Transform';
+        }
+        // Check if it's a custom (from .refine(), .superRefine(), etc.)
+        // Custom types don't wrap schemas - refinements are stored as checks on the schema
+        if (zodType === 'custom') {
+            visitedSchemas.delete(schema);
+            return '🔧 Custom';
+        }
+        // Check if it's a ZodDefault (has default value)
+        if (isZodDefault(schema)) {
+            const innerSchema = getZodDefSchemaProperty(schema, 'innerType');
+            if (!innerSchema) {
+                visitedSchemas.delete(schema);
+                return 'unknown (with default)';
+            }
+            const result = this.analyzeDtoSchemaRecursive(innerSchema, indent, maxDepth, currentDepth, new Set(visitedSchemas)) + ' (with default)';
+            visitedSchemas.delete(schema);
+            return result;
+        }
+        // Default case
+        visitedSchemas.delete(schema);
+        return `🔍 ${zodType || 'Unknown'}`;
+    }
+    /**
+     * Get detailed field type description with full recursive sub-object support
+     */
+    static getFieldTypeRecursive(fieldSchema, indent = '', maxDepth = 5, currentDepth = 0, visitedSchemas = new Set()) {
+        const zodType = getZodType(fieldSchema);
+        if (!zodType)
+            return 'unknown';
+        // Prevent infinite recursion
+        if (currentDepth >= maxDepth) {
+            return `[Max depth ${maxDepth} reached]`;
+        }
+        // Prevent circular references
+        if (visitedSchemas.has(fieldSchema)) {
+            return '[Circular reference]';
+        }
+        switch (zodType) {
+            case 'string':
+                // Check for decorations
+                if (fieldSchema.description) {
+                    try {
+                        const metadata = JSON.parse(fieldSchema.description);
+                        const decorations = [];
+                        if (metadata.isDBIndexed)
+                            decorations.push('indexed');
+                        if (metadata.isForeignKey)
+                            decorations.push('ref');
+                        if (decorations.length > 0) {
+                            return `string [${decorations.join(', ')}]`;
+                        }
+                    }
+                    catch { }
+                }
+                return 'string';
+            case 'number':
+            case 'int': return 'number';
+            case 'bigint': return 'bigint';
+            case 'boolean': return 'boolean';
+            case 'date': return 'Date';
+            case 'array':
+                visitedSchemas.add(fieldSchema);
+                const element = getZodDefSchemaProperty(fieldSchema, 'element');
+                if (!element) {
+                    visitedSchemas.delete(fieldSchema);
+                    return 'unknown[]';
+                }
+                const elementType = this.getFieldTypeRecursive(element, indent, maxDepth, currentDepth + 1, new Set(visitedSchemas));
+                visitedSchemas.delete(fieldSchema);
+                return `${elementType}[]`;
+            case 'enum':
+                // Use centralized getEnumValues function
+                const enumValues = getEnumValues(fieldSchema);
+                if (enumValues.length === 0)
+                    return 'enum()';
+                return `enum(${enumValues.slice(0, 3).join('|')}${enumValues.length > 3 ? '...' : ''})`;
+            case 'object':
+                // Full recursive object analysis
+                visitedSchemas.add(fieldSchema);
+                const { fieldCount, fieldNames } = this.getZodObjectFields(fieldSchema);
+                if (fieldCount === 0) {
+                    visitedSchemas.delete(fieldSchema);
+                    return '{}';
+                }
+                let result = `{\n`;
+                try {
+                    const shape = getZodObjectShape(fieldSchema);
+                    fieldNames.forEach((fieldName, index) => {
+                        const nestedFieldSchema = shape[fieldName];
+                        const nestedFieldType = this.getFieldTypeRecursive(nestedFieldSchema, indent + '    ', maxDepth, currentDepth + 1, new Set(visitedSchemas));
+                        const isOptional = this.isFieldOptional(nestedFieldSchema);
+                        const optionalMark = isOptional ? '?' : '';
+                        result += `${indent}    ${fieldName}${optionalMark}: ${nestedFieldType}`;
+                        if (index < fieldNames.length - 1)
+                            result += ',\n';
+                    });
+                    result += `\n${indent}}`;
+                }
+                catch (error) {
+                    result = `object(${fieldCount} fields) [error: ${error}]`;
+                }
+                visitedSchemas.delete(fieldSchema);
+                return result;
+            case 'optional':
+                const optionalInnerType = getZodDefSchemaProperty(fieldSchema, 'innerType');
+                if (!optionalInnerType)
+                    return 'unknown?';
+                return this.getFieldTypeRecursive(optionalInnerType, indent, maxDepth, currentDepth, visitedSchemas) + '?';
+            case 'nullable':
+                const nullableInnerType = getZodDefSchemaProperty(fieldSchema, 'innerType');
+                if (!nullableInnerType)
+                    return 'unknown | null';
+                return this.getFieldTypeRecursive(nullableInnerType, indent, maxDepth, currentDepth, visitedSchemas) + ' | null';
+            case 'default':
+                const defaultValue = getZodDefProperty(fieldSchema, 'defaultValue');
+                const defaultInnerType = getZodDefSchemaProperty(fieldSchema, 'innerType');
+                if (!defaultInnerType)
+                    return 'unknown (with default)';
+                const defaultValueStr = typeof defaultValue === 'function'
+                    ? 'fn()'
+                    : String(defaultValue ?? 'undefined');
+                return this.getFieldTypeRecursive(defaultInnerType, indent, maxDepth, currentDepth, visitedSchemas) + ` (default: ${defaultValueStr})`;
+            case 'union':
+                const unionOptions = getZodDefArrayProperty(fieldSchema, 'options');
+                const optionCount = unionOptions?.length || 0;
+                // Check if it's a discriminated union
+                const unionDiscriminator = getZodDefStringProperty(fieldSchema, 'discriminator');
+                if (unionDiscriminator) {
+                    return `discriminatedUnion(${optionCount} options, discriminator: "${unionDiscriminator}")`;
+                }
+                return `union(${optionCount} options)`;
+            case 'literal':
+                const literalValue = getZodDefProperty(fieldSchema, 'value');
+                return `literal("${String(literalValue ?? 'unknown')}")`;
+            case 'any':
+                return 'any';
+            case 'unknown':
+                return 'unknown';
+            case 'set':
+                visitedSchemas.add(fieldSchema);
+                const setElement = getZodDefSchemaProperty(fieldSchema, 'valueType');
+                if (!setElement) {
+                    visitedSchemas.delete(fieldSchema);
+                    return 'Set<unknown>';
+                }
+                const setElementType = this.getFieldTypeRecursive(setElement, indent, maxDepth, currentDepth + 1, new Set(visitedSchemas));
+                visitedSchemas.delete(fieldSchema);
+                return `Set<${setElementType}>`;
+            case 'tuple':
+                visitedSchemas.add(fieldSchema);
+                const tupleItems = getZodDefArrayProperty(fieldSchema, 'items') ?? [];
+                const tupleTypes = tupleItems
+                    .filter((item) => isZodTypeAny(item))
+                    .map(item => this.getFieldTypeRecursive(item, indent, maxDepth, currentDepth + 1, new Set(visitedSchemas)));
+                visitedSchemas.delete(fieldSchema);
+                return `[${tupleTypes.join(', ')}]`;
+            case 'record':
+                visitedSchemas.add(fieldSchema);
+                const recordValue = getZodDefSchemaProperty(fieldSchema, 'valueType');
+                if (!recordValue) {
+                    visitedSchemas.delete(fieldSchema);
+                    return 'Record<string, unknown>';
+                }
+                const recordValueType = this.getFieldTypeRecursive(recordValue, indent, maxDepth, currentDepth + 1, new Set(visitedSchemas));
+                visitedSchemas.delete(fieldSchema);
+                return `Record<string, ${recordValueType}>`;
+            case 'map':
+                visitedSchemas.add(fieldSchema);
+                const mapKey = getZodDefSchemaProperty(fieldSchema, 'keyType');
+                const mapValue = getZodDefSchemaProperty(fieldSchema, 'valueType');
+                const mapKeyType = mapKey ? this.getFieldTypeRecursive(mapKey, indent, maxDepth, currentDepth + 1, new Set(visitedSchemas)) : 'unknown';
+                const mapValueType = mapValue ? this.getFieldTypeRecursive(mapValue, indent, maxDepth, currentDepth + 1, new Set(visitedSchemas)) : 'unknown';
+                visitedSchemas.delete(fieldSchema);
+                return `Map<${mapKeyType}, ${mapValueType}>`;
+            case 'intersection':
+                const leftSchema = getZodDefSchemaProperty(fieldSchema, 'left');
+                const rightSchema = getZodDefSchemaProperty(fieldSchema, 'right');
+                const leftType = leftSchema ? this.getFieldTypeRecursive(leftSchema, indent, maxDepth, currentDepth + 1, visitedSchemas) : 'unknown';
+                const rightType = rightSchema ? this.getFieldTypeRecursive(rightSchema, indent, maxDepth, currentDepth + 1, visitedSchemas) : 'unknown';
+                return `${leftType} & ${rightType}`;
+            case 'lazy':
+                return 'lazy<...>';
+            case 'void':
+            case 'undefined':
+            case 'never':
+                return zodType;
+            case 'pipe':
+                const pipeInSchema = getZodDefSchemaProperty(fieldSchema, 'in');
+                if (!pipeInSchema)
+                    return 'pipe[unknown]';
+                const pipeInnerType = this.getFieldTypeRecursive(pipeInSchema, indent, maxDepth, currentDepth, visitedSchemas);
+                return `pipe[${pipeInnerType}]`;
+            case 'transform':
+                return 'transform';
+            case 'custom':
+                return 'custom';
+            default:
+                return zodType || 'unknown';
+        }
+    }
+    /**
+     * Check if a field is optional
+     */
+    static isFieldOptional(fieldSchema) {
+        // Check if it's wrapped in ZodOptional
+        if (isZodOptional(fieldSchema))
+            return true;
+        // Check if it's a ZodDefault (has default value)
+        if (isZodDefault(fieldSchema))
+            return true;
+        return false;
+    }
+    /**
+     * Apply inheritance to mainSchema based on inheritance definition
+     * Creates discriminated union schemas when inheritance is defined
+     *
+     * NOTE: This transfers inheritance logic from relationship cascading mechanism
+     * to schema-level processing, ensuring inheritance affects DTOs properly.
+     *
+     * NOTE: TDatabaseSchema has been removed. Backend-only fields are now marked with
+     * the `isBackendOnly` decorator and stripped at the service layer.
+     */
+    static applyInheritanceToSchema(mainSchema, inheritanceDefinition, processedInheritanceSchemas) {
+        // If no inheritance definition, return original schema
+        if (!inheritanceDefinition || !inheritanceDefinition.inheritedSchemas ||
+            inheritanceDefinition.inheritedSchemas.length === 0) {
+            return mainSchema;
+        }
+        const cacheKey = `${JSON.stringify(inheritanceDefinition)}_main`;
+        // Check cache first
+        if (processedInheritanceSchemas.has(cacheKey)) {
+            return processedInheritanceSchemas.get(cacheKey);
+        }
+        const { discriminatorField, inheritedSchemas, withoutInheritanceDiscriminatorFieldValues } = inheritanceDefinition;
+        // Build discriminated union options for mainSchema
+        const mainSchemaOptions = [];
+        // Add base schema for non-inherited values if specified
+        if (withoutInheritanceDiscriminatorFieldValues && withoutInheritanceDiscriminatorFieldValues.length > 0) {
+            // Create enum for base discriminator values
+            const baseDiscriminatorEnum = z.enum(withoutInheritanceDiscriminatorFieldValues);
+            // Extend mainSchema with discriminator field
+            const baseMainSchema = this.extendSchemaWithDiscriminator(mainSchema, discriminatorField, baseDiscriminatorEnum);
+            mainSchemaOptions.push(baseMainSchema);
+        }
+        // Process each inherited schema
+        inheritedSchemas.forEach((inheritedItem) => {
+            const { discriminatorFieldValue, schema: inheritedSchema } = inheritedItem;
+            // Create literal discriminator for this variant
+            const discriminatorLiteral = z.literal(discriminatorFieldValue);
+            // Merge inherited schema with base schema and add discriminator
+            const mergedMainSchema = this.mergeInheritedSchema(mainSchema, inheritedSchema, discriminatorField, discriminatorLiteral);
+            mainSchemaOptions.push(mergedMainSchema);
+            // Handle nested inheritance recursively
+            if (inheritedItem.inheritenceSchemaDefinition) {
+                const nestedMain = this.applyInheritanceToSchema(mergedMainSchema, inheritedItem.inheritenceSchemaDefinition, processedInheritanceSchemas);
+                // Replace the simple merged schema with the nested enhanced one
+                mainSchemaOptions[mainSchemaOptions.length - 1] = nestedMain;
+            }
+        });
+        // Create discriminated union if we have multiple options
+        let enhancedMainSchema;
+        if (mainSchemaOptions.length > 1) {
+            // Check if all schemas are ZodObject types to use discriminated union
+            const allMainAreObjects = mainSchemaOptions.every(schema => isZodObject(schema));
+            if (allMainAreObjects) {
+                // Use discriminated union for object schemas
+                enhancedMainSchema = z.discriminatedUnion(discriminatorField, mainSchemaOptions);
+            }
+            else {
+                // Fallback to regular union for mixed types
+                enhancedMainSchema = z.union(mainSchemaOptions);
+            }
+        }
+        else if (mainSchemaOptions.length === 1) {
+            enhancedMainSchema = mainSchemaOptions[0];
+        }
+        else {
+            // Fallback to original schema
+            enhancedMainSchema = mainSchema;
+        }
+        // Cache the result
+        processedInheritanceSchemas.set(cacheKey, enhancedMainSchema);
+        return enhancedMainSchema;
+    }
+    /**
+     * Extend a schema with a discriminator field
+     */
+    static extendSchemaWithDiscriminator(baseSchema, discriminatorField, discriminatorSchema) {
+        // If base schema is not an object, wrap it in an object with the discriminator
+        if (!isZodObject(baseSchema)) {
+            return z.object({
+                [discriminatorField]: discriminatorSchema,
+                value: baseSchema
+            });
+        }
+        // Extend existing object schema with discriminator field
+        // Type guard already ensures it's a ZodObject
+        return baseSchema.extend({
+            [discriminatorField]: discriminatorSchema
+        });
+    }
+    /**
+     * Merge inherited schema with base schema and add discriminator
+     */
+    static mergeInheritedSchema(baseSchema, inheritedSchema, discriminatorField, discriminatorValue) {
+        // If both are object schemas, merge them
+        if (isZodObject(baseSchema) && isZodObject(inheritedSchema)) {
+            // Merge the two object schemas and add discriminator (using extend instead of merge in Zod v4)
+            const mergedSchema = baseSchema.extend(inheritedSchema.shape);
+            return mergedSchema.extend({
+                [discriminatorField]: discriminatorValue
+            });
+        }
+        // If only inherited schema is an object, extend it with discriminator
+        if (isZodObject(inheritedSchema)) {
+            // Type guard already ensures it's a ZodObject
+            return inheritedSchema.extend({
+                [discriminatorField]: discriminatorValue
+            });
+        }
+        // Fallback: create object with discriminator and value
+        return z.object({
+            [discriminatorField]: discriminatorValue,
+            value: inheritedSchema
+        });
+    }
+    // =============================================================================
+    // NESTED OPERATIONS DTO BUILDING
+    // =============================================================================
+    static getAllResourceFieldIdentifiers(resourceRegistry) {
+        const allResourceFieldIdentifiers = {};
+        for (const [resourceType, resourceConfig] of resourceRegistry.entries()) {
+            if (typeof resourceConfig?.resourceFieldIdentifier === 'string' && resourceConfig.resourceFieldIdentifier.length > 0) {
+                allResourceFieldIdentifiers[resourceType] = resourceConfig.resourceFieldIdentifier;
+            }
+        }
+        return allResourceFieldIdentifiers;
+    }
+    /**
+     * Derive nested field name from the relationship identifier.
+     */
+    static getNestedFieldName(rel, resourceRegistry) {
+        return Resources_SharedUtils.resolveRelationshipObjectIdentity(rel, rel.resourceType2, rel.cardinality2, this.getAllResourceFieldIdentifiers(resourceRegistry)).objectFieldName;
+    }
+    static getRelationshipObjectFieldName(rel, relatedResourceType, cardinality, resourceRegistry) {
+        return Resources_SharedUtils.resolveRelationshipObjectIdentity(rel, relatedResourceType, cardinality, this.getAllResourceFieldIdentifiers(resourceRegistry)).objectFieldName;
+    }
+    /**
+     * Get delete field name: _{nestedField}ToDelete
+     */
+    static getDeleteFieldName(nestedFieldName) {
+        return `_${nestedFieldName}ToDelete`;
+    }
+    /**
+     * Build child schema for nested operations based on operation type and config.
+     * For CREATE: uses child's CREATE request DTO
+     * For UPDATE: uses union of CREATE (no _id) and UPDATE (with _id) DTOs
+     */
+    static buildNestedChildSchema(rel, nestedConfig, operation, childMainSchema, resourceRegistry) {
+        const childResourceType = rel.resourceType2;
+        // Get child's operation config to find request DTOs
+        const childConfig = resourceRegistry.get(childResourceType);
+        if (!childConfig || !childConfig.operations) {
+            // Fallback: use child's main schema with appropriate omissions
+            if (operation === CoreResourceOperation.CREATE || operation === CoreResourceOperation.CREATE_MANY) {
+                return this.createRequestDtoForCreate(childMainSchema);
+            }
+            else {
+                return this.createRequestDtoForUpdate(childMainSchema);
+            }
+        }
+        // Find child's CREATE operation for request DTO
+        const childCreateOp = childConfig.operations.find((op) => op.operationIdentifier === CoreResourceOperation.CREATE ||
+            op.resourceOperationLike === CoreResourceOperation.CREATE);
+        const childCreateDto = childCreateOp?.requestDto || this.createRequestDtoForCreate(childMainSchema);
+        if (operation === CoreResourceOperation.CREATE || operation === CoreResourceOperation.CREATE_MANY) {
+            // For CREATE: use child's CREATE DTO
+            return childCreateDto;
+        }
+        // For UPDATE: use union of CREATE (no _id) and UPDATE (with _id) DTOs
+        const childUpdateOp = childConfig.operations.find((op) => op.operationIdentifier === CoreResourceOperation.UPDATE ||
+            op.resourceOperationLike === CoreResourceOperation.UPDATE);
+        const childUpdateDto = childUpdateOp?.requestDto || this.createRequestDtoForUpdate(childMainSchema);
+        // Create union: items without _id are creates, items with _id are updates
+        // In Zod 4, we use z.union for discriminated unions or z.union for simple unions
+        if (isZodObject(childCreateDto) && isZodObject(childUpdateDto)) {
+            // Explicitly forbid _id on the create branch so _id-bearing payloads are
+            // routed through the update branch instead of being accepted as creates and
+            // only failing later in downstream child UPDATE validation.
+            const createWithoutId = childCreateDto.extend({
+                _id: z.never().optional()
+            });
+            // UPDATE DTO should have _id as required
+            const updateWithRequiredId = childUpdateDto.extend({
+                _id: z.string()
+            });
+            return z.union([updateWithRequiredId, createWithoutId]);
+        }
+        // Fallback: use UPDATE DTO
+        return childUpdateDto;
+    }
+    /**
+     * Get child schema for a specific DataMode (for nested READ responses).
+     * - RAW: All stored fields, no population
+     * - SUMMARY: Summary fields only (fields with isSummaryField decorator)
+     * - CONTEXT: Full context (all fields with contextPolicy applied)
+     *
+     * Note: CONTEXT mode requires service-layer processing (contextPolicy application),
+     * so we return the full schema here. The service layer will apply contextPolicy.
+     */
+    static getChildSchemaForDataMode(childMainSchema, dataMode) {
+        switch (dataMode) {
+            case DataMode.SUMMARY:
+                // Use ResourcesSummaryUtils to derive summary schema (only fields with isSummaryField decorator)
+                if (isZodObject(childMainSchema)) {
+                    return ResourcesSummaryUtils.deriveSummarySchema(childMainSchema, {
+                        includeId: true, // Always include _id in summaries
+                        includeForeignKeys: false, // Only include FKs if they have isSummaryField decorator
+                    });
+                }
+                // Fallback for non-object schemas
+                return childMainSchema;
+            case DataMode.CONTEXT:
+                // CONTEXT mode requires service-layer processing (contextPolicy, population, etc.)
+                // Return full schema - service layer will apply contextPolicy
+                return childMainSchema;
+            case DataMode.RAW:
+            default:
+                // RAW mode: return full schema (all stored fields)
+                return childMainSchema;
+        }
+    }
+    /**
+     * Extend a DTO root that may be either a plain object or a discriminated
+     * union of objects.
+     *
+     * Relationship-driven nested fields must exist on every variant of a
+     * polymorphic DTO root; otherwise the shared contract silently diverges from
+     * the live frontend form/runtime path.
+     */
+    static extendObjectLikeDto(baseDto, extensionShape) {
+        if (Object.keys(extensionShape).length === 0) {
+            return baseDto;
+        }
+        if (isZodObject(baseDto)) {
+            return baseDto.extend(extensionShape);
+        }
+        const zodType = getZodType(baseDto);
+        if (zodType === 'union') {
+            const discriminator = getZodDefStringProperty(baseDto, 'discriminator');
+            const unionOptions = getZodDefArrayProperty(baseDto, 'options');
+            if (discriminator && unionOptions && unionOptions.length > 0) {
+                const extendedOptions = unionOptions.map((option) => isZodObject(option)
+                    ? option.extend(extensionShape)
+                    : option);
+                if (extendedOptions.every((option) => isZodObject(option))) {
+                    if (extendedOptions.length >= 2) {
+                        return z.discriminatedUnion(discriminator, extendedOptions);
+                    }
+                    if (extendedOptions.length === 1) {
+                        return extendedOptions[0];
+                    }
+                }
+            }
+        }
+        return baseDto;
+    }
+    /**
+     * Build request DTO with nested children based on config.
+     * Extends the base request DTO with nested child fields for CREATE/UPDATE operations.
+     *
+     * ## Deliberate Condition-Agnosticism
+     *
+     * This method iterates ALL child relationships whose compiled runtime
+     * semantics expose a current effective nested projection,
+     * regardless of whether they carry a `discriminator` or `condition`.
+     * It generates DTO fields for every such relationship unconditionally.
+     *
+     * This is intentional: DTO generation is a STARTUP concern — it defines the shape
+     * of all possible request/response schemas. Conditional filtering is a RUNTIME
+     * concern handled by:
+     * - `ServicesRegistryHandler.filterRelationshipsByParent()` — which filters
+     *   active relationships before processing nested data in CREATE/UPDATE
+     * - `ResourceContextBackendService.fetchChildResourcesWithPolicy()` — which
+     *   filters active relationships before fetching children in context
+     *
+     * If the DTO builder filtered by discriminator at startup, the nested fields
+     * would be missing from the schema entirely, and runtime data for those fields
+     * would be silently dropped during Zod validation.
+     */
+    static buildRequestDtoWithNested(operation, baseDto, childRelationships, resourceRegistry) {
+        if (operation === CoreResourceOperation.CREATE_MANY) {
+            const baseShape = isZodObject(baseDto) ? getZodObjectShape(baseDto) : undefined;
+            const dataSchema = baseShape?.data;
+            if (dataSchema instanceof z.ZodArray) {
+                const nestedItemDto = this.buildRequestDtoWithNested(CoreResourceOperation.CREATE, dataSchema.element, childRelationships, resourceRegistry);
+                return this.extendObjectLikeDto(baseDto, {
+                    data: z.array(nestedItemDto),
+                });
+            }
+        }
+        const nestedFields = {};
+        for (const rel of childRelationships) {
+            const compiledRel = Resources_SharedUtils.ensureCompiledRelationship(rel);
+            const nestedConfig = Resources_SharedUtils.resolveRelationshipNestedMutationConfig(compiledRel, operation);
+            if (!nestedConfig)
+                continue;
+            const fieldName = this.getNestedFieldName(compiledRel, resourceRegistry);
+            const childConfig = resourceRegistry.get(compiledRel.resourceType2);
+            if (!childConfig)
+                continue;
+            const childSchema = this.buildNestedChildSchema(compiledRel, nestedConfig, operation, childConfig.mainSchema, resourceRegistry);
+            // Add nested field (array for 1:N/N:N, object for 1:1)
+            nestedFields[fieldName] = isArrayCardinality(compiledRel.cardinality2)
+                ? z.array(childSchema).optional()
+                : childSchema.optional();
+            // Add delete field if allowDelete (for UPDATE only)
+            if (nestedConfig.allowDelete &&
+                (operation === CoreResourceOperation.UPDATE || operation === CoreResourceOperation.UPDATE_MANY)) {
+                nestedFields[this.getDeleteFieldName(fieldName)] = z.array(z.string()).optional();
+            }
+        }
+        return this.extendObjectLikeDto(baseDto, nestedFields);
+    }
+    /**
+     * Build response DTO with nested children based on onRead config.
+     * Extends the base response DTO with nested child fields for READ operations.
+     *
+     * Like `buildRequestDtoWithNested`, this is deliberately condition-agnostic —
+     * it generates response DTO fields for ALL relationships whose compiled
+     * runtime semantics expose an effective nested-read projection, regardless of
+     * discriminator/condition. The fields are optional (`z.optional()`), so when
+     * the runtime skips a conditional relationship, the field is simply absent
+     * from the response rather than causing a schema validation error.
+     */
+    static buildResponseDtoWithNested(baseDto, childRelationships, resourceRegistry) {
+        const nestedFields = {};
+        for (const rel of childRelationships) {
+            const compiledRel = Resources_SharedUtils.ensureCompiledRelationship(rel);
+            const readConfig = Resources_SharedUtils.resolveRelationshipNestedReadConfig(compiledRel);
+            if (!readConfig)
+                continue;
+            const fieldName = this.getNestedFieldName(compiledRel, resourceRegistry);
+            const childConfig = resourceRegistry.get(compiledRel.resourceType2);
+            if (!childConfig)
+                continue;
+            const childSchema = this.getChildSchemaForDataMode(childConfig.mainSchema, readConfig.dataMode);
+            // Add nested field (array for 1:N/N:N, object for 1:1)
+            nestedFields[fieldName] = isArrayCardinality(compiledRel.cardinality2)
+                ? z.array(childSchema).optional()
+                : childSchema.optional();
+        }
+        return this.extendObjectLikeDto(baseDto, nestedFields);
+    }
+    /**
+     * Strip fields marked with isBackendOnly decorator from schema.
+     *
+     * @param schema - Schema to strip from
+     * @param options - Options for stripping behavior
+     * @returns New schema without backend-only fields
+     */
+    static stripBackendOnlyFields(schema, options) {
+        // Handle discriminated unions - strip from all variants
+        const zodType = getZodType(schema);
+        if (zodType === 'union') {
+            const discriminator = getZodDefStringProperty(schema, 'discriminator');
+            const unionOptions = getZodDefArrayProperty(schema, 'options');
+            if (discriminator && unionOptions && unionOptions.length > 0) {
+                const strippedOptions = unionOptions.map((option) => this.stripBackendOnlyFields(option, options));
+                // Recreate discriminated union with modified variants
+                if (strippedOptions.length >= 2) {
+                    return z.discriminatedUnion(discriminator, strippedOptions);
+                }
+                else if (strippedOptions.length === 1) {
+                    return strippedOptions[0];
+                }
+            }
+            return schema;
+        }
+        // Handle arrays - strip from array element schema
+        if (isZodArray(schema)) {
+            // ZodArray stores element schema in _def.element (not _def.type)
+            const elementSchema = getZodDefProperty(schema, 'element');
+            return z.array(this.stripBackendOnlyFields(elementSchema, options));
+        }
+        // Handle optional/nullable/default wrappers - unwrap, strip, rewrap
+        if (isZodOptional(schema)) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            return this.stripBackendOnlyFields(innerSchema, options).optional();
+        }
+        if (hasZodType(schema, 'nullable')) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            return this.stripBackendOnlyFields(innerSchema, options).nullable();
+        }
+        if (isZodDefault(schema)) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            const defaultValue = getZodDefProperty(schema, 'defaultValue');
+            return this.stripBackendOnlyFields(innerSchema, options).default(defaultValue);
+        }
+        // Handle objects - strip backend-only fields from shape
+        if (isZodObject(schema)) {
+            const shape = getZodObjectShape(schema);
+            const omitObj = {};
+            const rebuiltShape = {};
+            let didRebuildNestedField = false;
+            for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+                if (isBackendOnlyField(fieldSchema)) {
+                    const backendOnlyParams = getBackendOnlyParams(fieldSchema);
+                    // Respect isReturnedAtCreation for CREATE operations
+                    if (options?.respectIsReturnedAtCreation &&
+                        options?.operationType === CoreResourceOperation.CREATE &&
+                        backendOnlyParams?.isReturnedAtCreation) {
+                        // Keep this field - it's returned at creation
+                        rebuiltShape[fieldName] = fieldSchema;
+                        continue;
+                    }
+                    // Strip this backend-only field
+                    omitObj[fieldName] = true;
+                }
+                else {
+                    // Recursively strip from nested objects/arrays
+                    const strippedFieldSchema = this.stripBackendOnlyFields(fieldSchema, options);
+                    rebuiltShape[fieldName] = strippedFieldSchema;
+                    didRebuildNestedField = didRebuildNestedField || strippedFieldSchema !== fieldSchema;
+                }
+            }
+            if (Object.keys(omitObj).length > 0 || didRebuildNestedField) {
+                return this.rebuildObjectSchema(schema, rebuiltShape, {
+                    preserveChecks: Object.keys(omitObj).length === 0,
+                });
+            }
+            return schema;
+        }
+        // For other schema types (primitives, etc.), return as-is
+        return schema;
+    }
+    /**
+     * Transform z.date() → z.coerce.date() recursively for API/WebSocket/Queue DTOs.
+     *
+     * This utility is used to create schemas suitable for parsing API responses/requests
+     * where dates come as ISO strings and need to be coerced to Date objects.
+     *
+     * Use this when parsing data from:
+     * - HTTP API responses (JSON with date strings)
+     * - WebSocket messages
+     * - Queue messages
+     * - Any external data source where dates are serialized as strings
+     *
+     * @param schema - Schema to transform (typically a database/internal schema with z.date())
+     * @returns New schema with coerced dates (z.coerce.date()) suitable for API parsing
+     *
+     * @example
+     * ```typescript
+     * // Database schema uses z.date()
+     * const dbSchema = z.object({ createdAt: z.date() });
+     *
+     * // Create API parsing schema
+     * const apiSchema = ResourcesConfigOperationsDtosBuilderUtils.createApiParsingSchema(dbSchema);
+     *
+     * // Now can parse API response with date strings
+     * const data = apiSchema.parse({ createdAt: "2024-01-01T00:00:00Z" }); // Works!
+     * ```
+     */
+    static createApiParsingSchema(schema) {
+        return this.applyDateCoercion(schema);
+    }
+    /**
+     * Transform z.date() → z.coerce.date() recursively for API/WebSocket/Queue DTOs.
+     *
+     * @param schema - Schema to transform
+     * @returns New schema with coerced dates
+     */
+    static applyDateCoercion(schema) {
+        // Handle discriminated unions - transform dates in all variants
+        const zodType = getZodType(schema);
+        if (zodType === 'union') {
+            const discriminator = getZodDefStringProperty(schema, 'discriminator');
+            const unionOptions = getZodDefArrayProperty(schema, 'options');
+            if (discriminator && unionOptions && unionOptions.length > 0) {
+                const transformedOptions = unionOptions.map((option) => this.applyDateCoercion(option));
+                if (transformedOptions.length >= 2) {
+                    return z.discriminatedUnion(discriminator, transformedOptions);
+                }
+                else if (transformedOptions.length === 1) {
+                    return transformedOptions[0];
+                }
+            }
+            return schema;
+        }
+        // Handle arrays - transform dates in array element schema
+        if (isZodArray(schema)) {
+            // ZodArray stores element schema in _def.element (not _def.type)
+            const elementSchema = getZodDefProperty(schema, 'element');
+            return z.array(this.applyDateCoercion(elementSchema));
+        }
+        // Handle optional/nullable/default wrappers - unwrap, transform, rewrap
+        if (isZodOptional(schema)) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            return this.applyDateCoercion(innerSchema).optional();
+        }
+        if (hasZodType(schema, 'nullable')) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            return this.applyDateCoercion(innerSchema).nullable();
+        }
+        if (isZodDefault(schema)) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            const defaultValue = getZodDefProperty(schema, 'defaultValue');
+            return this.applyDateCoercion(innerSchema).default(defaultValue);
+        }
+        // Handle pipe/refine - unwrap, transform, rewrap
+        if (hasZodType(schema, 'pipe') || hasZodType(schema, 'refine')) {
+            const innerSchema = getZodDefProperty(schema, 'schema');
+            const transformed = this.applyDateCoercion(innerSchema);
+            // Reapply pipe/refine - this is complex, for now just transform inner schema
+            // Full pipe/refine preservation would require extracting all pipe steps
+            return transformed;
+        }
+        // Handle date - transform to coerce.date
+        if (hasZodType(schema, 'date')) {
+            // Always transform to coerce.date for DTOs (API/WebSocket/Queue communication)
+            // This allows string dates from JSON to be coerced to Date objects
+            return z.coerce.date();
+        }
+        // Handle objects - transform dates in shape
+        if (isZodObject(schema)) {
+            const shape = getZodObjectShape(schema);
+            const transformedShape = {};
+            let didTransformAnyField = false;
+            for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+                const transformedFieldSchema = this.applyDateCoercion(fieldSchema);
+                transformedShape[fieldName] = transformedFieldSchema;
+                didTransformAnyField = didTransformAnyField || transformedFieldSchema !== fieldSchema;
+            }
+            if (!didTransformAnyField) {
+                return schema;
+            }
+            return this.rebuildObjectSchema(schema, transformedShape);
+        }
+        // For other schema types (primitives, etc.), return as-is
+        return schema;
+    }
+    /**
+     * Extract summary fields (isSummaryField decorator) from schema.
+     * Handles discriminated unions by extracting from each variant.
+     *
+     * @param schema - Schema to extract from
+     * @returns New schema with only summary fields
+     */
+    static extractSummaryFields(schema) {
+        // Handle discriminated unions - extract summary from each variant
+        const zodType = getZodType(schema);
+        if (zodType === 'union') {
+            const discriminator = getZodDefStringProperty(schema, 'discriminator');
+            const unionOptions = getZodDefArrayProperty(schema, 'options');
+            if (discriminator && unionOptions && unionOptions.length > 0) {
+                // Use ResourcesSummaryUtils.deriveSummarySchemaForDiscriminatedUnion if all options are objects
+                const allAreObjects = unionOptions.every(opt => isZodObject(opt));
+                if (allAreObjects) {
+                    try {
+                        return ResourcesSummaryUtils.deriveSummarySchemaForDiscriminatedUnion(schema, {
+                            discriminatorField: discriminator,
+                            withoutInheritanceDiscriminatorFieldValues: []
+                        });
+                    }
+                    catch {
+                        // Fallback: extract from each variant individually (see lines below)
+                    }
+                }
+                // Extract summary from each variant and rebuild union
+                const summaryOptions = unionOptions.map((option) => this.extractSummaryFields(option)).filter(opt => opt !== null && opt !== undefined);
+                if (summaryOptions.length >= 2) {
+                    return z.discriminatedUnion(discriminator, summaryOptions);
+                }
+                else if (summaryOptions.length === 1) {
+                    return summaryOptions[0];
+                }
+            }
+            return schema;
+        }
+        // Handle arrays - extract summary from array element schema
+        if (isZodArray(schema)) {
+            // ZodArray stores element schema in _def.element (not _def.type)
+            const elementSchema = getZodDefProperty(schema, 'element');
+            return z.array(this.extractSummaryFields(elementSchema));
+        }
+        // Handle optional/nullable/default wrappers - unwrap, extract, rewrap
+        if (isZodOptional(schema)) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            return this.extractSummaryFields(innerSchema).optional();
+        }
+        if (hasZodType(schema, 'nullable')) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            return this.extractSummaryFields(innerSchema).nullable();
+        }
+        if (isZodDefault(schema)) {
+            const innerSchema = getZodDefProperty(schema, 'innerType');
+            const defaultValue = getZodDefProperty(schema, 'defaultValue');
+            return this.extractSummaryFields(innerSchema).default(defaultValue);
+        }
+        // Handle objects - use ResourcesSummaryUtils.deriveSummarySchema
+        if (isZodObject(schema)) {
+            try {
+                const summarySchema = ResourcesSummaryUtils.deriveSummarySchema(schema, {
+                    includeId: true,
+                    includeForeignKeys: false
+                });
+                // Apply date coercion to summary schema
+                return this.applyDateCoercion(summarySchema);
+            }
+            catch (error) {
+                throw new Error(`Failed to derive summary schema for object: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // For other schema types (primitives, etc.), return as-is
+        return schema;
+    }
+    /**
+     * Add relationship placeholders to schema for context DTO.
+     * Placeholders are optional fields: parentResourceType?: { _id: string }
+     *
+     * @param schema - Base schema
+     * @param relationships - Resource relationships configuration
+     * @param registry - Resource registry for type resolution
+     * @returns Schema with relationship placeholders added
+     */
+    static addRelationshipPlaceholders(schema, relationships, registry) {
+        // Only add placeholders to object schemas
+        if (!isZodObject(schema)) {
+            return schema;
+        }
+        const shape = getZodObjectShape(schema);
+        const placeholderFields = {};
+        // Add parent relationship placeholders (includes self-refs acting as parents)
+        const parentDirRels = getParentDirectionRelationships(relationships);
+        for (const relationship of parentDirRels) {
+            if (relationship.contextPolicy?.enabled === false) {
+                continue;
+            }
+            const fieldName = this.getRelationshipObjectFieldName(relationship, relationship.resourceType1, ResourceRelationshipCardinality.ONE, registry);
+            // Only add if field doesn't already exist (avoid conflicts)
+            if (!shape[fieldName]) {
+                // Placeholder format: parentResourceType?: { _id: string }
+                placeholderFields[fieldName] = z.object({
+                    _id: z.string()
+                }).optional();
+            }
+        }
+        // Add child relationship placeholders (includes self-refs acting as children)
+        // Children with contextPolicy enabled are populated in CONTEXT mode
+        const childDirRels = getChildDirectionRelationships(relationships);
+        for (const relationship of childDirRels) {
+            // Skip relationships without contextPolicy or with disabled contextPolicy
+            if (!relationship.contextPolicy) {
+                continue;
+            }
+            // Skip if contextPolicy is explicitly disabled
+            if (relationship.contextPolicy.enabled === false) {
+                continue;
+            }
+            const fieldName = this.getRelationshipObjectFieldName(relationship, relationship.resourceType2, relationship.cardinality2, registry);
+            const isOneToOne = isOneToOneCardinality(relationship.cardinality2);
+            // Only add if field doesn't already exist (avoid conflicts)
+            if (!shape[fieldName]) {
+                // Use a passthrough schema to allow any fields from the child
+                // Zod 4 requires key and value schemas for z.record
+                const childPlaceholder = z.record(z.string(), z.any());
+                if (isOneToOne) {
+                    // 1:1: single object (optional)
+                    placeholderFields[fieldName] = childPlaceholder.optional();
+                }
+                else {
+                    // 1:many: array of objects (optional)
+                    placeholderFields[fieldName] = z.array(childPlaceholder).optional();
+                }
+            }
+        }
+        // Merge placeholders with existing schema
+        if (Object.keys(placeholderFields).length > 0) {
+            return schema.extend(placeholderFields);
+        }
+        return schema;
+    }
+    /**
+     * Transform object dates from strings to Date objects (for incoming requests).
+     * Uses DTO schema to identify which fields are dates.
+     *
+     * @param data - Object to transform
+     * @param dtoSchema - DTO schema (with z.coerce.date() fields)
+     * @returns Transformed object with Date objects
+     */
+    static transformRequestDates(data, dtoSchema) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        // Handle arrays
+        if (Array.isArray(data)) {
+            const zodType = getZodType(dtoSchema);
+            if (zodType === 'array') {
+                // ZodArray stores element schema in _def.element (not _def.type)
+                const elementSchema = getZodDefProperty(dtoSchema, 'element');
+                if (elementSchema) {
+                    return data.map(item => this.transformRequestDates(item, elementSchema));
+                }
+            }
+            return data;
+        }
+        // Handle objects
+        if (isZodObject(dtoSchema)) {
+            const shape = getZodObjectShape(dtoSchema);
+            const transformed = {};
+            for (const [key, value] of Object.entries(data)) {
+                const fieldSchema = shape[key];
+                if (fieldSchema) {
+                    // Check if field is a date (coerced or regular)
+                    const zodType = getZodType(fieldSchema);
+                    if (zodType === 'date' || hasZodType(fieldSchema, 'date')) {
+                        // Transform string to Date
+                        if (typeof value === 'string') {
+                            transformed[key] = new Date(value);
+                        }
+                        else {
+                            transformed[key] = value;
+                        }
+                    }
+                    else {
+                        // Recursively transform nested objects/arrays
+                        transformed[key] = this.transformRequestDates(value, fieldSchema);
+                    }
+                }
+                else {
+                    transformed[key] = value;
+                }
+            }
+            return transformed;
+        }
+        return data;
+    }
+    /**
+     * Transform object dates from Date objects to ISO strings (for outgoing responses).
+     * Uses DTO schema to identify which fields are dates.
+     *
+     * @param data - Object to transform
+     * @param dtoSchema - DTO schema (with z.coerce.date() fields)
+     * @returns Transformed object with ISO string dates
+     */
+    static transformResponseDates(data, dtoSchema) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        // Handle arrays
+        if (Array.isArray(data)) {
+            const zodType = getZodType(dtoSchema);
+            if (zodType === 'array') {
+                // ZodArray stores element schema in _def.element (not _def.type)
+                const elementSchema = getZodDefProperty(dtoSchema, 'element');
+                if (elementSchema) {
+                    return data.map(item => this.transformResponseDates(item, elementSchema));
+                }
+            }
+            return data;
+        }
+        // Handle objects
+        if (isZodObject(dtoSchema)) {
+            const shape = getZodObjectShape(dtoSchema);
+            const transformed = {};
+            for (const [key, value] of Object.entries(data)) {
+                const fieldSchema = shape[key];
+                if (fieldSchema) {
+                    // Check if field is a date (coerced or regular)
+                    const zodType = getZodType(fieldSchema);
+                    if (zodType === 'date' || hasZodType(fieldSchema, 'date')) {
+                        // Transform Date to ISO string
+                        if (value instanceof Date) {
+                            transformed[key] = value.toISOString();
+                        }
+                        else {
+                            transformed[key] = value;
+                        }
+                    }
+                    else {
+                        // Recursively transform nested objects/arrays
+                        transformed[key] = this.transformResponseDates(value, fieldSchema);
+                    }
+                }
+                else {
+                    transformed[key] = value;
+                }
+            }
+            return transformed;
+        }
+        return data;
+    }
+    /**
+     * Select the appropriate response DTO based on DataMode.
+     * Used by both backend and frontend services to ensure consistent DTO selection.
+     *
+     * IMPORTANT: Handles structure differences between single-item and collection operations:
+     * - Single item (READ, CREATE, etc.): Returns item schema
+     * - Collection (LIST, SEARCH): Returns pagination wrapper schema
+     *
+     * Priority:
+     * 1. If operation has variantKey → return operation.responseDto (already variant-specific)
+     * 2. If DataMode is SUMMARY and summaryDto exists → return summaryDto (wrapped for LIST/SEARCH)
+     * 3. If DataMode is CONTEXT and contextDto exists → return contextDto (wrapped for LIST/SEARCH)
+     * 4. Otherwise → return responseDto (default for RAW mode)
+     *
+     * @param operation - The resource operation configuration
+     * @param dataMode - The data mode (defaults to RAW if not specified)
+     * @returns The selected DTO schema, or null/undefined if not available
+     */
+    static selectResponseDto(operation, dataMode) {
+        if (!operation) {
+            return null;
+        }
+        // For variant operations (with variantKey), responseDto is already correct
+        // (built in buildAllOperationDtos with correct structure for LIST/SEARCH)
+        if (operation.variantKey) {
+            return operation.responseDto || null;
+        }
+        const effectiveDataMode = dataMode || DataMode.RAW;
+        const effectiveOperation = operation.resourceOperationLike || operation.operationIdentifier;
+        const isListOrSearch = effectiveOperation === CoreResourceOperation.LIST
+            || effectiveOperation === CoreResourceOperation.SEARCH;
+        // For default operations with dataMode specified, select and wrap appropriately
+        if (effectiveDataMode === DataMode.SUMMARY && operation.summaryDto) {
+            return isListOrSearch
+                ? this.wrapInPaginationStructure(operation.summaryDto)
+                : operation.summaryDto;
+        }
+        if (effectiveDataMode === DataMode.CONTEXT && operation.contextDto) {
+            return isListOrSearch
+                ? this.wrapInPaginationStructure(operation.contextDto)
+                : operation.contextDto;
+        }
+        // Default to responseDto for RAW mode or when specific DTOs are not available
+        return operation.responseDto || null;
+    }
+    /**
+     * Wrap item schema in pagination structure for LIST/SEARCH operations
+     * @param itemSchema - Schema for individual items
+     * @returns Pagination wrapper schema
+     */
+    static wrapInPaginationStructure(itemSchema) {
+        return z.object({
+            data: z.array(itemSchema),
+            pagination: Resouces_PaginationResponseMetadataSchema
+        });
+    }
+}
+//# sourceMappingURL=resources-config-operations.dtos-builder.utils.js.map