@powerlines/schema 0.11.81 → 0.11.82

package/dist/type-checks.mjs

@@ -0,0 +1,594 @@
+import { JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES } from "./constants.mjs";
+import { isBoolean, isFunction, isSetObject, isSetString, isString } from "@stryke/type-checks";
+
+//#region src/type-checks.ts
+const isSetNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isSchemaLikeValue = (value) => isSetObject(value) || isBoolean(value);
+const isRecordOfSchemaLike = (value) => isSetObject(value) && Object.values(value).every((item) => isSchemaLikeValue(item));
+const isVocabularyMap = (value) => isSetObject(value) && Object.values(value).every((item) => isBoolean(item));
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => isSetString(item));
+const isRecordOfStringArrays = (value) => isSetObject(value) && Object.values(value).every((item) => isStringArray(item));
+const JSON_SCHEMA_PRIMITIVE_TYPE_SET = new Set(JSON_SCHEMA_PRIMITIVE_TYPES);
+const JSON_SCHEMA_TYPE_SET = new Set(JSON_SCHEMA_TYPES);
+/**
+* A helper type guard to check if a value is a JSON Schema primitive type.
+*
+* @param value - The value to check.
+* @returns True if the value is a JSON Schema primitive type, false otherwise.
+*/
+function isJsonSchemaPrimitiveType(value) {
+	return isSetString(value) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(value);
+}
+/**
+* A helper type guard to check if a value is a JSON Schema type.
+*
+* @param value - The value to check.
+* @returns True if the value is a JSON Schema type, false otherwise.
+*/
+function isJsonSchemaType(value) {
+	return isSetString(value) && JSON_SCHEMA_TYPE_SET.has(value);
+}
+const DATE_FORMAT_SET = new Set([
+	"date",
+	"time",
+	"date-time",
+	"iso-time",
+	"iso-date-time",
+	"unix-time"
+]);
+const isSetBigint = (value) => typeof value === "bigint";
+const UNTYPED_TYPE_NAME_SET = new Set([
+	"string",
+	"number",
+	"bigint",
+	"boolean",
+	"symbol",
+	"function",
+	"object",
+	"any",
+	"array"
+]);
+const isUntypedJSType = (value) => isSetString(value) && UNTYPED_TYPE_NAME_SET.has(value);
+const isUntypedTypeDescriptor = (value) => {
+	if (!isSetObject(value)) return false;
+	const descriptor = value;
+	if (descriptor.type !== void 0 && !(isSetString(descriptor.type) && isUntypedJSType(descriptor.type) || Array.isArray(descriptor.type) && descriptor.type.every((item) => isUntypedJSType(item)))) return false;
+	if (descriptor.tsType !== void 0 && !isSetString(descriptor.tsType)) return false;
+	if (descriptor.markdownType !== void 0 && !isSetString(descriptor.markdownType)) return false;
+	if (descriptor.items !== void 0 && !(isUntypedTypeDescriptor(descriptor.items) || Array.isArray(descriptor.items) && descriptor.items.every((item) => isUntypedTypeDescriptor(item)))) return false;
+	return true;
+};
+const isUntypedFunctionArg = (value) => {
+	if (!isUntypedTypeDescriptor(value)) return false;
+	const arg = value;
+	if (arg.name !== void 0 && !isSetString(arg.name)) return false;
+	return arg.optional === void 0 || typeof arg.optional === "boolean";
+};
+const isRecordOfUntypedSchema = (value) => isSetObject(value) && Object.values(value).every((item) => isUntypedSchema(item));
+const isArrayOf = (value, predicate) => Array.isArray(value) && value.every((item) => predicate(item));
+const isTupleOfTwo = (value, aPredicate, bPredicate) => Array.isArray(value) && value.length === 2 && aPredicate(value[0]) && bPredicate(value[1]);
+const isOptionalString = (value, allowEmpty = false) => value === void 0 || isString(value) && (allowEmpty || value.length > 0);
+const isOptionalBoolean = (value) => value === void 0 || isBoolean(value);
+const isOptionalNumber = (value) => value === void 0 || isSetNumber(value);
+const isOptionalBigint = (value) => value === void 0 || isSetBigint(value);
+const isOptionalJsonSchema = (value) => value === void 0 || isJsonSchema(value);
+const isOptionalJsonSchemaArray = (value) => value === void 0 || isArrayOf(value, isJsonSchema);
+const isOptionalPrimitiveTypeArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => isSetString(item) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(item));
+const isOptionalJsonSchemaTypeArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => isSetString(item) && JSON_SCHEMA_TYPE_SET.has(item));
+const hasValidJsonSchemaKeywords = (schema) => {
+	if (!isOptionalString(schema.$id)) return false;
+	if (!isOptionalString(schema.$schema)) return false;
+	if (schema.$vocabulary !== void 0 && !isVocabularyMap(schema.$vocabulary)) return false;
+	if (!isOptionalString(schema.$comment, true)) return false;
+	if (!isOptionalString(schema.$anchor)) return false;
+	if (schema.$defs !== void 0 && !isRecordOfSchemaLike(schema.$defs)) return false;
+	if (!isOptionalString(schema.$dynamicRef)) return false;
+	if (!isOptionalString(schema.$dynamicAnchor)) return false;
+	if (!isOptionalString(schema.name)) return false;
+	if (!isOptionalString(schema.title, true)) return false;
+	if (!isOptionalString(schema.description, true)) return false;
+	if (!isOptionalString(schema.docs, true)) return false;
+	if (schema.examples !== void 0 && !Array.isArray(schema.examples)) return false;
+	if (schema.alias !== void 0 && !isStringArray(schema.alias)) return false;
+	if (schema.tags !== void 0 && !isStringArray(schema.tags)) return false;
+	if (!isOptionalBoolean(schema.deprecated)) return false;
+	if (!isOptionalBoolean(schema.hidden)) return false;
+	if (!isOptionalBoolean(schema.ignore)) return false;
+	if (!isOptionalBoolean(schema.internal)) return false;
+	if (!isOptionalBoolean(schema.runtime)) return false;
+	if (!isOptionalBoolean(schema.readOnly)) return false;
+	if (!isOptionalBoolean(schema.writeOnly)) return false;
+	if (!isOptionalJsonSchemaArray(schema.allOf)) return false;
+	if (!isOptionalJsonSchemaArray(schema.anyOf)) return false;
+	if (!isOptionalJsonSchemaArray(schema.oneOf)) return false;
+	if (!isOptionalJsonSchema(schema.not)) return false;
+	if (!isOptionalJsonSchema(schema.if)) return false;
+	if (!isOptionalJsonSchema(schema.then)) return false;
+	if (!isOptionalJsonSchema(schema.else)) return false;
+	return true;
+};
+/**
+* Type guard for shared JSON Schema keyword groups.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema keyword group, false otherwise.
+*/
+function isJsonSchemaKeywords(input) {
+	if (!isSetObject(input)) return false;
+	return hasValidJsonSchemaKeywords(input);
+}
+/**
+* Type guard for generic JSON Schema objects with optional `$ref`.
+*
+* @param input - The value to check.
+* @returns True if the input is a generic JSON Schema object, false otherwise.
+*/
+function isJsonSchemaAny(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isOptionalString(schema.$ref);
+}
+/**
+* Type guard for JSON Schema array types.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema array schema, false otherwise.
+*/
+function isJsonSchemaArray(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "array") return false;
+	return isOptionalJsonSchemaArray(schema.prefixItems) && isOptionalJsonSchema(schema.items) && isOptionalJsonSchema(schema.contains) && isOptionalNumber(schema.minItems) && isOptionalNumber(schema.maxItems) && isOptionalBoolean(schema.uniqueItems) && isOptionalNumber(schema.minContains) && isOptionalNumber(schema.maxContains) && (schema.unevaluatedItems === void 0 || isBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for bigint-backed integer schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a bigint-backed integer schema, false otherwise.
+*/
+function isJsonSchemaBigint(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "integer" || schema.format !== "int64") return false;
+	return isOptionalBigint(schema.minimum) && isOptionalBigint(schema.exclusiveMinimum) && isOptionalBigint(schema.maximum) && isOptionalBigint(schema.exclusiveMaximum) && isOptionalBigint(schema.multipleOf) && isOptionalBigint(schema.default) && (schema.enum === void 0 || isArrayOf(schema.enum, isSetBigint));
+}
+/**
+* Type guard for boolean schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a boolean schema, false otherwise.
+*/
+function isJsonSchemaBoolean(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "boolean" && isOptionalBoolean(schema.default);
+}
+/**
+* Type guard for date/time schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a date or time schema, false otherwise.
+*/
+function isJsonSchemaDate(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema)) return false;
+	if (schema.anyOf !== void 0) return isArrayOf(schema.anyOf, isJsonSchemaDate);
+	if (schema.type !== "integer" && schema.type !== "string") return false;
+	if (!isSetString(schema.format) || !DATE_FORMAT_SET.has(schema.format)) return false;
+	return isOptionalNumber(schema.minimum) && isOptionalNumber(schema.maximum) && (schema.default === void 0 || isSetString(schema.default) || isSetNumber(schema.default));
+}
+/**
+* Type guard for enum-constrained schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an enum-constrained schema, false otherwise.
+*/
+function isJsonSchemaEnum(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !isSetString(schema.type) || !JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(schema.type) || !Array.isArray(schema.enum)) return false;
+	const typeName = schema.type;
+	const enumValues = schema.enum;
+	const defaultValue = schema.default;
+	if (typeName === "string") return enumValues.every((value) => isSetString(value)) && (defaultValue === void 0 || isSetString(defaultValue));
+	if (typeName === "number" || typeName === "integer") return enumValues.every((value) => isSetNumber(value)) && (defaultValue === void 0 || isSetNumber(defaultValue));
+	if (typeName === "boolean") return enumValues.every((value) => isBoolean(value)) && (defaultValue === void 0 || isBoolean(defaultValue));
+	return typeName === "null" && enumValues.every((value) => value === null) && (defaultValue === void 0 || defaultValue === null);
+}
+/**
+* Type guard for `allOf` composition schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an `allOf` schema, false otherwise.
+*/
+function isJsonSchemaAllOf(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !isArrayOf(schema.allOf, isJsonSchema)) return false;
+	return schema.unevaluatedProperties === void 0 || isBoolean(schema.unevaluatedProperties) || isJsonSchema(schema.unevaluatedProperties);
+}
+/**
+* Type guard for literal-value schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a literal-value schema, false otherwise.
+*/
+function isJsonSchemaLiteral(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !("const" in schema)) return false;
+	return schema.type === void 0 || isSetString(schema.type) && isJsonSchemaType(schema.type) || isOptionalJsonSchemaTypeArray(schema.type);
+}
+/**
+* Type guard for map tuple-array schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a map tuple-array schema, false otherwise.
+*/
+function isJsonSchemaMap(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "array" || schema.maxItems !== 125 || !isSetObject(schema.items)) return false;
+	const items = schema.items;
+	return items.type === "array" && isTupleOfTwo(items.prefixItems, isJsonSchema, isJsonSchema) && (items.items === void 0 || items.items === false) && items.minItems === 2 && items.maxItems === 2;
+}
+/**
+* Type guard for native enum schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a native enum schema, false otherwise.
+*/
+function isJsonSchemaNativeEnum(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	const isValidType = schema.type === "string" || schema.type === "number" || Array.isArray(schema.type) && schema.type.length === 2 && schema.type[0] === "string" && schema.type[1] === "number";
+	return hasValidJsonSchemaKeywords(schema) && isValidType && Array.isArray(schema.enum) && schema.enum.every((value) => isSetString(value) || isSetNumber(value));
+}
+/**
+* Type guard for impossible/never schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a never schema, false otherwise.
+*/
+function isJsonSchemaNever(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isJsonSchemaAny(schema.not);
+}
+/**
+* Type guard for `null` schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a null schema, false otherwise.
+*/
+function isJsonSchemaNull(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "null" && (schema.const === void 0 || schema.const === null) && (schema.enum === void 0 || Array.isArray(schema.enum) && schema.enum.every((v) => v === null)) && (schema.default === void 0 || schema.default === null);
+}
+/**
+* Type guard for nullable schema unions.
+*
+* @param input - The value to check.
+* @returns True if the input is a nullable schema union, false otherwise.
+*/
+function isJsonSchemaNullable(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema)) return false;
+	const anyOfBranch = schema.anyOf !== void 0 && Array.isArray(schema.anyOf) && schema.anyOf.length === 2 && isJsonSchema(schema.anyOf[0]) && isJsonSchemaNull(schema.anyOf[1]);
+	const typeBranch = Array.isArray(schema.type) && schema.type.length === 2 && (schema.type[0] === "null" && isSetString(schema.type[1]) && schema.type[1] !== "null" && JSON_SCHEMA_TYPE_SET.has(schema.type[1]) || schema.type[1] === "null" && isSetString(schema.type[0]) && schema.type[0] !== "null" && JSON_SCHEMA_TYPE_SET.has(schema.type[0]));
+	return anyOfBranch || typeBranch;
+}
+/**
+* Type guard for numeric schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a numeric schema, false otherwise.
+*/
+function isJsonSchemaNumber(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "number" && schema.type !== "integer") return false;
+	return isOptionalString(schema.format) && isOptionalNumber(schema.minimum) && isOptionalNumber(schema.exclusiveMinimum) && isOptionalNumber(schema.maximum) && isOptionalNumber(schema.exclusiveMaximum) && isOptionalNumber(schema.multipleOf) && isOptionalNumber(schema.default) && (schema.enum === void 0 || isArrayOf(schema.enum, isSetNumber));
+}
+/**
+* Type guard for integer schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an integer schema, false otherwise.
+*/
+function isJsonSchemaInteger(input) {
+	return isJsonSchemaNumber(input) && input.type === "integer";
+}
+/**
+* Type guard for decimal schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a decimal schema, false otherwise.
+*/
+function isJsonSchemaDecimal(input) {
+	return isJsonSchemaNumber(input) && input.type === "number";
+}
+/**
+* Type guard for object schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an object schema, false otherwise.
+*/
+function isJsonSchemaObject(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "object" && (schema.properties === void 0 || isRecordOfSchemaLike(schema.properties)) && (schema.patternProperties === void 0 || isRecordOfSchemaLike(schema.patternProperties)) && (schema.additionalProperties === void 0 || isBoolean(schema.additionalProperties) || isJsonSchema(schema.additionalProperties)) && (schema.required === void 0 || isStringArray(schema.required)) && (schema.unevaluatedProperties === void 0 || isBoolean(schema.unevaluatedProperties) || isJsonSchema(schema.unevaluatedProperties)) && (schema.dependencies === void 0 || isSetObject(schema.dependencies) && Object.values(schema.dependencies).every((item) => isStringArray(item) || isJsonSchema(item))) && (schema.dependentRequired === void 0 || isRecordOfStringArrays(schema.dependentRequired)) && (schema.dependentSchemas === void 0 || isRecordOfSchemaLike(schema.dependentSchemas)) && isOptionalNumber(schema.minProperties) && isOptionalNumber(schema.maxProperties) && (schema.primaryKey === void 0 || isStringArray(schema.primaryKey)) && isOptionalString(schema.databaseSchema);
+}
+/**
+* Type guard for string schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a string schema, false otherwise.
+*/
+function isJsonSchemaString(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "string" && isOptionalNumber(schema.minLength) && isOptionalNumber(schema.maxLength) && isOptionalString(schema.pattern) && isOptionalString(schema.format) && isOptionalString(schema.default) && (schema.enum === void 0 || isArrayOf(schema.enum, isSetString)) && isOptionalString(schema.contentMediaType) && isOptionalString(schema.contentEncoding) && isOptionalString(schema.contentSchema);
+}
+/**
+* Type guard for set-like array schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a set-like array schema, false otherwise.
+*/
+function isJsonSchemaSet(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "array" && schema.uniqueItems === true && isOptionalJsonSchemaArray(schema.prefixItems) && isOptionalJsonSchema(schema.items) && isOptionalJsonSchema(schema.contains) && isOptionalNumber(schema.minItems) && isOptionalNumber(schema.maxItems) && isOptionalNumber(schema.minContains) && isOptionalNumber(schema.maxContains) && (schema.unevaluatedItems === void 0 || isBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for record schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a record schema, false otherwise.
+*/
+function isJsonSchemaRecord(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "object" && (schema.patternProperties === void 0 || isRecordOfSchemaLike(schema.patternProperties)) && (schema.additionalProperties === void 0 || isBoolean(schema.additionalProperties) || isJsonSchema(schema.additionalProperties)) && isOptionalJsonSchema(schema.propertyNames);
+}
+/**
+* Type guard for tuple schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a tuple schema, false otherwise.
+*/
+function isJsonSchemaTuple(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "array" && isArrayOf(schema.prefixItems, isJsonSchema) && isOptionalNumber(schema.minItems) && isOptionalNumber(schema.maxItems) && isOptionalJsonSchema(schema.items) && isOptionalJsonSchema(schema.contains) && isOptionalBoolean(schema.uniqueItems) && isOptionalNumber(schema.minContains) && isOptionalNumber(schema.maxContains) && (schema.unevaluatedItems === void 0 || isBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for undefined-representing schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an undefined-representing schema, false otherwise.
+*/
+function isJsonSchemaUndefined(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isJsonSchemaAny(schema.not) && (schema.default === void 0 || schema.default === void 0);
+}
+/**
+* Type guard for primitive-union schema variants.
+*
+* @param input - The value to check.
+* @returns True if the input is a primitive-union schema variant, false otherwise.
+*/
+function isJsonSchemaPrimitiveUnion(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema)) return false;
+	if (isSetString(schema.type) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(schema.type)) {
+		if (schema.enum === void 0) return true;
+		if (!Array.isArray(schema.enum)) return false;
+		if (schema.type === "string") return schema.enum.every((value) => isSetString(value)) && (schema.default === void 0 || isSetString(schema.default));
+		if (schema.type === "number") return schema.enum.every((value) => isSetNumber(value)) && (schema.default === void 0 || isSetNumber(schema.default));
+		if (schema.type === "boolean") return schema.enum.every((value) => isBoolean(value)) && (schema.default === void 0 || isBoolean(schema.default));
+		if (schema.type === "integer") {
+			if (schema.format !== "int64") return false;
+			return schema.enum.every((value) => isSetBigint(value)) && (schema.default === void 0 || isSetBigint(schema.default));
+		}
+		return schema.type === "null" && schema.enum.every((value) => value === null) && (schema.default === void 0 || schema.default === null);
+	}
+	return isOptionalPrimitiveTypeArray(schema.type) && schema.type !== void 0;
+}
+/**
+* Type guard for union schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a union schema, false otherwise.
+*/
+function isJsonSchemaUnion(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && (isJsonSchemaPrimitiveUnion(schema) || isJsonSchemaAnyOf(schema));
+}
+/**
+* Type guard for permissive unknown schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a permissive unknown schema, false otherwise.
+*/
+function isJsonSchemaUnknown(input) {
+	return isJsonSchemaAny(input);
+}
+/**
+* Type guard for `anyOf` composition schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is an `anyOf` schema, false otherwise.
+*/
+function isJsonSchemaAnyOf(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isArrayOf(schema.anyOf, isJsonSchema);
+}
+/**
+* Type guard for reference schemas.
+*
+* @param input - The value to check.
+* @returns True if the input is a reference schema, false otherwise.
+*/
+function isJsonSchemaRef(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isSetString(schema.$ref);
+}
+/**
+* Type guard for Standard Schema V1 objects.
+*
+* @param input - The value to check.
+* @returns True if the input is a Standard Schema V1 object, false otherwise.
+*/
+function isStandardSchema(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!isSetObject(schema["~standard"])) return false;
+	const standard = schema["~standard"];
+	return standard.version === 1 && isFunction(standard.validate);
+}
+/**
+* Type guard for Valibot BaseSchema objects.
+*
+* @param input - The value to check.
+* @returns True if the input is a Valibot BaseSchema, false otherwise.
+*/
+function isValibotSchema(input) {
+	if (!isSetObject(input) || !isStandardSchema(input)) return false;
+	const schema = input;
+	return schema.kind === "schema" && isSetString(schema.type) && isBoolean(schema.async) && isFunction(schema.reference) && isSetString(schema.expects) && isFunction(schema["~run"]);
+}
+/**
+* Type guard for JSON Schema types.
+*
+* @remarks
+* This function checks if the input is a JSON Schema type, which is defined as having a `type` property or a `$ref` property. This is used to determine if a given input conforms to the structure of a JSON Schema definition that includes type information.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema type, false otherwise.
+*/
+function isJsonSchema(input) {
+	return isJsonSchemaString(input) || isJsonSchemaInteger(input) || isJsonSchemaDecimal(input) || isJsonSchemaBigint(input) || isJsonSchemaBoolean(input) || isJsonSchemaDate(input) || isJsonSchemaEnum(input) || isJsonSchemaLiteral(input) || isJsonSchemaNativeEnum(input) || isJsonSchemaNull(input) || isJsonSchemaArray(input) || isJsonSchemaObject(input) || isJsonSchemaRecord(input) || isJsonSchemaTuple(input) || isJsonSchemaUnion(input) || isJsonSchemaUndefined(input) || isJsonSchemaRef(input) || isJsonSchemaNever(input) || isJsonSchemaMap(input) || isJsonSchemaAny(input) || isJsonSchemaNullable(input) || isJsonSchemaAllOf(input) || isJsonSchemaUnknown(input) || isJsonSchemaSet(input);
+}
+/**
+* Type guard for JSON Schemas that only accept `null`.
+*
+* @remarks
+* This function checks if the input is a JSON Schema that exclusively accepts the `null` type. It verifies that the input is a valid JSON Schema and that its `type` property is set to "null". This is useful for identifying schemas that are specifically designed to allow only `null` values.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema that only accepts `null`, false otherwise.
+*/
+function isNullOnlyJsonSchema(input) {
+	return isJsonSchemaNull(input);
+}
+/**
+* Type guard for untyped schema objects.
+*
+* @remarks
+* This function checks if the input is an untyped schema object, which is defined as having certain properties that are commonly found in untyped schema definitions. This includes properties such as `id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., strings for certain properties, arrays for others). This type guard is used to determine if a given input can be treated as an untyped schema object within the context of the Powerlines schema system.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped schema object, false otherwise.
+*/
+function isUntypedSchema(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if (!isUntypedTypeDescriptor(schema)) return false;
+	if ("id" in schema && !isSetString(schema.id)) return false;
+	if ("resolve" in schema && !isFunction(schema.resolve)) return false;
+	if ("properties" in schema && !isRecordOfUntypedSchema(schema.properties)) return false;
+	if ("required" in schema && !isStringArray(schema.required)) return false;
+	if ("title" in schema && !isSetString(schema.title)) return false;
+	if ("description" in schema && !isSetString(schema.description)) return false;
+	if ("$schema" in schema && !isSetString(schema.$schema)) return false;
+	if ("tags" in schema && !isStringArray(schema.tags)) return false;
+	if ("args" in schema && (!Array.isArray(schema.args) || !schema.args.every((item) => isUntypedFunctionArg(item)))) return false;
+	if ("returns" in schema && !isUntypedTypeDescriptor(schema.returns)) return false;
+	return true;
+}
+/**
+* Strict type guard for untyped schema objects.
+*
+* @remarks
+* This guard narrows values to the Untyped schema model while explicitly
+* rejecting values that are also valid JSON Schema instances.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped schema and not a JSON Schema.
+*/
+function isUntypedSchemaStrict(input) {
+	return isUntypedSchema(input) && !isJsonSchema(input);
+}
+/**
+* Type guard for untyped input objects.
+*
+* @remarks
+* This function checks if the input is an untyped input object, which is defined as having certain properties that are commonly found in untyped input definitions. This includes properties such as `$schema` and `$resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., objects for `$schema`, functions for `$resolve`). This type guard is used to determine if a given input can be treated as an untyped input object within the context of the Powerlines schema system.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped input object, false otherwise.
+*/
+function isUntypedInput(input) {
+	if (!isSetObject(input)) return false;
+	const inputObject = input;
+	if ("$schema" in inputObject && !isUntypedSchema(inputObject.$schema)) return false;
+	if ("$resolve" in inputObject && !isFunction(inputObject.$resolve)) return false;
+	return true;
+}
+/**
+* Strict type guard for untyped input objects.
+*
+* @remarks
+* This guard narrows values to the Untyped input-object model while
+* explicitly rejecting values that are valid JSON Schema objects.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped input object and not JSON Schema.
+*/
+function isUntypedInputStrict(input) {
+	if (!isUntypedInput(input) || isJsonSchema(input)) return false;
+	const inputObject = input;
+	if ("$schema" in inputObject && inputObject.$schema !== void 0 && !isUntypedSchemaStrict(inputObject.$schema)) return false;
+	return true;
+}
+/**
+* Type guard for Powerlines Schema objects.
+*
+* @param input - The value to check.
+* @returns True if the input is a Powerlines Schema object, false otherwise.
+*/
+function isSchema(input) {
+	return isSetObject(input) && "schema" in input && isJsonSchema(input.schema) && "variant" in input && isSetString(input.variant) && "hash" in input && isSetString(input.hash);
+}
+/**
+* Type guard for extracted schema objects that include source information.
+*
+* @param input - The value to check.
+* @returns True if the input is a SchemaWithSource object, false otherwise.
+*/
+function isSchemaWithSource(input) {
+	return isSchema(input) && "source" in input && isSetObject(input.source) && "schema" in input.source && "variant" in input.source && isSetString(input.source.variant);
+}
+/**
+* Type guard for Powerlines Schemas that are in Object form.
+*
+* @param input - The value to check.
+* @returns True if the input is a Powerlines Schema object in Object form, false otherwise.
+*/
+function isSchemaObject(input) {
+	return isSchema(input) && isJsonSchemaObject(input.schema);
+}
+
+//#endregion
+export { isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isSchema, isSchemaObject, isSchemaWithSource, isStandardSchema, isUntypedInput, isUntypedInputStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema };
+//# sourceMappingURL=type-checks.mjs.map