@cheetah.js/orm 0.1.35 → 0.1.37

package/dist/bun/index.js

@@ -23556,15 +23556,15 @@ ${lanes.join("\n")}
       return predicate && predicate.kind === 0;
     }
     function forEachPropertyAssignment(objectLiteral, key, callback, key2) {
-      return forEach(objectLiteral == null ? undefined : objectLiteral.properties, (property2) => {
-        if (!isPropertyAssignment(property2))
+      return forEach(objectLiteral == null ? undefined : objectLiteral.properties, (property3) => {
+        if (!isPropertyAssignment(property3))
           return;
-        const propName = tryGetTextOfPropertyName(property2.name);
-        return key === propName || key2 && key2 === propName ? callback(property2) : undefined;
+        const propName = tryGetTextOfPropertyName(property3.name);
+        return key === propName || key2 && key2 === propName ? callback(property3) : undefined;
       });
     }
     function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
-      return forEachPropertyAssignment(objectLiteral, propKey, (property2) => isArrayLiteralExpression(property2.initializer) ? find(property2.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
+      return forEachPropertyAssignment(objectLiteral, propKey, (property3) => isArrayLiteralExpression(property3.initializer) ? find(property3.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
     }
     function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
       if (tsConfigSourceFile && tsConfigSourceFile.statements.length) {
@@ -23573,7 +23573,7 @@ ${lanes.join("\n")}
       }
     }
     function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) {
-      return forEachTsConfigPropArray(tsConfigSourceFile, propKey, (property2) => isArrayLiteralExpression(property2.initializer) ? find(property2.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
+      return forEachTsConfigPropArray(tsConfigSourceFile, propKey, (property3) => isArrayLiteralExpression(property3.initializer) ? find(property3.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : undefined);
     }
     function forEachTsConfigPropArray(tsConfigSourceFile, propKey, callback) {
       return forEachPropertyAssignment(getTsConfigObjectLiteralExpression(tsConfigSourceFile), propKey, callback);
@@ -35048,10 +35048,10 @@ ${lanes.join("\n")}
         return setParent(setTextRange(factory2.cloneNode(memberName), memberName), memberName.parent);
       }
     }
-    function createExpressionForAccessorDeclaration(factory2, properties, property2, receiver, multiLine) {
-      const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property2);
-      if (property2 === firstAccessor) {
-        return setTextRange(factory2.createObjectDefinePropertyCall(receiver, createExpressionForPropertyName(factory2, property2.name), factory2.createPropertyDescriptor({
+    function createExpressionForAccessorDeclaration(factory2, properties, property3, receiver, multiLine) {
+      const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property3);
+      if (property3 === firstAccessor) {
+        return setTextRange(factory2.createObjectDefinePropertyCall(receiver, createExpressionForPropertyName(factory2, property3.name), factory2.createPropertyDescriptor({
           enumerable: factory2.createFalse(),
           configurable: true,
           get: getAccessor && setTextRange(setOriginalNode(factory2.createFunctionExpression(getModifiers(getAccessor), undefined, undefined, undefined, getAccessor.parameters, undefined, getAccessor.body), getAccessor), getAccessor),
@@ -35060,29 +35060,29 @@ ${lanes.join("\n")}
       }
       return;
     }
-    function createExpressionForPropertyAssignment(factory2, property2, receiver) {
-      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property2.name, property2.name), property2.initializer), property2), property2);
+    function createExpressionForPropertyAssignment(factory2, property3, receiver) {
+      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property3.name, property3.name), property3.initializer), property3), property3);
     }
-    function createExpressionForShorthandPropertyAssignment(factory2, property2, receiver) {
-      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property2.name, property2.name), factory2.cloneNode(property2.name)), property2), property2);
+    function createExpressionForShorthandPropertyAssignment(factory2, property3, receiver) {
+      return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, property3.name, property3.name), factory2.cloneNode(property3.name)), property3), property3);
     }
     function createExpressionForMethodDeclaration(factory2, method, receiver) {
       return setOriginalNode(setTextRange(factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, method.name, method.name), setOriginalNode(setTextRange(factory2.createFunctionExpression(getModifiers(method), method.asteriskToken, undefined, undefined, method.parameters, undefined, method.body), method), method)), method), method);
     }
-    function createExpressionForObjectLiteralElementLike(factory2, node, property2, receiver) {
-      if (property2.name && isPrivateIdentifier(property2.name)) {
-        Debug.failBadSyntaxKind(property2.name, "Private identifiers are not allowed in object literals.");
+    function createExpressionForObjectLiteralElementLike(factory2, node, property3, receiver) {
+      if (property3.name && isPrivateIdentifier(property3.name)) {
+        Debug.failBadSyntaxKind(property3.name, "Private identifiers are not allowed in object literals.");
       }
-      switch (property2.kind) {
+      switch (property3.kind) {
         case 177:
         case 178:
-          return createExpressionForAccessorDeclaration(factory2, node.properties, property2, receiver, !!node.multiLine);
+          return createExpressionForAccessorDeclaration(factory2, node.properties, property3, receiver, !!node.multiLine);
         case 303:
-          return createExpressionForPropertyAssignment(factory2, property2, receiver);
+          return createExpressionForPropertyAssignment(factory2, property3, receiver);
         case 304:
-          return createExpressionForShorthandPropertyAssignment(factory2, property2, receiver);
+          return createExpressionForShorthandPropertyAssignment(factory2, property3, receiver);
         case 174:
-          return createExpressionForMethodDeclaration(factory2, property2, receiver);
+          return createExpressionForMethodDeclaration(factory2, property3, receiver);
       }
     }
     function expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, recordTempVariable, resultVariable) {
@@ -43484,7 +43484,7 @@ ${lanes.join("\n")}
             if (sourceFile) {
               const fileName = configFileName || "tsconfig.json";
               const diagnosticMessage = Diagnostics.The_files_list_in_config_file_0_is_empty;
-              const nodeValue = forEachTsConfigPropArray(sourceFile, "files", (property2) => property2.initializer);
+              const nodeValue = forEachTsConfigPropArray(sourceFile, "files", (property3) => property3.initializer);
               const error2 = createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, nodeValue, diagnosticMessage, fileName);
               errors.push(error2);
             } else {
@@ -51498,9 +51498,9 @@ ${lanes.join("\n")}
           const node = getParseTreeNode(nodeIn, isPropertyAccessOrQualifiedNameOrImportTypeNode);
           return !!node && isValidPropertyAccess(node, escapeLeadingUnderscores(propertyName));
         },
-        isValidPropertyAccessForCompletions: (nodeIn, type, property2) => {
+        isValidPropertyAccessForCompletions: (nodeIn, type, property3) => {
           const node = getParseTreeNode(nodeIn, isPropertyAccessExpression);
-          return !!node && isValidPropertyAccessForCompletions(node, type, property2);
+          return !!node && isValidPropertyAccessForCompletions(node, type, property3);
         },
         getSignatureFromDeclaration: (declarationIn) => {
           const declaration = getParseTreeNode(declarationIn, isFunctionLike);
@@ -60069,11 +60069,11 @@ ${lanes.join("\n")}
       }
       function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) {
         const list = obj.properties;
-        return list.some((property2) => {
-          const nameType = property2.name && (isJsxNamespacedName(property2.name) ? getStringLiteralType(getTextOfJsxAttributeName(property2.name)) : getLiteralTypeFromPropertyName(property2.name));
+        return list.some((property3) => {
+          const nameType = property3.name && (isJsxNamespacedName(property3.name) ? getStringLiteralType(getTextOfJsxAttributeName(property3.name)) : getLiteralTypeFromPropertyName(property3.name));
           const name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined;
           const expected = name === undefined ? undefined : getTypeOfPropertyOfType(contextualType, name);
-          return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property2), expected);
+          return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property3), expected);
         });
       }
       function getAllPossiblePropertiesOfTypes(types) {
@@ -60499,15 +60499,15 @@ ${lanes.join("\n")}
       }
       function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
         var _a, _b;
-        let property2 = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? undefined : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? undefined : _b.get(name) : undefined;
-        if (!property2) {
-          property2 = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
-          if (property2) {
+        let property3 = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? undefined : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? undefined : _b.get(name) : undefined;
+        if (!property3) {
+          property3 = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
+          if (property3) {
             const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
-            properties.set(name, property2);
+            properties.set(name, property3);
           }
         }
-        return property2;
+        return property3;
       }
       function getCommonDeclarationsOfSymbols(symbols) {
         let commonDeclarations;
@@ -60531,8 +60531,8 @@ ${lanes.join("\n")}
         return commonDeclarations;
       }
       function getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment) {
-        const property2 = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
-        return property2 && !(getCheckFlags(property2) & 16) ? property2 : undefined;
+        const property3 = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
+        return property3 && !(getCheckFlags(property3) & 16) ? property3 : undefined;
       }
       function getReducedType(type) {
         if (type.flags & 1048576 && type.objectFlags & 16777216) {
@@ -61979,10 +61979,10 @@ ${lanes.join("\n")}
             const flags = elementFlags[i];
             combinedFlags |= flags;
             if (!(combinedFlags & 12)) {
-              const property2 = createSymbol(4 | (flags & 2 ? 16777216 : 0), "" + i, readonly ? 8 : 0);
-              property2.links.tupleLabelDeclaration = namedMemberDeclarations == null ? undefined : namedMemberDeclarations[i];
-              property2.links.type = typeParameter;
-              properties.push(property2);
+              const property3 = createSymbol(4 | (flags & 2 ? 16777216 : 0), "" + i, readonly ? 8 : 0);
+              property3.links.tupleLabelDeclaration = namedMemberDeclarations == null ? undefined : namedMemberDeclarations[i];
+              property3.links.type = typeParameter;
+              properties.push(property3);
             }
           }
         }
@@ -62995,8 +62995,8 @@ ${lanes.join("\n")}
                 diagnostics.add(createDiagnosticForNode(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)));
                 return undefinedType;
               } else if (indexType.flags & (8 | 4)) {
-                const types = map(objectType.properties, (property2) => {
-                  return getTypeOfSymbol(property2);
+                const types = map(objectType.properties, (property3) => {
+                  return getTypeOfSymbol(property3);
                 });
                 return getUnionType(append(types, undefinedType));
               }
@@ -64991,12 +64991,12 @@ ${lanes.join("\n")}
           return !!(entry & 1);
         }
         const targetEnumType = getTypeOfSymbol(targetSymbol);
-        for (const property2 of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
-          if (property2.flags & 8) {
-            const targetProperty = getPropertyOfType(targetEnumType, property2.escapedName);
+        for (const property3 of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
+          if (property3.flags & 8) {
+            const targetProperty = getPropertyOfType(targetEnumType, property3.escapedName);
             if (!targetProperty || !(targetProperty.flags & 8)) {
               if (errorReporter) {
-                errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(property2), typeToString(getDeclaredTypeOfSymbol(targetSymbol), undefined, 64));
+                errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(property3), typeToString(getDeclaredTypeOfSymbol(targetSymbol), undefined, 64));
                 enumRelation.set(id, 2 | 4);
               } else {
                 enumRelation.set(id, 2);
@@ -67073,10 +67073,10 @@ ${lanes.join("\n")}
       function getDeclaringClass(prop) {
         return prop.parent && prop.parent.flags & 32 ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : undefined;
       }
-      function getTypeOfPropertyInBaseClass(property2) {
-        const classType = getDeclaringClass(property2);
+      function getTypeOfPropertyInBaseClass(property3) {
+        const classType = getDeclaringClass(property3);
         const baseClassType = classType && getBaseTypes(classType)[0];
-        return baseClassType && getTypeOfPropertyOfType(baseClassType, property2.escapedName);
+        return baseClassType && getTypeOfPropertyOfType(baseClassType, property3.escapedName);
       }
       function isPropertyInClassDerivedFrom(prop, baseClass) {
         return forEachProperty2(prop, (sp) => {
@@ -67505,10 +67505,10 @@ ${lanes.join("\n")}
       }
       function transformTypeOfMembers(type, f) {
         const members = createSymbolTable();
-        for (const property2 of getPropertiesOfObjectType(type)) {
-          const original = getTypeOfSymbol(property2);
+        for (const property3 of getPropertiesOfObjectType(type)) {
+          const original = getTypeOfSymbol(property3);
           const updated = f(original);
-          members.set(property2.escapedName, updated === original ? property2 : createSymbolWithType(property2, updated));
+          members.set(property3.escapedName, updated === original ? property3 : createSymbolWithType(property3, updated));
         }
         return members;
       }
@@ -73573,8 +73573,8 @@ ${lanes.join("\n")}
             return isValidPropertyAccessWithType(node, false, propertyName, getTypeFromTypeNode(node));
         }
       }
-      function isValidPropertyAccessForCompletions(node, type, property2) {
-        return isPropertyAccessible(node, node.kind === 211 && node.expression.kind === 108, false, type, property2);
+      function isValidPropertyAccessForCompletions(node, type, property3) {
+        return isPropertyAccessible(node, node.kind === 211 && node.expression.kind === 108, false, type, property3);
       }
       function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
         if (isTypeAny(type)) {
@@ -73583,15 +73583,15 @@ ${lanes.join("\n")}
         const prop = getPropertyOfType(type, propertyName);
         return !!prop && isPropertyAccessible(node, isSuper, false, type, prop);
       }
-      function isPropertyAccessible(node, isSuper, isWrite, containingType, property2) {
+      function isPropertyAccessible(node, isSuper, isWrite, containingType, property3) {
         if (isTypeAny(containingType)) {
           return true;
         }
-        if (property2.valueDeclaration && isPrivateIdentifierClassElementDeclaration(property2.valueDeclaration)) {
-          const declClass = getContainingClass(property2.valueDeclaration);
+        if (property3.valueDeclaration && isPrivateIdentifierClassElementDeclaration(property3.valueDeclaration)) {
+          const declClass = getContainingClass(property3.valueDeclaration);
           return !isOptionalChain(node) && !!findAncestor(node, (parent2) => parent2 === declClass);
         }
-        return checkPropertyAccessibilityAtLocation(node, isSuper, isWrite, containingType, property2);
+        return checkPropertyAccessibilityAtLocation(node, isSuper, isWrite, containingType, property3);
       }
       function getForInVariableSymbol(node) {
         const initializer = node.initializer;
@@ -76688,27 +76688,27 @@ ${lanes.join("\n")}
       }
       function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis = false) {
         const properties = node.properties;
-        const property2 = properties[propertyIndex];
-        if (property2.kind === 303 || property2.kind === 304) {
-          const name = property2.name;
+        const property3 = properties[propertyIndex];
+        if (property3.kind === 303 || property3.kind === 304) {
+          const name = property3.name;
           const exprType = getLiteralTypeFromPropertyName(name);
           if (isTypeUsableAsPropertyName(exprType)) {
             const text = getPropertyNameFromType(exprType);
             const prop = getPropertyOfType(objectLiteralType, text);
             if (prop) {
-              markPropertyAsReferenced(prop, property2, rightIsThis);
-              checkPropertyAccessibility(property2, false, true, objectLiteralType, prop);
+              markPropertyAsReferenced(prop, property3, rightIsThis);
+              checkPropertyAccessibility(property3, false, true, objectLiteralType, prop);
             }
           }
           const elementType = getIndexedAccessType(objectLiteralType, exprType, 32, name);
-          const type = getFlowTypeOfDestructuring(property2, elementType);
-          return checkDestructuringAssignment(property2.kind === 304 ? property2 : property2.initializer, type);
-        } else if (property2.kind === 305) {
+          const type = getFlowTypeOfDestructuring(property3, elementType);
+          return checkDestructuringAssignment(property3.kind === 304 ? property3 : property3.initializer, type);
+        } else if (property3.kind === 305) {
           if (propertyIndex < properties.length - 1) {
-            error2(property2, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
+            error2(property3, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
           } else {
             if (languageVersion < 99) {
-              checkExternalEmitHelpers(property2, 4);
+              checkExternalEmitHelpers(property3, 4);
             }
             const nonRestNames = [];
             if (allProperties) {
@@ -76720,10 +76720,10 @@ ${lanes.join("\n")}
             }
             const type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol);
             checkGrammarForDisallowedTrailingComma(allProperties, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
-            return checkDestructuringAssignment(property2.expression, type);
+            return checkDestructuringAssignment(property3.expression, type);
           }
         } else {
-          error2(property2, Diagnostics.Property_assignment_expected);
+          error2(property3, Diagnostics.Property_assignment_expected);
         }
       }
       function checkArrayLiteralAssignment(node, sourceType, checkMode) {
@@ -79983,10 +79983,10 @@ ${lanes.join("\n")}
             const exprType = getLiteralTypeFromPropertyName(name);
             if (isTypeUsableAsPropertyName(exprType)) {
               const nameText = getPropertyNameFromType(exprType);
-              const property2 = getPropertyOfType(parentType, nameText);
-              if (property2) {
-                markPropertyAsReferenced(property2, undefined, false);
-                checkPropertyAccessibility(node, !!parent2.initializer && parent2.initializer.kind === 108, false, parentType, property2);
+              const property3 = getPropertyOfType(parentType, nameText);
+              if (property3) {
+                markPropertyAsReferenced(property3, undefined, false);
+                checkPropertyAccessibility(node, !!parent2.initializer && parent2.initializer.kind === 108, false, parentType, property3);
               }
             }
           }
@@ -87696,8 +87696,8 @@ ${lanes.join("\n")}
       }
       return { decorators: decorators5, parameters };
     }
-    function getAllDecoratorsOfProperty(property2) {
-      const decorators5 = getDecorators(property2);
+    function getAllDecoratorsOfProperty(property3) {
+      const decorators5 = getDecorators(property3);
       if (!some(decorators5)) {
         return;
       }
@@ -90695,7 +90695,7 @@ ${lanes.join("\n")}
         const instanceProperties = getProperties(node, false, false);
         let properties = instanceProperties;
         if (!useDefineForClassFields) {
-          properties = filter(properties, (property2) => !!property2.initializer || isPrivateIdentifier(property2.name) || hasAccessorModifier(property2));
+          properties = filter(properties, (property3) => !!property3.initializer || isPrivateIdentifier(property3.name) || hasAccessorModifier(property3));
         }
         const privateMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node);
         const needsConstructorBody = some(properties) || some(privateMethodsAndAccessors);
@@ -90748,32 +90748,32 @@ ${lanes.join("\n")}
         return setTextRange(factory2.createBlock(setTextRange(factory2.createNodeArray(statements), constructor ? constructor.body.statements : node.members), multiLine), constructor ? constructor.body : undefined);
       }
       function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
-        for (const property2 of properties) {
-          if (isStatic(property2) && !shouldTransformPrivateElementsOrClassStaticBlocks) {
+        for (const property3 of properties) {
+          if (isStatic(property3) && !shouldTransformPrivateElementsOrClassStaticBlocks) {
             continue;
           }
-          const statement = transformPropertyOrClassStaticBlock(property2, receiver);
+          const statement = transformPropertyOrClassStaticBlock(property3, receiver);
           if (!statement) {
             continue;
           }
           statements.push(statement);
         }
       }
-      function transformPropertyOrClassStaticBlock(property2, receiver) {
-        const expression = isClassStaticBlockDeclaration(property2) ? setCurrentClassElementAnd(property2, transformClassStaticBlockDeclaration, property2) : transformProperty(property2, receiver);
+      function transformPropertyOrClassStaticBlock(property3, receiver) {
+        const expression = isClassStaticBlockDeclaration(property3) ? setCurrentClassElementAnd(property3, transformClassStaticBlockDeclaration, property3) : transformProperty(property3, receiver);
         if (!expression) {
           return;
         }
         const statement = factory2.createExpressionStatement(expression);
-        setOriginalNode(statement, property2);
-        addEmitFlags(statement, getEmitFlags(property2) & 3072);
-        setCommentRange(statement, property2);
-        const propertyOriginalNode = getOriginalNode(property2);
+        setOriginalNode(statement, property3);
+        addEmitFlags(statement, getEmitFlags(property3) & 3072);
+        setCommentRange(statement, property3);
+        const propertyOriginalNode = getOriginalNode(property3);
         if (isParameter(propertyOriginalNode)) {
           setSourceMapRange(statement, propertyOriginalNode);
           removeAllComments(statement);
         } else {
-          setSourceMapRange(statement, moveRangePastModifiers(property2));
+          setSourceMapRange(statement, moveRangePastModifiers(property3));
         }
         setSyntheticLeadingComments(expression, undefined);
         setSyntheticTrailingComments(expression, undefined);
@@ -90784,50 +90784,50 @@ ${lanes.join("\n")}
       }
       function generateInitializedPropertyExpressionsOrClassStaticBlock(propertiesOrClassStaticBlocks, receiver) {
         const expressions = [];
-        for (const property2 of propertiesOrClassStaticBlocks) {
-          const expression = isClassStaticBlockDeclaration(property2) ? setCurrentClassElementAnd(property2, transformClassStaticBlockDeclaration, property2) : setCurrentClassElementAnd(property2, () => transformProperty(property2, receiver), undefined);
+        for (const property3 of propertiesOrClassStaticBlocks) {
+          const expression = isClassStaticBlockDeclaration(property3) ? setCurrentClassElementAnd(property3, transformClassStaticBlockDeclaration, property3) : setCurrentClassElementAnd(property3, () => transformProperty(property3, receiver), undefined);
           if (!expression) {
             continue;
           }
           startOnNewLine(expression);
-          setOriginalNode(expression, property2);
-          addEmitFlags(expression, getEmitFlags(property2) & 3072);
-          setSourceMapRange(expression, moveRangePastModifiers(property2));
-          setCommentRange(expression, property2);
+          setOriginalNode(expression, property3);
+          addEmitFlags(expression, getEmitFlags(property3) & 3072);
+          setSourceMapRange(expression, moveRangePastModifiers(property3));
+          setCommentRange(expression, property3);
           expressions.push(expression);
         }
         return expressions;
       }
-      function transformProperty(property2, receiver) {
+      function transformProperty(property3, receiver) {
         var _a;
         const savedCurrentClassElement = currentClassElement;
-        const transformed = transformPropertyWorker(property2, receiver);
-        if (transformed && hasStaticModifier(property2) && ((_a = lexicalEnvironment == null ? undefined : lexicalEnvironment.data) == null ? undefined : _a.facts)) {
-          setOriginalNode(transformed, property2);
+        const transformed = transformPropertyWorker(property3, receiver);
+        if (transformed && hasStaticModifier(property3) && ((_a = lexicalEnvironment == null ? undefined : lexicalEnvironment.data) == null ? undefined : _a.facts)) {
+          setOriginalNode(transformed, property3);
           addEmitFlags(transformed, 4);
-          setSourceMapRange(transformed, getSourceMapRange(property2.name));
-          lexicalEnvironmentMap.set(getOriginalNode(property2), lexicalEnvironment);
+          setSourceMapRange(transformed, getSourceMapRange(property3.name));
+          lexicalEnvironmentMap.set(getOriginalNode(property3), lexicalEnvironment);
         }
         currentClassElement = savedCurrentClassElement;
         return transformed;
       }
-      function transformPropertyWorker(property2, receiver) {
+      function transformPropertyWorker(property3, receiver) {
         const emitAssignment = !useDefineForClassFields;
-        if (isNamedEvaluation(property2, isAnonymousClassNeedingAssignedName)) {
-          property2 = transformNamedEvaluation(context, property2);
+        if (isNamedEvaluation(property3, isAnonymousClassNeedingAssignedName)) {
+          property3 = transformNamedEvaluation(context, property3);
         }
-        const propertyName = hasAccessorModifier(property2) ? factory2.getGeneratedPrivateNameForNode(property2.name) : isComputedPropertyName(property2.name) && !isSimpleInlineableExpression(property2.name.expression) ? factory2.updateComputedPropertyName(property2.name, factory2.getGeneratedNameForNode(property2.name)) : property2.name;
-        if (hasStaticModifier(property2)) {
-          currentClassElement = property2;
+        const propertyName = hasAccessorModifier(property3) ? factory2.getGeneratedPrivateNameForNode(property3.name) : isComputedPropertyName(property3.name) && !isSimpleInlineableExpression(property3.name.expression) ? factory2.updateComputedPropertyName(property3.name, factory2.getGeneratedNameForNode(property3.name)) : property3.name;
+        if (hasStaticModifier(property3)) {
+          currentClassElement = property3;
         }
-        if (isPrivateIdentifier(propertyName) && shouldTransformClassElementToWeakMap(property2)) {
+        if (isPrivateIdentifier(propertyName) && shouldTransformClassElementToWeakMap(property3)) {
           const privateIdentifierInfo = accessPrivateIdentifier2(propertyName);
           if (privateIdentifierInfo) {
             if (privateIdentifierInfo.kind === "f") {
               if (!privateIdentifierInfo.isStatic) {
-                return createPrivateInstanceFieldInitializer(factory2, receiver, visitNode(property2.initializer, visitor, isExpression), privateIdentifierInfo.brandCheckIdentifier);
+                return createPrivateInstanceFieldInitializer(factory2, receiver, visitNode(property3.initializer, visitor, isExpression), privateIdentifierInfo.brandCheckIdentifier);
               } else {
-                return createPrivateStaticFieldInitializer(factory2, privateIdentifierInfo.variableName, visitNode(property2.initializer, visitor, isExpression));
+                return createPrivateStaticFieldInitializer(factory2, privateIdentifierInfo.variableName, visitNode(property3.initializer, visitor, isExpression));
               }
             } else {
               return;
@@ -90836,14 +90836,14 @@ ${lanes.join("\n")}
             Debug.fail("Undeclared private name for property declaration.");
           }
         }
-        if ((isPrivateIdentifier(propertyName) || hasStaticModifier(property2)) && !property2.initializer) {
+        if ((isPrivateIdentifier(propertyName) || hasStaticModifier(property3)) && !property3.initializer) {
           return;
         }
-        const propertyOriginalNode = getOriginalNode(property2);
+        const propertyOriginalNode = getOriginalNode(property3);
         if (hasSyntacticModifier(propertyOriginalNode, 256)) {
           return;
         }
-        let initializer = visitNode(property2.initializer, visitor, isExpression);
+        let initializer = visitNode(property3.initializer, visitor, isExpression);
         if (isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && isIdentifier(propertyName)) {
           const localName = factory2.cloneNode(propertyName);
           if (initializer) {
@@ -96854,8 +96854,8 @@ ${lanes.join("\n")}
         const properties = node.properties;
         let numInitialProperties = -1, hasComputed = false;
         for (let i = 0;i < properties.length; i++) {
-          const property2 = properties[i];
-          if (property2.transformFlags & 1048576 && hierarchyFacts & 4 || (hasComputed = Debug.checkDefined(property2.name).kind === 167)) {
+          const property3 = properties[i];
+          if (property3.transformFlags & 1048576 && hierarchyFacts & 4 || (hasComputed = Debug.checkDefined(property3.name).kind === 167)) {
             numInitialProperties = i;
             break;
           }
@@ -97239,23 +97239,23 @@ ${lanes.join("\n")}
         const properties = node.properties;
         const numProperties = properties.length;
         for (let i = start;i < numProperties; i++) {
-          const property2 = properties[i];
-          switch (property2.kind) {
+          const property3 = properties[i];
+          switch (property3.kind) {
             case 177:
             case 178:
-              const accessors = getAllAccessorDeclarations(node.properties, property2);
-              if (property2 === accessors.firstAccessor) {
+              const accessors = getAllAccessorDeclarations(node.properties, property3);
+              if (property3 === accessors.firstAccessor) {
                 expressions.push(transformAccessorsToExpression(receiver, accessors, node, !!node.multiLine));
               }
               break;
             case 174:
-              expressions.push(transformObjectLiteralMethodDeclarationToExpression(property2, receiver, node, node.multiLine));
+              expressions.push(transformObjectLiteralMethodDeclarationToExpression(property3, receiver, node, node.multiLine));
               break;
             case 303:
-              expressions.push(transformPropertyAssignmentToExpression(property2, receiver, node.multiLine));
+              expressions.push(transformPropertyAssignmentToExpression(property3, receiver, node.multiLine));
               break;
             case 304:
-              expressions.push(transformShorthandPropertyAssignmentToExpression(property2, receiver, node.multiLine));
+              expressions.push(transformShorthandPropertyAssignmentToExpression(property3, receiver, node.multiLine));
               break;
             default:
               Debug.failBadSyntaxKind(node);
@@ -97263,17 +97263,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function transformPropertyAssignmentToExpression(property2, receiver, startsOnNewLine) {
-        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property2.name, visitor, isPropertyName))), Debug.checkDefined(visitNode(property2.initializer, visitor, isExpression)));
-        setTextRange(expression, property2);
+      function transformPropertyAssignmentToExpression(property3, receiver, startsOnNewLine) {
+        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property3.name, visitor, isPropertyName))), Debug.checkDefined(visitNode(property3.initializer, visitor, isExpression)));
+        setTextRange(expression, property3);
         if (startsOnNewLine) {
           startOnNewLine(expression);
         }
         return expression;
       }
-      function transformShorthandPropertyAssignmentToExpression(property2, receiver, startsOnNewLine) {
-        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property2.name, visitor, isPropertyName))), factory2.cloneNode(property2.name));
-        setTextRange(expression, property2);
+      function transformShorthandPropertyAssignmentToExpression(property3, receiver, startsOnNewLine) {
+        const expression = factory2.createAssignment(createMemberAccessForPropertyName(factory2, receiver, Debug.checkDefined(visitNode(property3.name, visitor, isPropertyName))), factory2.cloneNode(property3.name));
+        setTextRange(expression, property3);
         if (startsOnNewLine) {
           startOnNewLine(expression);
         }
@@ -98150,12 +98150,12 @@ ${lanes.join("\n")}
         const expressions = reduceLeft(properties, reduceProperty, [], numInitialProperties);
         expressions.push(multiLine ? startOnNewLine(setParent(setTextRange(factory2.cloneNode(temp), temp), temp.parent)) : temp);
         return factory2.inlineExpressions(expressions);
-        function reduceProperty(expressions2, property2) {
-          if (containsYield(property2) && expressions2.length > 0) {
+        function reduceProperty(expressions2, property3) {
+          if (containsYield(property3) && expressions2.length > 0) {
             emitStatement(factory2.createExpressionStatement(factory2.inlineExpressions(expressions2)));
             expressions2 = [];
           }
-          const expression = createExpressionForObjectLiteralElementLike(factory2, node, property2, temp);
+          const expression = createExpressionForObjectLiteralElementLike(factory2, node, property3, temp);
           const visited = visitNode(expression, visitor, isExpression);
           if (visited) {
             if (multiLine) {
@@ -111458,7 +111458,7 @@ ${lanes.join("\n")}
             if (!referenceInfo)
               return;
             const { sourceFile, index } = referenceInfo;
-            const referencesSyntax = forEachTsConfigPropArray(sourceFile, "references", (property2) => isArrayLiteralExpression(property2.initializer) ? property2.initializer : undefined);
+            const referencesSyntax = forEachTsConfigPropArray(sourceFile, "references", (property3) => isArrayLiteralExpression(property3.initializer) ? property3.initializer : undefined);
             return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(sourceFile, referencesSyntax.elements[index], reason.kind === 2 ? Diagnostics.File_is_output_from_referenced_project_specified_here : Diagnostics.File_is_source_from_referenced_project_specified_here) : undefined;
           case 8:
             if (!options.types)
@@ -111552,7 +111552,7 @@ ${lanes.join("\n")}
         return forEachOptionsSyntaxByName("paths", callback);
       }
       function getOptionsSyntaxByValue(name, value) {
-        return forEachOptionsSyntaxByName(name, (property2) => isStringLiteral(property2.initializer) && property2.initializer.text === value ? property2.initializer : undefined);
+        return forEachOptionsSyntaxByName(name, (property3) => isStringLiteral(property3.initializer) && property3.initializer.text === value ? property3.initializer : undefined);
       }
       function getOptionsSyntaxByArrayElementValue(name, value) {
         const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
@@ -111565,7 +111565,7 @@ ${lanes.join("\n")}
         createDiagnosticForOption(false, option1, undefined, message, ...args);
       }
       function createDiagnosticForReference(sourceFile, index, message, ...args) {
-        const referencesSyntax = forEachTsConfigPropArray(sourceFile || options.configFile, "references", (property2) => isArrayLiteralExpression(property2.initializer) ? property2.initializer : undefined);
+        const referencesSyntax = forEachTsConfigPropArray(sourceFile || options.configFile, "references", (property3) => isArrayLiteralExpression(property3.initializer) ? property3.initializer : undefined);
         if (referencesSyntax && referencesSyntax.elements.length > index) {
           programDiagnostics.add(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, ...args));
         } else {
@@ -122417,25 +122417,25 @@ ${lanes.join("\n")}
       const jsonObjectLiteral = getTsConfigObjectLiteralExpression(configFile);
       if (!jsonObjectLiteral)
         return;
-      forEachProperty(jsonObjectLiteral, (property2, propertyName) => {
+      forEachProperty(jsonObjectLiteral, (property3, propertyName) => {
         switch (propertyName) {
           case "files":
           case "include":
           case "exclude": {
-            const foundExactMatch = updatePaths(property2);
-            if (foundExactMatch || propertyName !== "include" || !isArrayLiteralExpression(property2.initializer))
+            const foundExactMatch = updatePaths(property3);
+            if (foundExactMatch || propertyName !== "include" || !isArrayLiteralExpression(property3.initializer))
               return;
-            const includes = mapDefined(property2.initializer.elements, (e) => isStringLiteral(e) ? e.text : undefined);
+            const includes = mapDefined(property3.initializer.elements, (e) => isStringLiteral(e) ? e.text : undefined);
             if (includes.length === 0)
               return;
             const matchers = getFileMatcherPatterns(configDir, [], includes, useCaseSensitiveFileNames2, currentDirectory);
             if (getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames2).test(oldFileOrDirPath) && !getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames2).test(newFileOrDirPath)) {
-              changeTracker.insertNodeAfter(configFile, last(property2.initializer.elements), factory.createStringLiteral(relativePath(newFileOrDirPath)));
+              changeTracker.insertNodeAfter(configFile, last(property3.initializer.elements), factory.createStringLiteral(relativePath(newFileOrDirPath)));
             }
             return;
           }
           case "compilerOptions":
-            forEachProperty(property2.initializer, (property22, propertyName2) => {
+            forEachProperty(property3.initializer, (property22, propertyName2) => {
               const option = getOptionFromName(propertyName2);
               Debug.assert((option == null ? undefined : option.type) !== "listOrElement");
               if (option && (option.isFilePath || option.type === "list" && option.element.isFilePath)) {
@@ -122453,8 +122453,8 @@ ${lanes.join("\n")}
             return;
         }
       });
-      function updatePaths(property2) {
-        const elements = isArrayLiteralExpression(property2.initializer) ? property2.initializer.elements : [property2.initializer];
+      function updatePaths(property3) {
+        const elements = isArrayLiteralExpression(property3.initializer) ? property3.initializer.elements : [property3.initializer];
         let foundExactMatch = false;
         for (const element of elements) {
           foundExactMatch = tryUpdateString(element) || foundExactMatch;
@@ -122561,9 +122561,9 @@ ${lanes.join("\n")}
     function forEachProperty(objectLiteral, cb) {
       if (!isObjectLiteralExpression(objectLiteral))
         return;
-      for (const property2 of objectLiteral.properties) {
-        if (isPropertyAssignment(property2) && isStringLiteral(property2.name)) {
-          cb(property2, property2.name.text);
+      for (const property3 of objectLiteral.properties) {
+        if (isPropertyAssignment(property3) && isStringLiteral(property3.name)) {
+          cb(property3, property3.name.text);
         }
       }
     }
@@ -126968,12 +126968,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       const nonRestArguments = hasRestParameter2 ? functionArguments.slice(0, parameters.length - 1) : functionArguments;
       const properties = map(nonRestArguments, (arg, i) => {
         const parameterName = getParameterName(parameters[i]);
-        const property2 = createPropertyOrShorthandAssignment(parameterName, arg);
-        suppressLeadingAndTrailingTrivia(property2.name);
-        if (isPropertyAssignment(property2))
-          suppressLeadingAndTrailingTrivia(property2.initializer);
-        copyComments(arg, property2);
-        return property2;
+        const property3 = createPropertyOrShorthandAssignment(parameterName, arg);
+        suppressLeadingAndTrailingTrivia(property3.name);
+        if (isPropertyAssignment(property3))
+          suppressLeadingAndTrailingTrivia(property3.initializer);
+        copyComments(arg, property3);
+        return property3;
       });
       if (hasRestParameter2 && functionArguments.length >= parameters.length) {
         const restArguments = functionArguments.slice(parameters.length - 1);
@@ -133855,12 +133855,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               return true;
             return isFunctionLike(source);
           } else {
-            return every(_target.properties, (property2) => {
-              if (isMethodDeclaration(property2) || isGetOrSetAccessorDeclaration(property2))
+            return every(_target.properties, (property3) => {
+              if (isMethodDeclaration(property3) || isGetOrSetAccessorDeclaration(property3))
                 return true;
-              if (isPropertyAssignment(property2) && isFunctionExpression(property2.initializer) && !!property2.name)
+              if (isPropertyAssignment(property3) && isFunctionExpression(property3.initializer) && !!property3.name)
                 return true;
-              if (isConstructorAssignment(property2))
+              if (isConstructorAssignment(property3))
                 return true;
               return false;
             });
@@ -133899,14 +133899,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
             return;
           } else if (isObjectLiteralExpression(assignmentExpr)) {
-            forEach(assignmentExpr.properties, (property2) => {
-              if (isMethodDeclaration(property2) || isGetOrSetAccessorDeclaration(property2)) {
-                members.push(property2);
+            forEach(assignmentExpr.properties, (property3) => {
+              if (isMethodDeclaration(property3) || isGetOrSetAccessorDeclaration(property3)) {
+                members.push(property3);
               }
-              if (isPropertyAssignment(property2) && isFunctionExpression(property2.initializer)) {
-                createFunctionLikeExpressionMember(members, property2.initializer, property2.name);
+              if (isPropertyAssignment(property3) && isFunctionExpression(property3.initializer)) {
+                createFunctionLikeExpressionMember(members, property3.initializer, property3.name);
               }
-              if (isConstructorAssignment(property2))
+              if (isConstructorAssignment(property3))
                 return;
               return;
             });
@@ -136611,9 +136611,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           fixIds: [fixId18],
           getCodeActions(context) {
             const { sourceFile, span, preferences } = context;
-            const property2 = getPropertyAccessExpression(sourceFile, span.start);
-            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, context.sourceFile, property2, preferences));
-            return [createCodeFixAction(fixId18, changes, [Diagnostics.Use_element_access_for_0, property2.name.text], fixId18, Diagnostics.Use_element_access_for_all_undeclared_properties)];
+            const property3 = getPropertyAccessExpression(sourceFile, span.start);
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, context.sourceFile, property3, preferences));
+            return [createCodeFixAction(fixId18, changes, [Diagnostics.Use_element_access_for_0, property3.name.text], fixId18, Diagnostics.Use_element_access_for_all_undeclared_properties)];
           },
           getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => doChange14(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences))
         });
@@ -137284,12 +137284,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const staticInitialization = initializePropertyToUndefined(factory.createIdentifier(className), tokenName);
         changeTracker.insertNodeAfter(sourceFile, classDeclaration, staticInitialization);
       } else if (isPrivateIdentifier(token)) {
-        const property2 = factory.createPropertyDeclaration(undefined, tokenName, undefined, undefined, undefined);
+        const property3 = factory.createPropertyDeclaration(undefined, tokenName, undefined, undefined, undefined);
         const lastProp = getNodeToInsertPropertyAfter(classDeclaration);
         if (lastProp) {
-          changeTracker.insertNodeAfter(sourceFile, lastProp, property2);
+          changeTracker.insertNodeAfter(sourceFile, lastProp, property3);
         } else {
-          changeTracker.insertMemberAtStart(sourceFile, classDeclaration, property2);
+          changeTracker.insertMemberAtStart(sourceFile, classDeclaration, property3);
         }
       } else {
         const classConstructor = getFirstConstructorWithBody(classDeclaration);
@@ -137333,12 +137333,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function addPropertyDeclaration(changeTracker, sourceFile, node, tokenName, typeNode, modifierFlags) {
       const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : undefined;
-      const property2 = isClassLike(node) ? factory.createPropertyDeclaration(modifiers, tokenName, undefined, typeNode, undefined) : factory.createPropertySignature(undefined, tokenName, undefined, typeNode);
+      const property3 = isClassLike(node) ? factory.createPropertyDeclaration(modifiers, tokenName, undefined, typeNode, undefined) : factory.createPropertySignature(undefined, tokenName, undefined, typeNode);
       const lastProp = getNodeToInsertPropertyAfter(node);
       if (lastProp) {
-        changeTracker.insertNodeAfter(sourceFile, lastProp, property2);
+        changeTracker.insertNodeAfter(sourceFile, lastProp, property3);
       } else {
-        changeTracker.insertMemberAtStart(sourceFile, node, property2);
+        changeTracker.insertMemberAtStart(sourceFile, node, property3);
       }
     }
     function getNodeToInsertPropertyAfter(node) {
@@ -138030,8 +138030,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           fixIds: [fixId29],
           getCodeActions(context) {
             const { sourceFile, span } = context;
-            const property2 = getProperty2(sourceFile, span.start);
-            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange23(t, context.sourceFile, property2));
+            const property3 = getProperty2(sourceFile, span.start);
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange23(t, context.sourceFile, property3));
             return [createCodeFixAction(fixId29, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId29, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])];
           },
           getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes, diag2) => doChange23(changes, diag2.file, getProperty2(diag2.file, diag2.start)))
@@ -140531,8 +140531,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       ], true));
     }
     function updatePropertyDeclaration(changeTracker, file, declaration, type, fieldName, modifiers) {
-      const property2 = factory.updatePropertyDeclaration(declaration, modifiers, fieldName, declaration.questionToken || declaration.exclamationToken, type, declaration.initializer);
-      changeTracker.replaceNode(file, declaration, property2);
+      const property3 = factory.updatePropertyDeclaration(declaration, modifiers, fieldName, declaration.questionToken || declaration.exclamationToken, type, declaration.initializer);
+      changeTracker.replaceNode(file, declaration, property3);
     }
     function updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName) {
       let assignment = factory.updatePropertyAssignment(declaration, fieldName, declaration.initializer);
@@ -140704,8 +140704,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function addDefiniteAssignmentAssertion(changeTracker, propertyDeclarationSourceFile, propertyDeclaration) {
       suppressLeadingAndTrailingTrivia(propertyDeclaration);
-      const property2 = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, factory.createToken(54), propertyDeclaration.type, propertyDeclaration.initializer);
-      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property2);
+      const property3 = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, factory.createToken(54), propertyDeclaration.type, propertyDeclaration.initializer);
+      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property3);
     }
     function getActionForAddMissingUndefinedType(context, info) {
       const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addUndefinedType(t, context.sourceFile, info));
@@ -140733,8 +140733,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function addInitializer(changeTracker, propertyDeclarationSourceFile, propertyDeclaration, initializer) {
       suppressLeadingAndTrailingTrivia(propertyDeclaration);
-      const property2 = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, propertyDeclaration.questionToken, propertyDeclaration.type, initializer);
-      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property2);
+      const property3 = factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, propertyDeclaration.questionToken, propertyDeclaration.type, initializer);
+      changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property3);
     }
     function getInitializer(checker, propertyDeclaration) {
       return getDefaultValueFromType(checker, checker.getTypeFromTypeNode(propertyDeclaration.type));
@@ -144099,8 +144099,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
         const properties = type && type.properties;
         if (properties) {
-          properties.forEach((property2) => {
-            membersDeclaredBySpreadAssignment.add(property2.name);
+          properties.forEach((property3) => {
+            membersDeclaredBySpreadAssignment.add(property3.name);
           });
         }
       }
@@ -200336,15 +200336,15 @@ var require_ts_morph = __commonJS((exports) => {
       return this._context.project;
     }
     getNodeProperty(propertyName) {
-      const property2 = this.compilerNode[propertyName];
-      if (property2 == null)
+      const property3 = this.compilerNode[propertyName];
+      if (property3 == null)
         return;
-      else if (property2 instanceof Array)
-        return property2.map((p) => isNode(p) ? this._getNodeFromCompilerNode(p) : p);
-      else if (isNode(property2))
-        return this._getNodeFromCompilerNode(property2);
+      else if (property3 instanceof Array)
+        return property3.map((p) => isNode(p) ? this._getNodeFromCompilerNode(p) : p);
+      else if (isNode(property3))
+        return this._getNodeFromCompilerNode(property3);
       else
-        return property2;
+        return property3;
       function isNode(value) {
         return typeof value.kind === "number" && typeof value.pos === "number" && typeof value.end === "number";
       }
@@ -207545,7 +207545,7 @@ var require_ts_morph = __commonJS((exports) => {
         kind: exports.StructureKind.Class,
         ctors: this.getConstructors().filter((ctor) => isAmbient || !ctor.isOverload()).map((ctor) => ctor.getStructure()),
         methods: this.getMethods().filter((method) => isAmbient || !method.isOverload()).map((method) => method.getStructure()),
-        properties: this.getProperties().map((property2) => property2.getStructure()),
+        properties: this.getProperties().map((property3) => property3.getStructure()),
         extends: getExtends ? getExtends.getText() : undefined,
         getAccessors: this.getGetAccessors().map((getAccessor) => getAccessor.getStructure()),
         setAccessors: this.getSetAccessors().map((accessor) => accessor.getStructure())
@@ -214114,18 +214114,18 @@ var require_postgres_interval = __commonJS((exports, module) => {
       return {};
     var matches = INTERVAL.exec(interval);
     var isNegative = matches[8] === "-";
-    return Object.keys(positions).reduce(function(parsed, property2) {
-      var position = positions[property2];
+    return Object.keys(positions).reduce(function(parsed, property3) {
+      var position = positions[property3];
       var value = matches[position];
       if (!value)
         return parsed;
-      value = property2 === "milliseconds" ? parseMilliseconds(value) : parseInt(value, 10);
+      value = property3 === "milliseconds" ? parseMilliseconds(value) : parseInt(value, 10);
       if (!value)
         return parsed;
-      if (isNegative && ~negatives.indexOf(property2)) {
+      if (isNegative && ~negatives.indexOf(property3)) {
         value *= -1;
       }
-      parsed[property2] = value;
+      parsed[property3] = value;
       return parsed;
     }, {});
   };
@@ -214139,12 +214139,12 @@ var require_postgres_interval = __commonJS((exports, module) => {
     }
     if (filtered.length === 0)
       return "0";
-    return filtered.map(function(property2) {
-      var value = this[property2] || 0;
-      if (property2 === "seconds" && this.milliseconds) {
+    return filtered.map(function(property3) {
+      var value = this[property3] || 0;
+      if (property3 === "seconds" && this.milliseconds) {
         value = (value + this.milliseconds / 1000).toFixed(6).replace(/\.?0+$/, "");
       }
-      return value + " " + property2;
+      return value + " " + property3;
     }, this).join(" ");
   };
   var propertiesISOEquivalent = {
@@ -214161,12 +214161,12 @@ var require_postgres_interval = __commonJS((exports, module) => {
     var datePart = dateProperties.map(buildProperty, this).join("");
     var timePart = timeProperties.map(buildProperty, this).join("");
     return "P" + datePart + "T" + timePart;
-    function buildProperty(property2) {
-      var value = this[property2] || 0;
-      if (property2 === "seconds" && this.milliseconds) {
+    function buildProperty(property3) {
+      var value = this[property3] || 0;
+      if (property3 === "seconds" && this.milliseconds) {
         value = (value + this.milliseconds / 1000).toFixed(6).replace(/0+$/, "");
       }
-      return value + propertiesISOEquivalent[property2];
+      return value + propertiesISOEquivalent[property3];
     }
   };
   var NUMBER = "([+-]?\\d+)";
@@ -215565,12 +215565,12 @@ var require_result = __commonJS((exports, module) => {
 var require_query = __commonJS((exports, module) => {
   var { EventEmitter } = import.meta.require("events");
   var Result = require_result();
-  var utils9 = require_utils5();
+  var utils10 = require_utils5();
 
   class Query3 extends EventEmitter {
     constructor(config, values, callback) {
       super();
-      config = utils9.normalizeQueryConfig(config, values, callback);
+      config = utils10.normalizeQueryConfig(config, values, callback);
       this.text = config.text;
       this.values = config.values;
       this.rows = config.rows;
@@ -215721,7 +215721,7 @@ var require_query = __commonJS((exports, module) => {
           statement: this.name,
           values: this.values,
           binary: this.binary,
-          valueMapper: utils9.prepareValue
+          valueMapper: utils10.prepareValue
         });
       } catch (err) {
         this.handleError(err, connection);
@@ -217025,7 +217025,7 @@ var require_lib = __commonJS((exports, module) => {
 // /export/htdocs/p/framework/node_modules/pg/lib/client.js
 var require_client = __commonJS((exports, module) => {
   var EventEmitter = import.meta.require("events").EventEmitter;
-  var utils9 = require_utils5();
+  var utils10 = require_utils5();
   var sasl = require_sasl();
   var TypeOverrides = require_type_overrides();
   var ConnectionParameters = require_connection_parameters();
@@ -217391,10 +217391,10 @@ var require_client = __commonJS((exports, module) => {
       return this._types.getTypeParser(oid, format);
     }
     escapeIdentifier(str) {
-      return utils9.escapeIdentifier(str);
+      return utils10.escapeIdentifier(str);
     }
     escapeLiteral(str) {
-      return utils9.escapeLiteral(str);
+      return utils10.escapeLiteral(str);
     }
     _pulseQueryQueue() {
       if (this.readyForQuery === true) {
@@ -217896,10 +217896,10 @@ var require_pg_pool = __commonJS((exports, module) => {
 var require_query2 = __commonJS((exports, module) => {
   var EventEmitter = import.meta.require("events").EventEmitter;
   var util = import.meta.require("util");
-  var utils9 = require_utils5();
+  var utils10 = require_utils5();
   var NativeQuery = module.exports = function(config, values, callback) {
     EventEmitter.call(this);
-    config = utils9.normalizeQueryConfig(config, values, callback);
+    config = utils10.normalizeQueryConfig(config, values, callback);
     this.text = config.text;
     this.values = config.values;
     this.name = config.name;
@@ -217998,7 +217998,7 @@ var require_query2 = __commonJS((exports, module) => {
         console.error("You supplied %s (%s)", this.name, this.name.length);
         console.error("This can cause conflicts and silent errors executing queries");
       }
-      var values = (this.values || []).map(utils9.prepareValue);
+      var values = (this.values || []).map(utils10.prepareValue);
       if (client.namedQueries[this.name]) {
         if (this.text && client.namedQueries[this.name] !== this.text) {
           const err = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
@@ -218017,7 +218017,7 @@ var require_query2 = __commonJS((exports, module) => {
         const err = new Error("Query values must be an array");
         return after(err);
       }
-      var vals = this.values.map(utils9.prepareValue);
+      var vals = this.values.map(utils10.prepareValue);
       client.native.query(this.text, vals, after);
     } else {
       client.native.query(this.text, after);
@@ -218325,7 +218325,7 @@ var PROPERTIES_METADATA = "cheetah:properties:metadata";
 var PROPERTIES_RELATIONS = "cheetah:properties:relations";
 var EVENTS_METADATA = "cheetah:events:metadata";
 
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/di
+// ../../node_modules/balanced-match/index.jsodules/minimatch
 var ProviderType;
 (function(ProviderType2) {
   ProviderType2["ROUTES"] = "routes";
@@ -218334,7 +218334,7 @@ var ProviderType;
   ProviderType2["CONTROLLER"] = "controller";
 })(ProviderType || (ProviderType = {}));
 
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dis
+// ../../node_modules/balanced-match/index.jsodules/minimatch/
 var ProviderScope;
 (function(ProviderScope2) {
   ProviderScope2["REQUEST"] = "request";
@@ -222357,7 +222357,7 @@ LoggerService = __decorate4([
   Service(),
   __metadata3("design:paramtypes", [InjectorService])
 ], LoggerService);
-// ../../node_modules/@ts-morph/common/node_modules/mkdi
+// ../../node_modules/balanced-match/index.jsodules/mini
 class Provider2 {
   type = ProviderType.PROVIDER;
   deps = [];
@@ -222418,7 +222418,7 @@ class Provider2 {
   }
 }
 
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist/cjs/src/fin
+// ../../node_modules/balanced-match/index.jsodules/minimatch/dist/cjs/unes
 class ProviderControl5 extends Map {
   settings = new Map;
   get(key) {
@@ -222495,7 +222495,7 @@ class ProviderControl5 extends Map {
   }
 }
 var GlobalProvider2 = new ProviderControl5;
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist/cjs/src/find
+// ../../node_modules/balanced-match/index.jsodules/minimatch/dist/cjs/unesc
 GlobalProvider2.createRegistry(ProviderType.CONTROLLER, Provider2);
 GlobalProvider2.createRegistry(ProviderType.ROUTES, Provider2);
 var registerController2 = GlobalProvider2.createRegisterFn(ProviderType.CONTROLLER);
@@ -222758,7 +222758,7 @@ var globbyStream2 = normalizeArgumentsSync2((patterns, options) => {
 var isDynamicPattern2 = normalizeArgumentsSync2((patterns, options) => patterns.some((pattern) => import_fast_glob4.default.isDynamicPattern(pattern, options)));
 var generateGlobTasks2 = normalizeArguments2(generateTasks2);
 var generateGlobTasksSync2 = normalizeArgumentsSync2(generateTasksSync2);
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist/cjs/src/fin
+// ../../node_modules/balanced-match/index.jsodules/minimatch/dist/cjs/unes
 function createParamDecorator2(func) {
   return (data) => (target, propertyKey, parameterIndex) => {
     const existingArgs = Metadata.get(ROUTE_PARAM, target.constructor, propertyKey) || {};
@@ -222791,7 +222791,7 @@ var Get2 = createMethodDecorator2("GET");
 var Post2 = createMethodDecorator2("POST");
 var Put2 = createMethodDecorator2("PUT");
 var Delete2 = createMethodDecorator2("DELETE");
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/d
+// ../../node_modules/balanced-match/index.jsodules/minimatc
 class Container2 extends Map {
   add(token, settings = {}) {
     const provider6 = GlobalProvider.get(token)?.clone() || new Provider(token);
@@ -222826,7 +222826,7 @@ class Container2 extends Map {
     });
   }
 }
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist/cjs/src/f
+// ../../node_modules/balanced-match/index.jsodules/minimatch/dist/cjs/un
 class ContainerConfiguration4 {
   default = new Map;
   map = new Map;
@@ -222906,7 +222906,7 @@ class ContainerConfiguration4 {
     return this.map[propertyKey] ?? defaultValue;
   }
 }
-// ../../node_modules/@ts-morph/common/node_modules/mkdi
+// ../../node_modules/balanced-match/index.jsodules/mini
 var createNode2 = (part, inert) => ({
   part,
   store: null,
@@ -223097,7 +223097,7 @@ var matchRoute2 = (url, urlLength, node, startIndex) => {
 };
 var memoirist_default2 = Memoirist2;
 
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist/cj
+// ../../node_modules/balanced-match/index.jsodules/minimatch/dist
 var __decorate5 = function(decorators5, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -223351,7 +223351,7 @@ var InjectorService5 = InjectorService_12 = class InjectorService6 {
 InjectorService5 = InjectorService_12 = __decorate5([
   Injectable()
 ], InjectorService5);
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist/cjs/sr
+// ../../node_modules/balanced-match/index.jsodules/minimatch/dist/cjs
 class MiddlewareResolver2 {
   async resolveMiddlewares(route, injector, local) {
     if (route.middlewares.length == 0) {
@@ -223377,7 +223377,7 @@ class MiddlewareResolver2 {
   }
 }
 var MiddlewareRes2 = new MiddlewareResolver2;
-// ../../node_modules/@ts-morph/common/node_modules/mkd
+// ../../node_modules/balanced-match/index.jsodules/min
 var __decorate6 = function(decorators5, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -223452,7 +223452,7 @@ Context4 = Context_12 = __decorate6([
   Injectable({ scope: ProviderScope2.REQUEST }),
   __metadata4("design:paramtypes", [])
 ], Context4);
-// ../../node_modules/@ts-morph/common/node_modules/mkdi
+// ../../node_modules/balanced-match/index.jsodules/mini
 var DESIGN_PARAM_TYPES2 = "design:paramtypes";
 var DESIGN_TYPE2 = "design:type";
 var DESIGN_RETURN_TYPE2 = "design:returntype";
@@ -223513,7 +223513,7 @@ class Metadata3 {
     return Reflect.getMetadata(ROUTE_PARAM, target.constructor, propertyKey);
   }
 }
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/
+// ../../node_modules/balanced-match/index.jsodules/minimat
 var HttpMethod2;
 (function(HttpMethod3) {
   HttpMethod3["GET"] = "get";
@@ -223521,7 +223521,7 @@ var HttpMethod2;
   HttpMethod3["POST"] = "post";
   HttpMethod3["DELETE"] = "delete";
 })(HttpMethod2 || (HttpMethod2 = {}));
-// ../../node_modules/@ts-morph/common/node_modules/mk
+// ../../node_modules/balanced-match/index.jsodules/mi
 var parseUrl3 = require_parseurl_fast();
 
 class Matcher3 {
@@ -223560,7 +223560,7 @@ class Matcher3 {
   }
 }
 var RouteResolver2 = new Matcher3;
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/d
+// ../../node_modules/balanced-match/index.jsodules/minimatc
 class Router2 {
   async executeRoute(route, injector, context, locals) {
     const provider7 = injector.invoke(route.provider, locals);
@@ -223595,7 +223595,7 @@ class Router2 {
   }
 }
 var RouteExecutor4 = new Router2;
-// ../../node_modules/@ts-morph/common/node_modu
+// ../../node_modules/balanced-match/index.jsodu
 import process5 from "process";
 var parseUrl4 = require_parseurl_fast();
 
@@ -223669,7 +223669,7 @@ class Cheetah3 {
     this.server.stop(closeActiveConnections);
   }
 }
-// ../../node_modules/@ts-morph/common/node_modules/mkdi
+// ../../node_modules/balanced-match/index.jsodules/mini
 var EventType2;
 (function(EventType3) {
   EventType3["OnApplicationBoot"] = "OnApplicationBoot";
@@ -223678,7 +223678,7 @@ var EventType2;
   EventType3["OnRequest"] = "OnRequest";
   EventType3["OnResponse"] = "OnResponse";
 })(EventType2 || (EventType2 = {}));
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist
+// ../../node_modules/balanced-match/index.jsodules/minimatch/d
 var __decorate7 = function(decorators5, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -223707,7 +223707,7 @@ __decorate7([
 DefaultRoutesCheetah3 = __decorate7([
   Controller()
 ], DefaultRoutesCheetah3);
-// ../../node_modules/@ts-morph/common/node_modules/mkdirp/dist/
+// ../../node_modules/balanced-match/index.jsodules/minimatch/di
 var import_pino2 = __toESM(require_pino(), 1);
 var __decorate8 = function(decorators5, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -223761,7 +223761,7 @@ LoggerService3 = __decorate8([
   Service(),
   __metadata6("design:paramtypes", [InjectorService])
 ], LoggerService3);
-// ../../node_modules/@ts-morph/commo
+// ../../node_modules/balanced-match/
 function Entity(options) {
   return (target) => {
     const entities = Metadata3.get(ENTITIES, Reflect) || [];
@@ -223777,8 +223777,20 @@ function toSnakeCase(propertyKey1) {
   propertyKey1 = propertyKey1[0].toLowerCase() + propertyKey1.slice(1);
   return propertyKey1.replace(/([A-Z])/g, "_$1").toLowerCase();
 }
+function extendsFrom(baseClass, instance) {
+  if (!instance)
+    return false;
+  let proto = Object.getPrototypeOf(instance);
+  while (proto) {
+    if (proto === baseClass.prototype) {
+      return true;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return false;
+}
 
-// ../../node_modules/@ts-morph/comm
+// ../../node_modules/balanced-match
 function Index(options) {
   return (target, propertyKey) => {
     const indexes = Metadata.get("indexes", target.constructor) || [];
@@ -223794,7 +223806,7 @@ function Index(options) {
   };
 }
 
-// ../../node_modules/@ts-morph/common/
+// ../../node_modules/balanced-match/in
 function Property(options) {
   return (target, propertyKey) => {
     const properties = Metadata.get(PROPERTIES, target.constructor) || [];
@@ -223802,6 +223814,13 @@ function Property(options) {
     const length = options && options.length || getDefaultLength(type.name);
     options = { length, ...options };
     options["columnName"] = options?.columnName || toSnakeCase(propertyKey);
+    if (extendsFrom(ValueObject, type.prototype)) {
+      let instance = new type(null, true).getDatabaseValues();
+      options["length"] = instance.max;
+      options["precision"] = instance.precision;
+      options["scale"] = instance.scale;
+      instance = null;
+    }
     properties.push({ propertyKey, options });
     Metadata.set(PROPERTIES, properties, target.constructor);
     if (options.isPrimary) {
@@ -223820,12 +223839,12 @@ function Property(options) {
     });
   };
 }
-// ../../node_modules/@ts-morph/common/nod
+// ../../node_modules/balanced-match/index
 function PrimaryKey(options) {
   const isPrimary = true;
-  return Property({ ...options, isPrimary, unique: true });
+  return Property({ ...options, isPrimary });
 }
-// ../../node_modules/@ts-morph/common/
+// ../../node_modules/balanced-match/in
 function OneToMany(entity, fkKey) {
   return (target, propertyKey) => {
     const existing = Metadata.get(PROPERTIES_RELATIONS, target.constructor) || [];
@@ -223844,7 +223863,7 @@ function ManyToOne(entity) {
     Metadata.set(PROPERTIES_RELATIONS, existing, target.constructor);
   };
 }
-// ../../node_modules/@ts-morph/common/no
+// ../../node_modules/balanced-match/inde
 function BeforeCreate() {
   return function(target, propertyName) {
     const metadata = Reflect.getMetadata(EVENTS_METADATA, target.constructor) || [];
@@ -223869,7 +223888,16 @@ function AfterUpdate() {
     Reflect.defineMetadata(EVENTS_METADATA, [...metadata, { type: "afterUpdate", propertyName }], target.constructor);
   };
 }
-// ../../node_modules/@ts
+// ../../node_modules/balanced-matc
+function Enum(options) {
+  const isEnum = true;
+  let enumItems = typeof options === "function" ? options() : typeof options.items === "function" ? options.items() : options.items;
+  if (typeof enumItems === "object") {
+    enumItems = Object.keys(enumItems).map((key) => enumItems[key]);
+  }
+  return Property({ ...options, isEnum, enumItems, dbType: "enum" });
+}
+// ../../node_modules/bal
 class EntityStorage {
   static instance;
   entities = new Map;
@@ -223924,6 +223952,8 @@ class EntityStorage {
         unique: value.options?.unique,
         length: value.options?.length,
         isEnum: value.options?.isEnum,
+        precision: value.options?.precision,
+        scale: value.options?.scale,
         enumItems: value.options?.enumItems
       };
     });
@@ -223938,6 +223968,8 @@ class EntityStorage {
         default: relation.default,
         autoIncrement: this.getFkIncrement(relation),
         primary: relation.isPrimary,
+        precision: relation.precision,
+        scale: relation.scale,
         foreignKeys: [
           {
             referencedColumnName: this.getFkKey(relation),
@@ -223980,11 +224012,11 @@ class EntityStorage {
   getFkKey(relationShip) {
     if (typeof relationShip.fkKey === "undefined") {
       const entity = this.entities.get(relationShip.entity());
-      const property2 = Object.entries(entity.properties).find(([key, value]) => value.options.isPrimary === true);
-      if (!property2) {
+      const property3 = Object.entries(entity.properties).find(([key, value]) => value.options.isPrimary === true);
+      if (!property3) {
         throw new Error(`Entity ${entity.tableName} does not have a primary key`);
       }
-      return property2[0];
+      return property3[0];
     }
     if (typeof relationShip.fkKey === "string") {
       return relationShip.fkKey;
@@ -223998,11 +224030,15 @@ EntityStorage = __legacyDecorateClassTS([
   __legacyMetadataTS("design:paramtypes", [])
 ], EntityStorage);
 
-// ../../node_modules/@ts-mor
+// ../../node_modules/balance
 class ValueObject {
+  max;
+  min;
+  precision;
+  scale;
   value;
-  constructor(value) {
-    if (!this.validate(value)) {
+  constructor(value, skipValidation = false) {
+    if (!skipValidation && (!this.validate(value) || !this.validateDatabase(value))) {
       throw new HttpException(`Invalid value for ${this.constructor.name}`, 400);
     }
     this.setValue(value);
@@ -224016,12 +224052,50 @@ class ValueObject {
   equals(vo) {
     return this.getValue() === vo.getValue();
   }
+  getDatabaseValues() {
+    return {
+      max: this.max,
+      min: this.min,
+      precision: this.precision,
+      scale: this.scale
+    };
+  }
   setValue(value) {
     this.value = value;
   }
+  validateDatabase(value) {
+    if (typeof value === "string") {
+      if (this.max !== undefined && value.length > this.max) {
+        throw new HttpException(`Value exceeds maximum length of ${this.max}`, 400);
+      }
+      if (this.min !== undefined && value.length < this.min) {
+        throw new HttpException(`Value is less than minimum length of ${this.min}`, 400);
+      }
+    } else if (typeof value === "number") {
+      if (this.max !== undefined && value > this.max) {
+        throw new HttpException(`Value exceeds maximum value of ${this.max}`, 400);
+      }
+      if (this.min !== undefined && value < this.min) {
+        throw new HttpException(`Value is less than minimum value of ${this.min}`, 400);
+      }
+      if (this.precision !== undefined) {
+        const totalDigits = value.toString().replace(".", "").length;
+        if (totalDigits > this.precision) {
+          throw new HttpException(`Value exceeds precision of ${this.precision}`, 400);
+        }
+      }
+      if (this.scale !== undefined) {
+        const decimalDigits = (value.toString().split(".")[1] || "").length;
+        if (decimalDigits > this.scale) {
+          throw new HttpException(`Value exceeds scale of ${this.scale}`, 400);
+        }
+      }
+    }
+    return true;
+  }
 }
 
-// ../../node_modules/@ts-mo
+// ../../node_modules/balanc
 class BaseEntity {
   _oldValues = {};
   _changedValues = {};
@@ -224134,28 +224208,18 @@ var processValuesForUpdate = function(values, options) {
   return newValue;
 };
 var getColumnName = function(propertyKey, entity) {
-  const property2 = entity.properties[propertyKey];
+  const property3 = entity.properties[propertyKey];
   const relation = entity.relations?.find((rel) => rel.propertyKey === propertyKey);
   if (propertyKey.startsWith("$")) {
     return propertyKey;
   }
-  if (!property2) {
+  if (!property3) {
     if (relation) {
       return relation.columnName || propertyKey;
     }
     throw new Error("Property not found");
   }
-  return property2.options.columnName || propertyKey;
-};
-var extendsFrom = function(baseClass, instance) {
-  let proto = Object.getPrototypeOf(instance);
-  while (proto) {
-    if (proto === baseClass.prototype) {
-      return true;
-    }
-    proto = Object.getPrototypeOf(proto);
-  }
-  return false;
+  return property3.options.columnName || propertyKey;
 };
 var upEntity = function(values, entity, moment = undefined) {
   const entityStorage = EntityStorage.getInstance();
@@ -224164,17 +224228,17 @@ var upEntity = function(values, entity, moment = undefined) {
   if (!entityOptions) {
     throw new Error("Entity not found");
   }
-  const property2 = Object.entries(entityOptions.properties);
+  const property3 = Object.entries(entityOptions.properties);
   const relations = entityOptions.relations;
-  property2.forEach(([key, property3]) => {
-    if (property3.options.onInsert && moment === "insert") {
-      instance[key] = property3.options.onInsert();
+  property3.forEach(([key, property4]) => {
+    if (property4.options.onInsert && moment === "insert") {
+      instance[key] = property4.options.onInsert();
     }
-    if (property3.options.onInsert && moment === "update") {
-      instance[key] = property3.options.onUpdate();
+    if (property4.options.onInsert && moment === "update") {
+      instance[key] = property4.options.onUpdate();
     }
     if (key in values) {
-      instance[key] = values[property3.options.columnName];
+      instance[key] = values[property4.options.columnName];
     }
   });
   if (relations) {
@@ -224417,10 +224481,10 @@ class SqlBuilder2 {
       }
       const child = await this.driver.executeStatement(join);
       this.logger.debug(`SQL: ${child.sql} [${Date.now() - child.startTime}ms]`);
-      const property2 = this.entityStorage.get(this.model).relations.find((rel) => rel.propertyKey === join.joinProperty);
+      const property3 = this.entityStorage.get(this.model).relations.find((rel) => rel.propertyKey === join.joinProperty);
       const values = child.query.rows.map((row) => this.transformToModel(join.joinEntity, join, row));
       const path3 = this.getPathForSelectJoin(join);
-      this.setValueByPath(models, path3, property2?.type === Array ? [...values] : values[0]);
+      this.setValueByPath(models, path3, property3?.type === Array ? [...values] : values[0]);
     }
     return models;
   }
@@ -224581,7 +224645,7 @@ class SqlBuilder2 {
     const sqlParts = [];
     const operators = ["$eq", "$ne", "$in", "$nin", "$like", "$gt", "$gte", "$lt", "$lte", "$and", "$or"];
     for (let [key, value] of Object.entries(condition)) {
-      if (this.extendsFrom(ValueObject, value.constructor.prototype)) {
+      if (extendsFrom(ValueObject, value.constructor.prototype)) {
         value = value.getValue();
       }
       if (!operators.includes(key)) {
@@ -224730,8 +224794,8 @@ class SqlBuilder2 {
     const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
     const propertyKey = match ? match.groups.propriedade : "";
     const entity = this.entityStorage.get(relationShip.entity());
-    const property2 = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
-    return property2.options.columnName;
+    const property3 = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
+    return property3.options.columnName;
   }
   getEntity(model) {
     const entity = this.entityStorage.get(model);
@@ -224769,7 +224833,7 @@ class SqlBuilder2 {
       const entityProperty = ep?.[1];
       const keyProperty = ep?.[0];
       if (entityProperty) {
-        if (this.extendsFrom(ValueObject, entityProperty.type.prototype)) {
+        if (extendsFrom(ValueObject, entityProperty.type.prototype)) {
           entity[keyProperty] = new entityProperty.type(value);
           return;
         }
@@ -224781,11 +224845,11 @@ class SqlBuilder2 {
         const { joinAlias, originAlias, propertyKey } = join;
         const originEntity = entitiesByAlias[originAlias];
         const joinEntity = entitiesByAlias[joinAlias];
-        const property2 = entitiesOptions.get(originAlias).relations.find((rel) => rel.propertyKey === propertyKey);
+        const property3 = entitiesOptions.get(originAlias).relations.find((rel) => rel.propertyKey === propertyKey);
         if (!originEntity || !joinEntity) {
           return;
         }
-        originEntity[propertyKey] = property2.type === Array ? originEntity[propertyKey] ? [...originEntity[propertyKey], joinEntity] : [joinEntity] : joinEntity;
+        originEntity[propertyKey] = property3.type === Array ? originEntity[propertyKey] ? [...originEntity[propertyKey], joinEntity] : [joinEntity] : joinEntity;
       });
     }
     return instance;
@@ -224817,43 +224881,31 @@ class SqlBuilder2 {
     return columns;
   }
   withDefaultValues(values, entityOptions) {
-    const property2 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
+    const property3 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
     const defaultProperties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.default);
-    for (const [key, property3] of defaultProperties) {
+    for (const [key, property4] of defaultProperties) {
       if (typeof values[key] === "undefined") {
-        if (typeof property3.options.default === "function") {
-          values[key] = (0, eval)(property3.options.default());
+        if (typeof property4.options.default === "function") {
+          values[key] = (0, eval)(property4.options.default());
         } else {
-          values[key] = (0, eval)(property3.options.default);
+          values[key] = (0, eval)(property4.options.default);
         }
       }
     }
-    property2.forEach(([key, property3]) => {
-      values[key] = property3.options.onInsert();
+    property3.forEach(([key, property4]) => {
+      values[key] = property4.options.onInsert();
       this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
     });
     return values;
   }
   withUpdatedValues(values, entityOptions) {
-    const property2 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
-    property2.forEach(([key, property3]) => {
-      values[property3.options.columnName] = property3.options.onUpdate();
-      this.updatedColumns.push(`${this.statements.alias}."${property3.options.columnName}" as "${this.statements.alias}_${property3.options.columnName}"`);
+    const property3 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
+    property3.forEach(([key, property4]) => {
+      values[property4.options.columnName] = property4.options.onUpdate();
+      this.updatedColumns.push(`${this.statements.alias}."${property4.options.columnName}" as "${this.statements.alias}_${property4.options.columnName}"`);
     });
     return values;
   }
-  extendsFrom(baseClass, instance) {
-    if (!instance)
-      return false;
-    let proto = Object.getPrototypeOf(instance);
-    while (proto) {
-      if (proto === baseClass.prototype) {
-        return true;
-      }
-      proto = Object.getPrototypeOf(proto);
-    }
-    return false;
-  }
   callHook(type, model) {
     const hooks3 = this.statements.hooks?.filter((hook) => hook.type === type) || [];
     const instance = model || this.statements.instance;
@@ -224939,10 +224991,10 @@ class OrmService {
             const extendsProperties = extendsClass.getProperties();
             properties.push(...extendsProperties);
           }
-          properties.forEach((property2) => {
-            const propertyName = property2.getName();
-            const isNullable = property2.hasQuestionToken();
-            const initializer = property2.getInitializer();
+          properties.forEach((property3) => {
+            const propertyName = property3.getName();
+            const isNullable = property3.hasQuestionToken();
+            const initializer = property3.getInitializer();
             if (isNullable) {
               nullables.push(propertyName);
             }
@@ -224995,12 +225047,12 @@ class OrmService {
       const properties = Metadata.get(PROPERTIES_METADATA, entity.target);
       const relationship = Metadata.get(PROPERTIES_RELATIONS, entity.target);
       const hooks3 = Metadata.get(EVENTS_METADATA, entity.target);
-      for (const property2 in properties) {
-        if (nullableDefaultEntity?.nullables.includes(property2)) {
-          properties[property2].options.nullable = true;
+      for (const property3 in properties) {
+        if (nullableDefaultEntity?.nullables.includes(property3)) {
+          properties[property3].options.nullable = true;
         }
-        if (nullableDefaultEntity?.defaults[property2]) {
-          properties[property2].options.default = nullableDefaultEntity?.defaults[property2];
+        if (nullableDefaultEntity?.defaults[property3]) {
+          properties[property3].options.default = nullableDefaultEntity?.defaults[property3];
         }
       }
       this.storage.add(entity, properties, relationship, hooks3);
@@ -225037,7 +225089,7 @@ OrmService = __legacyDecorateClassTS([
     String
   ])
 ], OrmService);
-// ../../node_modules/@ts-
+// ../../node_modules/bala
 var import_pg = __toESM(require_lib2(), 1);
 
 class PgDriver {
@@ -225342,7 +225394,7 @@ class PgDriver {
 }
 // ../../node_m
 var CheetahOrm = new Cheetah({ exports: [Orm, OrmService, EntityStorage] });
-// ../../node_modules/@ts
+// ../../node_modules/bal
 var REGEX = /^[a-z0-9.]+@[a-z0-9]+\.[a-z]+(\.[a-z]+)?$/i;
 
 class Email extends ValueObject {
@@ -225375,7 +225427,19 @@ function toSnakeCase2(propertyKey1) {
   propertyKey1 = propertyKey1[0].toLowerCase() + propertyKey1.slice(1);
   return propertyKey1.replace(/([A-Z])/g, "_$1").toLowerCase();
 }
-// ../../node_modules/@ts-
+function extendsFrom2(baseClass, instance) {
+  if (!instance)
+    return false;
+  let proto = Object.getPrototypeOf(instance);
+  while (proto) {
+    if (proto === baseClass.prototype) {
+      return true;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return false;
+}
+// ../../node_modules/bala
 var __decorate9 = function(decorators5, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -225448,6 +225512,8 @@ var EntityStorage2 = class EntityStorage3 {
         unique: value.options?.unique,
         length: value.options?.length,
         isEnum: value.options?.isEnum,
+        precision: value.options?.precision,
+        scale: value.options?.scale,
         enumItems: value.options?.enumItems
       };
     });
@@ -225462,6 +225528,8 @@ var EntityStorage2 = class EntityStorage3 {
         default: relation.default,
         autoIncrement: this.getFkIncrement(relation),
         primary: relation.isPrimary,
+        precision: relation.precision,
+        scale: relation.scale,
         foreignKeys: [
           {
             referencedColumnName: this.getFkKey(relation),
@@ -225504,11 +225572,11 @@ var EntityStorage2 = class EntityStorage3 {
   getFkKey(relationShip) {
     if (typeof relationShip.fkKey === "undefined") {
       const entity = this.entities.get(relationShip.entity());
-      const property3 = Object.entries(entity.properties).find(([key, value]) => value.options.isPrimary === true);
-      if (!property3) {
+      const property5 = Object.entries(entity.properties).find(([key, value]) => value.options.isPrimary === true);
+      if (!property5) {
         throw new Error(`Entity ${entity.tableName} does not have a primary key`);
       }
-      return property3[0];
+      return property5[0];
     }
     if (typeof relationShip.fkKey === "string") {
       return relationShip.fkKey;
@@ -225522,11 +225590,15 @@ EntityStorage2 = EntityStorage_1 = __decorate9([
   __metadata7("design:paramtypes", [])
 ], EntityStorage2);
 
-// ../../node_modules/@ts-morp
+// ../../node_modules/balanced
 class ValueObject2 {
+  max;
+  min;
+  precision;
+  scale;
   value;
-  constructor(value) {
-    if (!this.validate(value)) {
+  constructor(value, skipValidation = false) {
+    if (!skipValidation && (!this.validate(value) || !this.validateDatabase(value))) {
       throw new HttpException(`Invalid value for ${this.constructor.name}`, 400);
     }
     this.setValue(value);
@@ -225540,12 +225612,50 @@ class ValueObject2 {
   equals(vo) {
     return this.getValue() === vo.getValue();
   }
+  getDatabaseValues() {
+    return {
+      max: this.max,
+      min: this.min,
+      precision: this.precision,
+      scale: this.scale
+    };
+  }
   setValue(value) {
     this.value = value;
   }
+  validateDatabase(value) {
+    if (typeof value === "string") {
+      if (this.max !== undefined && value.length > this.max) {
+        throw new HttpException(`Value exceeds maximum length of ${this.max}`, 400);
+      }
+      if (this.min !== undefined && value.length < this.min) {
+        throw new HttpException(`Value is less than minimum length of ${this.min}`, 400);
+      }
+    } else if (typeof value === "number") {
+      if (this.max !== undefined && value > this.max) {
+        throw new HttpException(`Value exceeds maximum value of ${this.max}`, 400);
+      }
+      if (this.min !== undefined && value < this.min) {
+        throw new HttpException(`Value is less than minimum value of ${this.min}`, 400);
+      }
+      if (this.precision !== undefined) {
+        const totalDigits = value.toString().replace(".", "").length;
+        if (totalDigits > this.precision) {
+          throw new HttpException(`Value exceeds precision of ${this.precision}`, 400);
+        }
+      }
+      if (this.scale !== undefined) {
+        const decimalDigits = (value.toString().split(".")[1] || "").length;
+        if (decimalDigits > this.scale) {
+          throw new HttpException(`Value exceeds scale of ${this.scale}`, 400);
+        }
+      }
+    }
+    return true;
+  }
 }
 
-// ../../node_modules/@ts-mor
+// ../../node_modules/balance
 class BaseEntity2 {
   _oldValues = {};
   _changedValues = {};
@@ -225658,28 +225768,18 @@ var processValuesForUpdate2 = function(values, options) {
   return newValue;
 };
 var getColumnName2 = function(propertyKey, entity) {
-  const property3 = entity.properties[propertyKey];
+  const property5 = entity.properties[propertyKey];
   const relation = entity.relations?.find((rel) => rel.propertyKey === propertyKey);
   if (propertyKey.startsWith("$")) {
     return propertyKey;
   }
-  if (!property3) {
+  if (!property5) {
     if (relation) {
       return relation.columnName || propertyKey;
     }
     throw new Error("Property not found");
   }
-  return property3.options.columnName || propertyKey;
-};
-var extendsFrom2 = function(baseClass, instance) {
-  let proto = Object.getPrototypeOf(instance);
-  while (proto) {
-    if (proto === baseClass.prototype) {
-      return true;
-    }
-    proto = Object.getPrototypeOf(proto);
-  }
-  return false;
+  return property5.options.columnName || propertyKey;
 };
 var upEntity2 = function(values, entity, moment = undefined) {
   const entityStorage = EntityStorage2.getInstance();
@@ -225688,17 +225788,17 @@ var upEntity2 = function(values, entity, moment = undefined) {
   if (!entityOptions) {
     throw new Error("Entity not found");
   }
-  const property3 = Object.entries(entityOptions.properties);
+  const property5 = Object.entries(entityOptions.properties);
   const relations = entityOptions.relations;
-  property3.forEach(([key, property4]) => {
-    if (property4.options.onInsert && moment === "insert") {
-      instance[key] = property4.options.onInsert();
+  property5.forEach(([key, property6]) => {
+    if (property6.options.onInsert && moment === "insert") {
+      instance[key] = property6.options.onInsert();
     }
-    if (property4.options.onInsert && moment === "update") {
-      instance[key] = property4.options.onUpdate();
+    if (property6.options.onInsert && moment === "update") {
+      instance[key] = property6.options.onUpdate();
     }
     if (key in values) {
-      instance[key] = values[property4.options.columnName];
+      instance[key] = values[property6.options.columnName];
     }
   });
   if (relations) {
@@ -225941,10 +226041,10 @@ class SqlBuilder5 {
       }
       const child = await this.driver.executeStatement(join);
       this.logger.debug(`SQL: ${child.sql} [${Date.now() - child.startTime}ms]`);
-      const property3 = this.entityStorage.get(this.model).relations.find((rel) => rel.propertyKey === join.joinProperty);
+      const property5 = this.entityStorage.get(this.model).relations.find((rel) => rel.propertyKey === join.joinProperty);
       const values = child.query.rows.map((row) => this.transformToModel(join.joinEntity, join, row));
       const path3 = this.getPathForSelectJoin(join);
-      this.setValueByPath(models, path3, property3?.type === Array ? [...values] : values[0]);
+      this.setValueByPath(models, path3, property5?.type === Array ? [...values] : values[0]);
     }
     return models;
   }
@@ -226105,7 +226205,7 @@ class SqlBuilder5 {
     const sqlParts = [];
     const operators = ["$eq", "$ne", "$in", "$nin", "$like", "$gt", "$gte", "$lt", "$lte", "$and", "$or"];
     for (let [key, value] of Object.entries(condition)) {
-      if (this.extendsFrom(ValueObject2, value.constructor.prototype)) {
+      if (extendsFrom2(ValueObject2, value.constructor.prototype)) {
         value = value.getValue();
       }
       if (!operators.includes(key)) {
@@ -226250,8 +226350,8 @@ class SqlBuilder5 {
     const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
     const propertyKey = match ? match.groups.propriedade : "";
     const entity = this.entityStorage.get(relationShip.entity());
-    const property3 = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
-    return property3.options.columnName;
+    const property5 = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
+    return property5.options.columnName;
   }
   getEntity(model) {
     const entity = this.entityStorage.get(model);
@@ -226289,7 +226389,7 @@ class SqlBuilder5 {
       const entityProperty = ep?.[1];
       const keyProperty = ep?.[0];
       if (entityProperty) {
-        if (this.extendsFrom(ValueObject2, entityProperty.type.prototype)) {
+        if (extendsFrom2(ValueObject2, entityProperty.type.prototype)) {
           entity[keyProperty] = new entityProperty.type(value);
           return;
         }
@@ -226301,11 +226401,11 @@ class SqlBuilder5 {
         const { joinAlias, originAlias, propertyKey } = join;
         const originEntity = entitiesByAlias[originAlias];
         const joinEntity = entitiesByAlias[joinAlias];
-        const property3 = entitiesOptions.get(originAlias).relations.find((rel) => rel.propertyKey === propertyKey);
+        const property5 = entitiesOptions.get(originAlias).relations.find((rel) => rel.propertyKey === propertyKey);
         if (!originEntity || !joinEntity) {
           return;
         }
-        originEntity[propertyKey] = property3.type === Array ? originEntity[propertyKey] ? [...originEntity[propertyKey], joinEntity] : [joinEntity] : joinEntity;
+        originEntity[propertyKey] = property5.type === Array ? originEntity[propertyKey] ? [...originEntity[propertyKey], joinEntity] : [joinEntity] : joinEntity;
       });
     }
     return instance;
@@ -226337,43 +226437,31 @@ class SqlBuilder5 {
     return columns;
   }
   withDefaultValues(values, entityOptions) {
-    const property3 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
+    const property5 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
     const defaultProperties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.default);
-    for (const [key, property4] of defaultProperties) {
+    for (const [key, property6] of defaultProperties) {
       if (typeof values[key] === "undefined") {
-        if (typeof property4.options.default === "function") {
-          values[key] = (0, eval)(property4.options.default());
+        if (typeof property6.options.default === "function") {
+          values[key] = (0, eval)(property6.options.default());
         } else {
-          values[key] = (0, eval)(property4.options.default);
+          values[key] = (0, eval)(property6.options.default);
         }
       }
     }
-    property3.forEach(([key, property4]) => {
-      values[key] = property4.options.onInsert();
+    property5.forEach(([key, property6]) => {
+      values[key] = property6.options.onInsert();
       this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
     });
     return values;
   }
   withUpdatedValues(values, entityOptions) {
-    const property3 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
-    property3.forEach(([key, property4]) => {
-      values[property4.options.columnName] = property4.options.onUpdate();
-      this.updatedColumns.push(`${this.statements.alias}."${property4.options.columnName}" as "${this.statements.alias}_${property4.options.columnName}"`);
+    const property5 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
+    property5.forEach(([key, property6]) => {
+      values[property6.options.columnName] = property6.options.onUpdate();
+      this.updatedColumns.push(`${this.statements.alias}."${property6.options.columnName}" as "${this.statements.alias}_${property6.options.columnName}"`);
     });
     return values;
   }
-  extendsFrom(baseClass, instance) {
-    if (!instance)
-      return false;
-    let proto = Object.getPrototypeOf(instance);
-    while (proto) {
-      if (proto === baseClass.prototype) {
-        return true;
-      }
-      proto = Object.getPrototypeOf(proto);
-    }
-    return false;
-  }
   callHook(type, model) {
     const hooks3 = this.statements.hooks?.filter((hook) => hook.type === type) || [];
     const instance = model || this.statements.instance;
@@ -226489,10 +226577,10 @@ var OrmService2 = class OrmService3 {
             const extendsProperties = extendsClass.getProperties();
             properties.push(...extendsProperties);
           }
-          properties.forEach((property3) => {
-            const propertyName = property3.getName();
-            const isNullable = property3.hasQuestionToken();
-            const initializer = property3.getInitializer();
+          properties.forEach((property5) => {
+            const propertyName = property5.getName();
+            const isNullable = property5.hasQuestionToken();
+            const initializer = property5.getInitializer();
             if (isNullable) {
               nullables.push(propertyName);
             }
@@ -226545,12 +226633,12 @@ var OrmService2 = class OrmService3 {
       const properties = Metadata.get(PROPERTIES_METADATA2, entity.target);
       const relationship = Metadata.get(PROPERTIES_RELATIONS2, entity.target);
       const hooks3 = Metadata.get(EVENTS_METADATA2, entity.target);
-      for (const property3 in properties) {
-        if (nullableDefaultEntity?.nullables.includes(property3)) {
-          properties[property3].options.nullable = true;
+      for (const property5 in properties) {
+        if (nullableDefaultEntity?.nullables.includes(property5)) {
+          properties[property5].options.nullable = true;
         }
-        if (nullableDefaultEntity?.defaults[property3]) {
-          properties[property3].options.default = nullableDefaultEntity?.defaults[property3];
+        if (nullableDefaultEntity?.defaults[property5]) {
+          properties[property5].options.default = nullableDefaultEntity?.defaults[property5];
         }
       }
       this.storage.add(entity, properties, relationship, hooks3);
@@ -226581,15 +226669,15 @@ OrmService2 = __decorate11([
   Service(),
   __metadata9("design:paramtypes", [Orm2, EntityStorage2, String])
 ], OrmService2);
-// ../../node_modules/@ts-m
+// ../../node_modules/balan
 var import_pg2 = __toESM(require_lib2(), 1);
 // ../../node_mo
 var CheetahOrm2 = new Cheetah({ exports: [Orm2, OrmService2, EntityStorage2] });
-// ../../node_modules/@ts-mor
+// ../../node_modules/balance
 import * as path3 from "path";
 import * as fs5 from "fs";
 
-// ../../node_modules/@ts-morph/comm
+// ../../node_modules/balanced-match
 class DiffCalculator {
   entities;
   constructor(entities9) {
@@ -226875,7 +226963,7 @@ class DiffCalculator {
   }
 }
 
-// ../../node_modules/@ts-mor
+// ../../node_modules/balance
 class Migrator {
   config;
   orm;
@@ -227097,11 +227185,11 @@ class Migrator {
     return sqlInstructions.some((sql) => sql.includes(`"${s}"`));
   }
 }
-// ../../node_modules/@ts-mo
+// ../../node_modules/balanc
 import * as path4 from "path";
 import * as fs6 from "fs";
 
-// ../../node_modules/@ts-morph/com
+// ../../node_modules/balanced-matc
 class DiffCalculator2 {
   entities;
   constructor(entities10) {
@@ -227387,7 +227475,7 @@ class DiffCalculator2 {
   }
 }
 
-// ../../node_modules/@ts-mo
+// ../../node_modules/balanc
 class Migrator2 {
   config;
   orm;
@@ -227612,6 +227700,7 @@ class Migrator2 {
 export {
   toSnakeCase,
   getDefaultLength,
+  extendsFrom,
   ValueObject,
   Uuid,
   Property,
@@ -227623,6 +227712,7 @@ export {
   Migrator2 as Migrator,
   ManyToOne,
   Index,
+  Enum,
   EntityStorage,
   Entity,
   Email,
@@ -227634,4 +227724,4 @@ export {
   AfterCreate
 };
 
-//# debugId=78B1D93753E8A78864756e2164756e21
+//# debugId=BEC9201C05AB3BEE64756e2164756e21