@powerlines/schema 0.11.44 → 0.11.46

package/dist/type-checks.cjs

@@ -1,64 +1,338 @@
 const require_constants = require('./constants.cjs');
 let _stryke_type_checks = require("@stryke/type-checks");
-let _stryke_json = require("@stryke/json");
 
 //#region src/type-checks.ts
-const JSON_SCHEMA_DATA_TYPE_SET = new Set(require_constants.JSON_SCHEMA_DATA_TYPES);
 const isSetNumber = (value) => typeof value === "number" && Number.isFinite(value);
 const isSetBoolean = (value) => typeof value === "boolean";
-const isNonNegativeInteger = (value) => Number.isInteger(value) && value >= 0;
 const isSchemaLikeValue = (value) => (0, _stryke_type_checks.isSetObject)(value) || isSetBoolean(value);
+const isRecordOfSchemaLike = (value) => (0, _stryke_type_checks.isSetObject)(value) && Object.values(value).every((item) => isSchemaLikeValue(item));
+const isVocabularyMap = (value) => (0, _stryke_type_checks.isSetObject)(value) && Object.values(value).every((item) => isSetBoolean(item));
 const isStringArray = (value) => Array.isArray(value) && value.every((item) => (0, _stryke_type_checks.isSetString)(item));
 const isRecordOfStringArrays = (value) => (0, _stryke_type_checks.isSetObject)(value) && Object.values(value).every((item) => isStringArray(item));
-const TYPE_KEYWORD_VALIDATORS = {
-	string: {
-		minLength: isNonNegativeInteger,
-		maxLength: isNonNegativeInteger,
-		pattern: _stryke_type_checks.isSetString,
-		format: _stryke_type_checks.isSetString,
-		contentEncoding: _stryke_type_checks.isSetString,
-		contentMediaType: _stryke_type_checks.isSetString
-	},
-	number: {
-		minimum: isSetNumber,
-		maximum: isSetNumber,
-		exclusiveMinimum: isSetNumber,
-		exclusiveMaximum: isSetNumber,
-		multipleOf: isSetNumber
-	},
-	integer: {
-		minimum: isSetNumber,
-		maximum: isSetNumber,
-		exclusiveMinimum: isSetNumber,
-		exclusiveMaximum: isSetNumber,
-		multipleOf: isSetNumber
-	},
-	boolean: {},
-	array: {
-		items: isSchemaLikeValue,
-		prefixItems: Array.isArray,
-		contains: isSchemaLikeValue,
-		minItems: isNonNegativeInteger,
-		maxItems: isNonNegativeInteger,
-		uniqueItems: isSetBoolean,
-		minContains: isNonNegativeInteger,
-		maxContains: isNonNegativeInteger
-	},
-	object: {
-		properties: _stryke_type_checks.isSetObject,
-		patternProperties: _stryke_type_checks.isSetObject,
-		additionalProperties: isSchemaLikeValue,
-		required: isStringArray,
-		minProperties: isNonNegativeInteger,
-		maxProperties: isNonNegativeInteger,
-		dependentRequired: isRecordOfStringArrays,
-		dependentSchemas: _stryke_type_checks.isSetObject,
-		propertyNames: isSchemaLikeValue,
-		unevaluatedProperties: isSchemaLikeValue
-	},
-	null: {}
+const JSON_SCHEMA_PRIMITIVE_TYPE_SET = new Set(require_constants.JSON_SCHEMA_PRIMITIVE_TYPES);
+const JSON_SCHEMA_TYPE_SET = new Set(require_constants.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 (0, _stryke_type_checks.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 (0, _stryke_type_checks.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 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) => value === void 0 || (0, _stryke_type_checks.isSetString)(value);
+const isOptionalBoolean = (value) => value === void 0 || isSetBoolean(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) => (0, _stryke_type_checks.isSetString)(item) && JSON_SCHEMA_PRIMITIVE_TYPE_SET.has(item));
+const isOptionalJsonSchemaTypeArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => (0, _stryke_type_checks.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)) 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)) return false;
+	if (!isOptionalString(schema.description)) return false;
+	if (!isOptionalString(schema.docs)) 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.
+*/
+function isJsonSchemaKeywords(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	return hasValidJsonSchemaKeywords(input);
+}
+/**
+* Type guard for generic JSON Schema objects with optional `$ref`.
+*/
+function isJsonSchemaAny(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isOptionalString(schema.$ref);
+}
+/**
+* Type guard for JSON Schema array types.
+*/
+function isJsonSchemaArray(input) {
+	if (!(0, _stryke_type_checks.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 || isSetBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for bigint-backed integer schemas.
+*/
+function isJsonSchemaBigint(input) {
+	if (!(0, _stryke_type_checks.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.
+*/
+function isJsonSchemaBoolean(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "boolean" && isOptionalBoolean(schema.default);
+}
+/**
+* Type guard for date/time schemas.
+*/
+function isJsonSchemaDate(input) {
+	if (!(0, _stryke_type_checks.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 (!(0, _stryke_type_checks.isSetString)(schema.format) || !DATE_FORMAT_SET.has(schema.format)) return false;
+	return isOptionalNumber(schema.minimum) && isOptionalNumber(schema.maximum) && (schema.default === void 0 || (0, _stryke_type_checks.isSetString)(schema.default) || isSetNumber(schema.default));
+}
+/**
+* Type guard for enum-constrained schemas.
+*/
+function isJsonSchemaEnum(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !(0, _stryke_type_checks.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) => (0, _stryke_type_checks.isSetString)(value)) && (defaultValue === void 0 || (0, _stryke_type_checks.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) => isSetBoolean(value)) && (defaultValue === void 0 || isSetBoolean(defaultValue));
+	return typeName === "null" && enumValues.every((value) => value === null) && (defaultValue === void 0 || defaultValue === null);
+}
+/**
+* Type guard for `allOf` composition schemas.
+*/
+function isJsonSchemaAllOf(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !isArrayOf(schema.allOf, isJsonSchema)) return false;
+	return schema.unevaluatedProperties === void 0 || isSetBoolean(schema.unevaluatedProperties) || isJsonSchema(schema.unevaluatedProperties);
+}
+/**
+* Type guard for literal-value schemas.
+*/
+function isJsonSchemaLiteral(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || !("const" in schema)) return false;
+	return schema.type === void 0 || (0, _stryke_type_checks.isSetString)(schema.type) && isJsonSchemaType(schema.type) || isOptionalJsonSchemaTypeArray(schema.type);
+}
+/**
+* Type guard for map tuple-array schemas.
+*/
+function isJsonSchemaMap(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema) || schema.type !== "array" || schema.maxItems !== 125 || !(0, _stryke_type_checks.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.
+*/
+function isJsonSchemaNativeEnum(input) {
+	if (!(0, _stryke_type_checks.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) => (0, _stryke_type_checks.isSetString)(value) || isSetNumber(value));
+}
+/**
+* Type guard for impossible/never schemas.
+*/
+function isJsonSchemaNever(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isJsonSchemaAny(schema.not);
+}
+/**
+* Type guard for `null` schemas.
+*/
+function isJsonSchemaNull(input) {
+	if (!(0, _stryke_type_checks.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.
+*/
+function isJsonSchemaNullable(input) {
+	if (!(0, _stryke_type_checks.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" && (0, _stryke_type_checks.isSetString)(schema.type[1]) && schema.type[1] !== "null" && JSON_SCHEMA_TYPE_SET.has(schema.type[1]) || schema.type[1] === "null" && (0, _stryke_type_checks.isSetString)(schema.type[0]) && schema.type[0] !== "null" && JSON_SCHEMA_TYPE_SET.has(schema.type[0]));
+	return anyOfBranch || typeBranch;
+}
+/**
+* Type guard for numeric schemas.
+*/
+function isJsonSchemaNumber(input) {
+	if (!(0, _stryke_type_checks.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.
+*/
+function isJsonSchemaInteger(input) {
+	return isJsonSchemaNumber(input) && input.type === "integer";
+}
+/**
+* Type guard for decimal schemas.
+*/
+function isJsonSchemaDecimal(input) {
+	return isJsonSchemaNumber(input) && input.type === "number";
+}
+/**
+* Type guard for object schemas.
+*/
+function isJsonSchemaObject(input) {
+	if (!(0, _stryke_type_checks.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 || isSetBoolean(schema.additionalProperties) || isJsonSchema(schema.additionalProperties)) && (schema.required === void 0 || isStringArray(schema.required)) && (schema.unevaluatedProperties === void 0 || isSetBoolean(schema.unevaluatedProperties) || isJsonSchema(schema.unevaluatedProperties)) && (schema.dependencies === void 0 || (0, _stryke_type_checks.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.
+*/
+function isJsonSchemaString(input) {
+	if (!(0, _stryke_type_checks.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, _stryke_type_checks.isSetString)) && isOptionalString(schema.contentMediaType) && isOptionalString(schema.contentEncoding) && isOptionalString(schema.contentSchema);
+}
+/**
+* Type guard for set-like array schemas.
+*/
+function isJsonSchemaSet(input) {
+	if (!(0, _stryke_type_checks.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 || isSetBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for record schemas.
+*/
+function isJsonSchemaRecord(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && schema.type === "object" && (schema.patternProperties === void 0 || isRecordOfSchemaLike(schema.patternProperties)) && (schema.additionalProperties === void 0 || isSetBoolean(schema.additionalProperties) || isJsonSchema(schema.additionalProperties)) && isOptionalJsonSchema(schema.propertyNames);
+}
+/**
+* Type guard for tuple schemas.
+*/
+function isJsonSchemaTuple(input) {
+	if (!(0, _stryke_type_checks.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 || isSetBoolean(schema.unevaluatedItems) || isJsonSchema(schema.unevaluatedItems));
+}
+/**
+* Type guard for undefined-representing schemas.
+*/
+function isJsonSchemaUndefined(input) {
+	if (!(0, _stryke_type_checks.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.
+*/
+function isJsonSchemaPrimitiveUnion(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	if (!hasValidJsonSchemaKeywords(schema)) return false;
+	if ((0, _stryke_type_checks.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) => (0, _stryke_type_checks.isSetString)(value)) && (schema.default === void 0 || (0, _stryke_type_checks.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) => isSetBoolean(value)) && (schema.default === void 0 || isSetBoolean(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.
+*/
+function isJsonSchemaUnion(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && (isJsonSchemaPrimitiveUnion(schema) || isJsonSchemaAnyOf(schema));
+}
+/**
+* Type guard for permissive unknown schemas.
+*/
+function isJsonSchemaUnknown(input) {
+	return isJsonSchemaAny(input);
+}
+/**
+* Type guard for `anyOf` composition schemas.
+*/
+function isJsonSchemaAnyOf(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && isArrayOf(schema.anyOf, isJsonSchema);
+}
+/**
+* Type guard for reference schemas.
+*/
+function isJsonSchemaRef(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	return hasValidJsonSchemaKeywords(schema) && (0, _stryke_type_checks.isSetString)(schema.$ref);
+}
+/**
 * Type guard for Standard Schema V1 objects.
 *
 * @param input - The value to check.
@@ -92,36 +366,7 @@ function isValibotSchema(input) {
 * @returns True if the input is a JSON Schema type, false otherwise.
 */
 function isJsonSchema(input) {
-	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
-	const schema = input;
-	if ("$ref" in schema && (0, _stryke_type_checks.isSetString)(schema.$ref)) return true;
-	if (!("type" in schema)) return false;
-	const schemaTypes = [];
-	if ((0, _stryke_type_checks.isSetString)(schema.type)) {
-		if (!JSON_SCHEMA_DATA_TYPE_SET.has(schema.type)) return false;
-		schemaTypes.push(schema.type);
-	} else if (Array.isArray(schema.type) && schema.type.length > 0) {
-		if (!schema.type.every((schemaType) => (0, _stryke_type_checks.isSetString)(schemaType) && JSON_SCHEMA_DATA_TYPE_SET.has(schemaType)) || new Set(schema.type).size !== schema.type.length) return false;
-		schemaTypes.push(...schema.type);
-	} else return false;
-	const typeKeywordValidators = schemaTypes.flatMap((schemaType) => Object.entries(TYPE_KEYWORD_VALIDATORS[schemaType]));
-	for (const [keyword, validator] of typeKeywordValidators) if (keyword in schema && !validator(schema[keyword])) return false;
-	if ("minItems" in schema && "maxItems" in schema && isNonNegativeInteger(schema.minItems) && isNonNegativeInteger(schema.maxItems) && schema.minItems > schema.maxItems) return false;
-	if ("minLength" in schema && "maxLength" in schema && isNonNegativeInteger(schema.minLength) && isNonNegativeInteger(schema.maxLength) && schema.minLength > schema.maxLength) return false;
-	if ("minProperties" in schema && "maxProperties" in schema && isNonNegativeInteger(schema.minProperties) && isNonNegativeInteger(schema.maxProperties) && schema.minProperties > schema.maxProperties) return false;
-	return true;
-}
-/**
-* Type guard for JSON Schema object forms.
-*
-* @remarks
-* This function checks if the input is a JSON Schema object type, which is defined as having a `type` property equal to "object" or having a `properties` object. This is used to determine if a given input conforms to the structure of a JSON Schema object definition.
-*
-* @param input - The value to check.
-* @returns True if the input is a JSON Schema object type, false otherwise.
-*/
-function isJsonSchemaObject(input) {
-	return (0, _stryke_json.isJsonSchemaObjectType)(input) && (input.type === "object" || (0, _stryke_type_checks.isObject)(input.properties));
+	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`.
@@ -133,7 +378,7 @@ function isJsonSchemaObject(input) {
 * @returns True if the input is a JSON Schema that only accepts `null`, false otherwise.
 */
 function isNullOnlyJsonSchema(input) {
-	return isJsonSchema(input) && input.type === "null";
+	return isJsonSchemaNull(input);
 }
 /**
 * Type guard for untyped schema objects.
@@ -186,16 +431,51 @@ function isUntypedInput(input) {
 function isSchema(input) {
 	return (0, _stryke_type_checks.isSetObject)(input) && "schema" in input && isJsonSchema(input.schema) && "variant" in input && (0, _stryke_type_checks.isSetString)(input.variant) && "hash" in input && (0, _stryke_type_checks.isSetString)(input.hash);
 }
-function isExtractedSchema(input) {
+/**
+* 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 && (0, _stryke_type_checks.isSetObject)(input.source) && "schema" in input.source && "variant" in input.source && (0, _stryke_type_checks.isSetString)(input.source.variant);
 }
 
 //#endregion
-exports.isExtractedSchema = isExtractedSchema;
 exports.isJsonSchema = isJsonSchema;
+exports.isJsonSchemaAllOf = isJsonSchemaAllOf;
+exports.isJsonSchemaAny = isJsonSchemaAny;
+exports.isJsonSchemaAnyOf = isJsonSchemaAnyOf;
+exports.isJsonSchemaArray = isJsonSchemaArray;
+exports.isJsonSchemaBigint = isJsonSchemaBigint;
+exports.isJsonSchemaBoolean = isJsonSchemaBoolean;
+exports.isJsonSchemaDate = isJsonSchemaDate;
+exports.isJsonSchemaDecimal = isJsonSchemaDecimal;
+exports.isJsonSchemaEnum = isJsonSchemaEnum;
+exports.isJsonSchemaInteger = isJsonSchemaInteger;
+exports.isJsonSchemaKeywords = isJsonSchemaKeywords;
+exports.isJsonSchemaLiteral = isJsonSchemaLiteral;
+exports.isJsonSchemaMap = isJsonSchemaMap;
+exports.isJsonSchemaNativeEnum = isJsonSchemaNativeEnum;
+exports.isJsonSchemaNever = isJsonSchemaNever;
+exports.isJsonSchemaNull = isJsonSchemaNull;
+exports.isJsonSchemaNullable = isJsonSchemaNullable;
+exports.isJsonSchemaNumber = isJsonSchemaNumber;
 exports.isJsonSchemaObject = isJsonSchemaObject;
+exports.isJsonSchemaPrimitiveType = isJsonSchemaPrimitiveType;
+exports.isJsonSchemaPrimitiveUnion = isJsonSchemaPrimitiveUnion;
+exports.isJsonSchemaRecord = isJsonSchemaRecord;
+exports.isJsonSchemaRef = isJsonSchemaRef;
+exports.isJsonSchemaSet = isJsonSchemaSet;
+exports.isJsonSchemaString = isJsonSchemaString;
+exports.isJsonSchemaTuple = isJsonSchemaTuple;
+exports.isJsonSchemaType = isJsonSchemaType;
+exports.isJsonSchemaUndefined = isJsonSchemaUndefined;
+exports.isJsonSchemaUnion = isJsonSchemaUnion;
+exports.isJsonSchemaUnknown = isJsonSchemaUnknown;
 exports.isNullOnlyJsonSchema = isNullOnlyJsonSchema;
 exports.isSchema = isSchema;
+exports.isSchemaWithSource = isSchemaWithSource;
 exports.isStandardSchema = isStandardSchema;
 exports.isUntypedInput = isUntypedInput;
 exports.isUntypedSchema = isUntypedSchema;