@orion-js/schema 4.0.0-next.2 → 4.0.0-next.4

package/dist/index.cjs

@@ -4,7 +4,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -35,9 +34,16 @@ __export(index_exports, {
   cleanKey: () => cleanKey_default,
   createEnum: () => createEnum,
   dotGetSchema: () => dotGetSchema_default2,
+  fieldTypes: () => fieldTypes_default,
   getFieldType: () => getFieldType,
+  getSchemaFromAnyOrionForm: () => getSchemaFromAnyOrionForm,
+  getSchemaModelName: () => getSchemaModelName,
+  getSchemaWithMetadataFromAnyOrionForm: () => getSchemaWithMetadataFromAnyOrionForm,
   getValidationErrors: () => getValidationErrors2,
+  isSchemaLike: () => isSchemaLike,
+  isSchemaOrFieldLike: () => isSchemaOrFieldLike,
   isValid: () => isValid,
+  schemaWithName: () => schemaWithName,
   validate: () => validate,
   validateKey: () => validateKey_default
 });
@@ -45,14 +51,14 @@ module.exports = __toCommonJS(index_exports);
 
 // src/ValidationError.ts
 var import_isPlainObject = __toESM(require("lodash/isPlainObject"), 1);
-var getPrintableError = /* @__PURE__ */ __name((validationErrors) => {
+var getPrintableError = (validationErrors) => {
   const printableErrors = Object.keys(validationErrors).map((key) => {
     return `${key}: ${validationErrors[key]}`;
   }).join(", ");
   const message = `Validation Error: {${printableErrors}}`;
   return message;
-}, "getPrintableError");
-var _ValidationError = class _ValidationError extends Error {
+};
+var ValidationError = class _ValidationError extends Error {
   code;
   isValidationError;
   isOrionError;
@@ -69,57 +75,31 @@ var _ValidationError = class _ValidationError extends Error {
     this.validationErrors = validationErrors;
     this.getInfo;
   }
-  getInfo = /* @__PURE__ */ __name(() => {
+  getInfo = () => {
     return {
       error: "validationError",
       message: "Validation Error",
       validationErrors: this.validationErrors
     };
-  }, "getInfo");
-  prependKey = /* @__PURE__ */ __name((prepend) => {
+  };
+  prependKey = (prepend) => {
     const newErrors = {};
     const keys = Object.keys(this.validationErrors);
     for (const key of keys) {
       newErrors[`${prepend}.${key}`] = this.validationErrors[key];
     }
     return new _ValidationError(newErrors);
-  }, "prependKey");
+  };
 };
-__name(_ValidationError, "ValidationError");
-var ValidationError = _ValidationError;
 
-// src/getValidationErrors/convertTypedModel.ts
-function isClass(obj) {
-  const isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === "class";
-  if (obj.prototype === void 0) {
-    return isCtorClass;
-  }
-  const isPrototypeCtorClass = obj.prototype.constructor && obj.prototype.constructor.toString && obj.prototype.constructor.toString().substring(0, 5) === "class";
-  return isCtorClass || isPrototypeCtorClass;
-}
-__name(isClass, "isClass");
-var convertOnParam = /* @__PURE__ */ __name((info, paramName) => {
-  if (!info[paramName]) return;
-  const type = info[paramName].type;
-  if (!type) return;
-  if (typeof type !== "function") return;
-  if (!isClass(type)) return;
-  if (!type.getModel || !type.__schemaId) return;
-  info[paramName].type = type.getModel().getCleanSchema();
-}, "convertOnParam");
-var convertTypedModel = /* @__PURE__ */ __name((info) => {
-  convertOnParam(info, "schema");
-  convertOnParam(info, "currentSchema");
-}, "convertTypedModel");
-
-// src/getSchemaFromTypedModel.ts
-var getSchemaFromTypedModel = /* @__PURE__ */ __name((schema) => {
+// src/getSchemaFromTypedSchema.ts
+Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
+var getSchemaFromTypedSchema = (schema) => {
   const item = schema;
-  if (typeof item !== "function") return item;
-  if (!isClass(item)) return item;
-  if (!item.getModel || !item.__schemaId) return item;
-  return item.getModel().getCleanSchema();
-}, "getSchemaFromTypedModel");
+  if (!schema[Symbol.metadata]) return item;
+  if (!schema[Symbol.metadata]._isTypedSchema) return item;
+  return schema[Symbol.metadata]._getModel().getSchema();
+};
 
 // src/getValidationErrors/getError/index.ts
 var import_isNil2 = __toESM(require("lodash/isNil"), 1);
@@ -132,13 +112,13 @@ var import_isString5 = __toESM(require("lodash/isString"), 1);
 // src/fieldType.ts
 function fieldType(opts) {
   const { name, validate: validate2, clean: clean3, ...otherFields } = opts;
-  const overwrittenValidate = /* @__PURE__ */ __name((value, info = {}) => {
+  const overwrittenValidate = (value, info = {}) => {
     if (!info.currentSchema) {
       info.currentSchema = {};
     }
     return validate2(value, info);
-  }, "overwrittenValidate");
-  const overwrittenClean = /* @__PURE__ */ __name((value, info = {}) => {
+  };
+  const overwrittenClean = (value, info = {}) => {
     if (!info.options) {
       info.options = {};
     }
@@ -146,16 +126,16 @@ function fieldType(opts) {
       return clean3(value, info);
     }
     return value;
-  }, "overwrittenClean");
+  };
   return {
     ...otherFields,
     name,
     validate: overwrittenValidate,
     clean: overwrittenClean,
-    _isFieldType: true
+    __isFieldType: true,
+    __tsFieldType: null
   };
 }
-__name(fieldType, "fieldType");
 
 // src/fieldTypes/array.ts
 var import_isArray = __toESM(require("lodash/isArray"), 1);
@@ -191,9 +171,7 @@ var array_default = fieldType({
   clean(value, { options }) {
     if (options.autoConvert) {
       if (!(0, import_isArray.default)(value)) {
-        value = [
-          value
-        ];
+        value = [value];
       }
     }
     return value;
@@ -230,12 +208,12 @@ var string_default = fieldType({
   name: "string",
   validate(value, { currentSchema }) {
     if (!(0, import_isString.default)(value)) return Errors_default.NOT_A_STRING;
-    if (isFinite(currentSchema.min)) {
+    if (Number.isFinite(currentSchema.min)) {
       if (value.length < currentSchema.min) {
         return Errors_default.STRING_TOO_SHORT;
       }
     }
-    if (isFinite(currentSchema.max)) {
+    if (Number.isFinite(currentSchema.max)) {
       if (value.length > currentSchema.max) {
         return Errors_default.STRING_TOO_LONG;
       }
@@ -276,13 +254,13 @@ var date_default = fieldType({
     if (options.autoConvert) {
       if ((0, import_isString2.default)(value)) {
         const result = new Date(value);
-        if (isNaN(result.getTime())) {
+        if (Number.isNaN(result.getTime())) {
           return value;
         }
         value = result;
       } else if ((0, import_isNumber.default)(value)) {
         const result = new Date(value);
-        if (isNaN(result.getTime())) {
+        if (Number.isNaN(result.getTime())) {
           return value;
         }
         value = result;
@@ -296,18 +274,17 @@ var date_default = fieldType({
 var import_isInteger = __toESM(require("lodash/isInteger"), 1);
 
 // src/fieldTypes/number.ts
-var import_isFinite = __toESM(require("lodash/isFinite"), 1);
 var import_toNumber = __toESM(require("lodash/toNumber"), 1);
 var number_default = fieldType({
   name: "number",
   validate(value, { currentSchema }) {
-    if (!(0, import_isFinite.default)(value)) return Errors_default.NOT_A_NUMBER;
-    if ((0, import_isFinite.default)(currentSchema.min)) {
+    if (!Number.isFinite(value)) return Errors_default.NOT_A_NUMBER;
+    if (Number.isFinite(currentSchema.min)) {
       if (value < currentSchema.min) {
         return Errors_default.NUMBER_TOO_SMALL;
       }
     }
-    if ((0, import_isFinite.default)(currentSchema.max)) {
+    if (Number.isFinite(currentSchema.max)) {
       if (value > currentSchema.max) {
         return Errors_default.NUMBER_TOO_BIG;
       }
@@ -362,10 +339,11 @@ var boolean_default = fieldType({
   clean(value, { options }) {
     if (options.autoConvert) {
       if (typeof value === "string") {
-        if (value === "true") {
+        const stringValue = value;
+        if (stringValue === "true") {
           value = true;
         }
-        if (value === "false") {
+        if (stringValue === "false") {
           value = false;
         }
       }
@@ -414,7 +392,7 @@ var blackbox_default = fieldType({
 // src/fieldTypes/any.ts
 var any_default = fieldType({
   name: "any",
-  validate(value) {
+  validate() {
   }
 });
 
@@ -435,19 +413,19 @@ var fieldTypes_default = {
 
 // src/getValidationErrors/getError/getFieldValidator.ts
 var import_has = __toESM(require("lodash/has"), 1);
-function getFieldValidator_default(type) {
+function getFieldValidator(type) {
   if ((0, import_isPlainObject4.default)(type)) {
-    if (type._isFieldType) return "custom";
+    if (type.__isFieldType) return "custom";
     return "plainObject";
   }
   if ((0, import_isArray3.default)(type)) return "array";
   if (type === String) return "string";
-  if (type === Date) return "date";
+  if (typeof type === "function" && type.name === "Date") return "date";
   if (type === Number) return "number";
   if (type === Boolean) return "boolean";
   if (type === "enum") return "string";
   if (!(0, import_isString5.default)(type)) {
-    throw new Error("Field type is invalid. Pass a string or a custom field type. Got " + type);
+    throw new Error(`Field type is invalid. Pass a string or a custom field type. Got ${type}`);
   }
   const exists = (0, import_has.default)(fieldTypes_default, type);
   if (!exists) {
@@ -455,25 +433,17 @@ function getFieldValidator_default(type) {
   }
   return type;
 }
-__name(getFieldValidator_default, "default");
 
 // src/getValidationErrors/getError/index.ts
 async function getValidationErrors(params) {
   const { schema, doc, currentDoc, value, currentSchema, keys, options = {}, args = [] } = params;
-  const info = {
-    schema,
-    doc,
-    currentDoc,
-    keys,
-    currentSchema,
-    options
-  };
+  const info = { schema, doc, currentDoc, keys, currentSchema, options };
   if ((0, import_isNil2.default)(value)) {
     if (!currentSchema.optional && !options.omitRequired) {
       return Errors_default.REQUIRED;
     }
   } else {
-    const validatorKey = getFieldValidator_default(currentSchema.type);
+    const validatorKey = getFieldValidator(currentSchema.type);
     const validator = validatorKey === "custom" ? currentSchema.type : fieldTypes_default[validatorKey];
     const error = await validator.validate(value, info, ...args);
     if (error) {
@@ -496,7 +466,6 @@ async function getValidationErrors(params) {
   }
   return null;
 }
-__name(getValidationErrors, "getValidationErrors");
 
 // src/getValidationErrors/doValidation.ts
 var import_isPlainObject5 = __toESM(require("lodash/isPlainObject"), 1);
@@ -504,20 +473,24 @@ var import_isArray4 = __toESM(require("lodash/isArray"), 1);
 var import_clone = __toESM(require("lodash/clone"), 1);
 var import_isNil3 = __toESM(require("lodash/isNil"), 1);
 var import_difference2 = __toESM(require("lodash/difference"), 1);
+
+// src/getValidationErrors/convertTypedSchema.ts
+var convertOnParam = (info, paramName) => {
+  if (!info[paramName]) return;
+  const type = info[paramName].type;
+  if (!type) return;
+  info[paramName].type = getSchemaFromTypedSchema(type);
+};
+var convertTypedSchema = (info) => {
+  convertOnParam(info, "schema");
+  convertOnParam(info, "currentSchema");
+};
+
+// src/getValidationErrors/doValidation.ts
 async function doValidation(params) {
-  convertTypedModel(params);
+  convertTypedSchema(params);
   const { schema, doc, currentDoc, value, currentSchema, keys = [], addError, options, args } = params;
-  const info = {
-    schema,
-    doc,
-    currentDoc,
-    value,
-    currentSchema,
-    keys,
-    options,
-    args,
-    addError
-  };
+  const info = { schema, doc, currentDoc, value, currentSchema, keys, options, args, addError };
   const error = await getValidationErrors(info);
   if (error) {
     addError(keys, error);
@@ -527,7 +500,7 @@ async function doValidation(params) {
   if ((0, import_isPlainObject5.default)(currentSchema.type)) {
     const type = currentSchema.type;
     if (type) {
-      if (type._isFieldType) {
+      if (type.__isFieldType) {
         return;
       }
       if (typeof type.__skipChildValidation === "function") {
@@ -567,15 +540,12 @@ async function doValidation(params) {
         ...info,
         currentDoc: value,
         value: itemValue,
-        currentSchema: {
-          type: itemSchema
-        },
+        currentSchema: { type: itemSchema },
         keys: keyItemKeys
       });
     }
   }
 }
-__name(doValidation, "doValidation");
 
 // src/getValidationErrors/getValidationErrorsObject.ts
 var import_dot_object = __toESM(require("dot-object"), 1);
@@ -588,40 +558,33 @@ function getValidationErrorsObject(validationErrors) {
   }
   return dot.dot(errors);
 }
-__name(getValidationErrorsObject, "getValidationErrorsObject");
 
 // src/getValidationErrors/index.ts
 var defaultOptions = {
   omitRequired: false
 };
 async function getValidationErrors2(schema, doc, passedOptions = {}, ...args) {
-  schema = getSchemaFromTypedModel(schema);
-  const options = {
-    ...defaultOptions,
-    ...passedOptions
-  };
+  schema = getSchemaFromTypedSchema(schema);
+  const options = { ...defaultOptions, ...passedOptions };
   const errors = [];
-  const addError = /* @__PURE__ */ __name(function(keys, code) {
+  const addError = (keys, code) => {
     errors.push({
       key: keys.join("."),
       code
     });
-  }, "addError");
+  };
   await doValidation({
     schema,
     doc,
     currentDoc: doc,
     value: doc,
-    currentSchema: {
-      type: schema
-    },
+    currentSchema: { type: schema },
     addError,
     options,
     args
   });
   return getValidationErrorsObject(errors);
 }
-__name(getValidationErrors2, "getValidationErrors");
 
 // src/validate.ts
 async function validate(schema, doc, passedOptions = {}, ...args) {
@@ -630,22 +593,19 @@ async function validate(schema, doc, passedOptions = {}, ...args) {
     throw new ValidationError(validationErrors);
   }
 }
-__name(validate, "validate");
 
 // src/isValid.ts
 async function isValid(schema, doc, passedOptions = {}, ...args) {
   const validationErrors = await getValidationErrors2(schema, doc, passedOptions, ...args);
   return !validationErrors;
 }
-__name(isValid, "isValid");
 
 // src/getValidationErrors/getError/getFieldType.ts
 function getFieldType(type) {
-  const validatorKey = getFieldValidator_default(type);
+  const validatorKey = getFieldValidator(type);
   const validator = validatorKey === "custom" ? type : fieldTypes_default[validatorKey];
   return validator;
 }
-__name(getFieldType, "getFieldType");
 
 // src/clean/recursiveClean.ts
 var import_isUndefined = __toESM(require("lodash/isUndefined"), 1);
@@ -663,7 +623,6 @@ function getObjectNode(schema, value) {
   }
   return null;
 }
-__name(getObjectNode, "getObjectNode");
 
 // src/clean/cleanType.ts
 async function cleanType(type, fieldSchema, value, info, ...args) {
@@ -690,11 +649,6 @@ async function cleanType(type, fieldSchema, value, info, ...args) {
       value = defaultValue;
     }
   }
-  const { autoValue } = fieldSchema;
-  if (autoValue) {
-    needReClean = true;
-    value = await autoValue(value, info, ...args);
-  }
   const { clean: clean3 } = fieldSchema;
   if (clean3) {
     needReClean = true;
@@ -705,11 +659,14 @@ async function cleanType(type, fieldSchema, value, info, ...args) {
   }
   return value;
 }
-__name(cleanType, "cleanType");
 
 // src/clean/recursiveClean.ts
 var import_isNil5 = __toESM(require("lodash/isNil"), 1);
-var cleanObjectFields = /* @__PURE__ */ __name(async function({ schema, value, ...other }) {
+var cleanObjectFields = async ({
+  schema,
+  value,
+  ...other
+}) => {
   const keys = Object.keys(schema.type).filter((key) => !key.startsWith("__"));
   const newDoc = {};
   for (const key of keys) {
@@ -729,10 +686,14 @@ var cleanObjectFields = /* @__PURE__ */ __name(async function({ schema, value, .
     }
   }
   return newDoc;
-}, "cleanObjectFields");
-var cleanArrayItems = /* @__PURE__ */ __name(async function({ schema, value, ...other }) {
+};
+var cleanArrayItems = async ({
+  schema,
+  value,
+  ...other
+}) => {
   const schemaType = schema.type[0];
-  const promises = value.map(async (item, index) => {
+  const promises = value.map(async (item) => {
     const newValue = await clean({
       ...other,
       schema: {
@@ -745,7 +706,7 @@ var cleanArrayItems = /* @__PURE__ */ __name(async function({ schema, value, ...
   });
   const result = await Promise.all(promises);
   return result.filter((value2) => !(0, import_isUndefined.default)(value2));
-}, "cleanArrayItems");
+};
 function getArrayNode(schema, value) {
   if ((0, import_isArray5.default)(schema.type) && !(0, import_isNil5.default)(value)) {
     const result = schema;
@@ -753,13 +714,10 @@ function getArrayNode(schema, value) {
   }
   return null;
 }
-__name(getArrayNode, "getArrayNode");
-var clean = /* @__PURE__ */ __name(async function(info) {
-  convertTypedModel(info);
-  let { schema, args = [], value } = info;
-  const currSchema = schema.type === void 0 ? {
-    type: schema
-  } : schema;
+var clean = async (info) => {
+  convertTypedSchema(info);
+  const { schema, args = [], value } = info;
+  const currSchema = schema.type === void 0 ? { type: schema } : schema;
   const objectSchema = getObjectNode(currSchema, value);
   if (objectSchema) {
     const newDoc = await cleanObjectFields({
@@ -774,9 +732,7 @@ var clean = /* @__PURE__ */ __name(async function(info) {
   if (arraySchema) {
     let updatedValue = value;
     if (!(0, import_isArray5.default)(value) && !Array.isArray(value)) {
-      updatedValue = [
-        value
-      ];
+      updatedValue = [value];
     }
     const newDoc = await cleanArrayItems({
       ...info,
@@ -788,7 +744,7 @@ var clean = /* @__PURE__ */ __name(async function(info) {
   }
   const result = await cleanType(currSchema.type, currSchema, value, info, ...args);
   return result;
-}, "clean");
+};
 var recursiveClean_default = clean;
 
 // src/clean/index.ts
@@ -800,15 +756,10 @@ var defaultOptions2 = {
 };
 async function clean2(schema, doc, opts = {}, ...args) {
   if (!doc) return doc;
-  schema = getSchemaFromTypedModel(schema);
-  const options = {
-    ...defaultOptions2,
-    ...opts
-  };
+  schema = getSchemaFromTypedSchema(schema);
+  const options = { ...defaultOptions2, ...opts };
   const params = {
-    schema: {
-      type: schema
-    },
+    schema: { type: schema },
     value: doc,
     doc: options.forceDoc || doc,
     currentDoc: doc,
@@ -818,42 +769,33 @@ async function clean2(schema, doc, opts = {}, ...args) {
   const cleanedResult = await recursiveClean_default(params);
   return cleanedResult;
 }
-__name(clean2, "clean");
 
 // src/validateKey/dotGetSchema.ts
 var import_isPlainObject7 = __toESM(require("lodash/isPlainObject"), 1);
 var import_isNil6 = __toESM(require("lodash/isNil"), 1);
-var dotGet = /* @__PURE__ */ __name(function dotGet2(object, path) {
+var dotGet = function dotGet2(object, path) {
   if (path === "") return object;
   const pathParts = path.split(".");
   const first = pathParts.shift();
   const remainingPath = pathParts.join(".");
   const levelObject = object.type;
   if (first === "$" || /^[0-9]+$/.test(first)) {
-    return dotGet2({
-      type: levelObject[0]
-    }, remainingPath);
-  } else if ((0, import_isPlainObject7.default)(levelObject[first])) {
+    return dotGet2({ type: levelObject[0] }, remainingPath);
+  }
+  if ((0, import_isPlainObject7.default)(levelObject[first])) {
     return dotGet2(levelObject[first], remainingPath);
   }
   if (levelObject === "blackbox") {
-    return {
-      type: "blackbox",
-      optional: true,
-      isBlackboxChild: true
-    };
+    return { type: "blackbox", optional: true, isBlackboxChild: true };
   }
   return null;
-}, "dotGet");
+};
 function dotGetSchema_default(schema, path) {
   if ((0, import_isNil6.default)(schema)) {
     throw new Error("You need to pass a schema");
   }
-  return dotGet({
-    type: schema
-  }, path);
+  return dotGet({ type: schema }, path);
 }
-__name(dotGetSchema_default, "default");
 
 // src/dotGetSchema.ts
 var dotGetSchema_default2 = dotGetSchema_default;
@@ -863,10 +805,7 @@ var defaultOptions3 = {
   filter: true
 };
 async function cleanKey_default(schema, key, value, passedOptions = {}, ...args) {
-  const options = {
-    ...defaultOptions3,
-    ...passedOptions
-  };
+  const options = { ...defaultOptions3, ...passedOptions };
   const keySchema = dotGetSchema_default2(schema, key);
   if (!keySchema) {
     if (options.filter) {
@@ -875,44 +814,35 @@ async function cleanKey_default(schema, key, value, passedOptions = {}, ...args)
       return value;
     }
   }
-  const result = await clean2({
-    clean: keySchema
-  }, {
-    clean: value
-  }, options, ...args);
+  const result = await clean2({ clean: keySchema }, { clean: value }, options, ...args);
   return result.clean;
 }
-__name(cleanKey_default, "default");
 
 // src/validateKey/index.ts
 var defaultOptions4 = {
   filter: false
 };
 async function validateKey_default(schema, key, value, passedOptions = {}, ...args) {
-  const options = {
-    ...defaultOptions4,
-    ...passedOptions
-  };
+  const options = { ...defaultOptions4, ...passedOptions };
   const keySchema = dotGetSchema_default(schema, key);
   if (!keySchema) {
     if (options.filter) {
       return Errors_default.NOT_IN_SCHEMA;
-    } else {
-      return null;
     }
+    return null;
   }
   if (keySchema.isBlackboxChild) {
     return null;
   }
-  const result = await getValidationErrors2({
-    validate: keySchema
-  }, {
-    validate: value
-  }, options, ...args);
+  const result = await getValidationErrors2(
+    { validate: keySchema },
+    { validate: value },
+    options,
+    ...args
+  );
   if (!result) return null;
   return result.validate;
 }
-__name(validateKey_default, "default");
 
 // src/fieldTypes/enum.ts
 var import_isString6 = __toESM(require("lodash/isString"), 1);
@@ -926,19 +856,17 @@ function createEnum(name, values) {
         enumName: name,
         enumValues: values
       },
-      toGraphQLType: /* @__PURE__ */ __name((GraphQL) => {
+      toGraphQLType: (GraphQL) => {
         global.GraphQLEnums = global.GraphQLEnums || {};
         global.GraphQLEnums[name] = global.GraphQLEnums[name] || new GraphQL.GraphQLEnumType({
           name,
           values: values.reduce((result, value) => {
-            result[value] = {
-              value
-            };
+            result[value] = { value };
             return result;
           }, {})
         });
         return global.GraphQLEnums[name];
-      }, "toGraphQLType"),
+      },
       validate(value, { currentSchema }) {
         if (!(0, import_isString6.default)(value)) return Errors_default.NOT_A_STRING;
         if (!(0, import_includes2.default)(values, value)) {
@@ -963,7 +891,75 @@ function createEnum(name, values) {
     })
   };
 }
-__name(createEnum, "createEnum");
+
+// src/models.ts
+Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
+function isSchemaLike(type) {
+  var _a;
+  if (!type) return false;
+  if (objectHasSubObjectWithKey(type, "type")) return true;
+  if ((_a = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _a._getModel) return true;
+  if (type.getModel) return true;
+  if (type.getSchema) return true;
+  if (type.getCleanSchema) return true;
+  if (type.__isModel) return true;
+  if (type.__modelName) return true;
+  return false;
+}
+function isSchemaOrFieldLike(type) {
+  if (Array.isArray(type)) {
+    if (type.length !== 1) return false;
+    return isSchemaOrFieldLike(type[0]);
+  }
+  if (isSchemaLike(type)) return true;
+  try {
+    if (getFieldValidator(type)) return true;
+  } catch {
+    return false;
+  }
+  return false;
+}
+function getSchemaModelName(type) {
+  if (!type) return null;
+  if (type.__modelName) return type.__modelName;
+  if (type.getModel) return type.getModel().name;
+  if (type.getSchema) return type.getSchema().__modelName;
+  return null;
+}
+function getSchemaFromAnyOrionForm(type) {
+  var _a, _b;
+  if ((_a = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _a._getModel) {
+    return (_b = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _b._getModel().getSchema();
+  }
+  if (type == null ? void 0 : type.getModel) return type.getModel().getSchema();
+  if (type.getSchema) {
+    return type.getSchema();
+  }
+  if (type.getSchema) {
+    return type.getSchema();
+  }
+  if (objectHasSubObjectWithKey(type, "type")) return type;
+  return null;
+}
+function objectHasSubObjectWithKey(object, key) {
+  if (!object || typeof object !== "object") return false;
+  for (const key1 in object) {
+    const value = object[key1];
+    if (value && typeof value === "object" && key in value) {
+      return true;
+    }
+  }
+  return false;
+}
+function getSchemaWithMetadataFromAnyOrionForm(type) {
+  return getSchemaFromAnyOrionForm(type);
+}
+
+// src/schemaWithName/index.ts
+function schemaWithName(name, schema) {
+  schema.__modelName = name;
+  return schema;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ValidationError,
@@ -971,9 +967,16 @@ __name(createEnum, "createEnum");
   cleanKey,
   createEnum,
   dotGetSchema,
+  fieldTypes,
   getFieldType,
+  getSchemaFromAnyOrionForm,
+  getSchemaModelName,
+  getSchemaWithMetadataFromAnyOrionForm,
   getValidationErrors,
+  isSchemaLike,
+  isSchemaOrFieldLike,
   isValid,
+  schemaWithName,
   validate,
   validateKey
 });