@yaag/cli 0.1.0

package/assets/types/typebox/build/schema/static/schema.d.mts

@@ -0,0 +1,56 @@
+import type { XAdditionalProperties } from '../types/additionalProperties.mjs';
+import type { XAnyOf } from '../types/anyOf.mjs';
+import type { XAllOf } from '../types/allOf.mjs';
+import type { XConst } from '../types/const.mjs';
+import type { XEnum } from '../types/enum.mjs';
+import type { XIf } from '../types/if.mjs';
+import type { XItems } from '../types/items.mjs';
+import type { XOneOf } from '../types/oneOf.mjs';
+import type { XPatternProperties } from '../types/patternProperties.mjs';
+import type { XPrefixItems } from '../types/prefixItems.mjs';
+import type { XProperties } from '../types/properties.mjs';
+import type { XRef } from '../types/ref.mjs';
+import type { XRequired } from '../types/required.mjs';
+import type { XSchema } from '../types/schema.mjs';
+import type { XType } from '../types/type.mjs';
+import type { XUnevaluatedProperties } from '../types/unevaluatedProperties.mjs';
+import type { XStaticAdditionalProperties } from './additionalProperties.mjs';
+import type { XStaticAllOf } from './allOf.mjs';
+import type { XStaticAnyOf } from './anyOf.mjs';
+import type { XStaticConst } from './const.mjs';
+import type { XStaticEnum } from './enum.mjs';
+import type { XStaticIf } from './if.mjs';
+import type { XStaticItems } from './items.mjs';
+import type { XStaticOneOf } from './oneOf.mjs';
+import type { XStaticPatternProperties } from './patternProperties.mjs';
+import type { XStaticPrefixItems } from './prefixItems.mjs';
+import type { XStaticProperties } from './properties.mjs';
+import type { XStaticRef } from './ref.mjs';
+import type { XStaticRequired } from './required.mjs';
+import type { XStaticType } from './type.mjs';
+import type { XStaticUnevaluatedProperties } from './unevaluatedProperties.mjs';
+type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends unknown[] = [
+    Schema extends XAdditionalProperties<infer Type extends XSchema> ? XStaticAdditionalProperties<Stack, Root, Type> : unknown,
+    Schema extends XAllOf<infer Types extends XSchema[]> ? XStaticAllOf<Stack, Root, Types> : unknown,
+    Schema extends XAnyOf<infer Types extends XSchema[]> ? XStaticAnyOf<Stack, Root, Types> : unknown,
+    Schema extends XConst<infer Value extends unknown> ? XStaticConst<Value> : unknown,
+    Schema extends XIf<infer Type extends XSchema> ? XStaticIf<Stack, Root, Schema, Type> : unknown,
+    Schema extends XEnum<infer Values extends unknown[]> ? XStaticEnum<Values> : unknown,
+    Schema extends XItems<infer Types extends XSchema[] | XSchema> ? XStaticItems<Stack, Root, Schema, Types> : unknown,
+    Schema extends XOneOf<infer Types extends XSchema[]> ? XStaticOneOf<Stack, Root, Types> : unknown,
+    Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
+    Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
+    Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Schema, Properties> : unknown,
+    Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
+    Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
+    Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,
+    Schema extends XUnevaluatedProperties<infer Type extends XSchema> ? XStaticUnevaluatedProperties<Stack, Root, Type> : unknown
+]> = Result;
+type XKeywordsIntersected<Schemas extends unknown[], Result extends unknown = unknown> = (Schemas extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XKeywordsIntersected<Right, Result & Left> : Result);
+type XKeywordsEvaluated<Schema extends unknown, Result extends unknown = Schema extends object ? {
+    [Key in keyof Schema]: Schema[Key];
+} : Schema> = Result;
+export type XStaticObject<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keywords extends unknown[] = XFromKeywords<Stack, Root, Schema>, Intersected extends unknown = XKeywordsIntersected<Keywords>, Evaluated extends unknown = XKeywordsEvaluated<Intersected>> = Evaluated;
+export type XStaticBoolean<Schema extends boolean, Result extends unknown = Schema extends false ? never : unknown> = Result;
+export type XStaticSchema<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends unknown = Schema extends boolean ? XStaticBoolean<Schema> : XStaticObject<Stack, Root, Schema>> = Result;
+export {};

package/assets/types/typebox/build/schema/static/static.d.mts

@@ -0,0 +1,4 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XCanonical } from './_canonical.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStatic<Value extends unknown, Schema extends XSchema = Value extends XSchema ? Value : {}, Canonical extends XSchema = XCanonical<Schema>, Result extends unknown = XStaticSchema<[], Canonical, Canonical>> = Result;

package/assets/types/typebox/build/schema/static/type.d.mts

@@ -0,0 +1,4 @@
+type XFromTypeNames<TypeNames extends string[], Result extends unknown = never> = (TypeNames extends readonly [infer Left extends string, ...infer Right extends string[]] ? XFromTypeNames<Right, Result | XFromTypeName<Left>> : Result);
+type XFromTypeName<TypeName extends string> = (TypeName extends 'object' ? object : TypeName extends 'array' ? {} : TypeName extends 'boolean' ? boolean : TypeName extends 'integer' ? number : TypeName extends 'number' ? number : TypeName extends 'null' ? null : TypeName extends 'string' ? string : TypeName extends 'bigint' ? bigint : TypeName extends 'symbol' ? symbol : TypeName extends 'undefined' ? undefined : TypeName extends 'void' ? void : TypeName extends 'asyncIterator' ? {} : TypeName extends 'constructor' ? {} : TypeName extends 'function' ? {} : TypeName extends 'iterator' ? {} : unknown);
+export type XStaticType<TypeName extends string[] | string> = (TypeName extends string[] ? XFromTypeNames<TypeName> : TypeName extends string ? XFromTypeName<TypeName> : unknown);
+export {};

package/assets/types/typebox/build/schema/static/unevaluatedProperties.d.mts

@@ -0,0 +1,7 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticUnevaluatedProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
+    [key: string]: unknown;
+} : Schema extends false ? {} : {
+    [key: string]: XStaticSchema<Stack, Root, Schema>;
+})> = Result;

package/assets/types/typebox/build/schema/types/_refine.d.mts

@@ -0,0 +1,13 @@
+import type { XSchemaObject } from './schema.mjs';
+export interface XRefinement {
+    check: (value: unknown) => boolean;
+    error: (value: unknown) => string;
+}
+export interface XRefine<Refinements extends XRefinement[] = XRefinement[]> {
+    '~refine': Refinements;
+}
+/**
+ * Returns true if the schema contains an '~refine` keyword
+ * @specification None
+ */
+export declare function IsRefine(value: XSchemaObject): value is XRefine;

package/assets/types/typebox/build/schema/types/additionalItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from '../types/schema.mjs';
+export interface XAdditionalItems<AdditionalItems extends XSchema = XSchema> {
+    additionalItems: AdditionalItems;
+}
+/**
+ * Returns true if the schema contains a valid additionalItems property
+ * @specification Json Schema 7
+ */
+export declare function IsAdditionalItems(schema: XSchemaObject): schema is XAdditionalItems;

package/assets/types/typebox/build/schema/types/additionalProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAdditionalProperties<AdditionalProperties extends XSchema = XSchema> {
+    additionalProperties: AdditionalProperties;
+}
+/**
+ * Returns true if the schema contains a valid additionalProperties property
+ * @specification Json Schema 7
+ */
+export declare function IsAdditionalProperties(schema: XSchemaObject): schema is XAdditionalProperties;

package/assets/types/typebox/build/schema/types/allOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAllOf<AllOf extends XSchema[] = XSchema[]> {
+    allOf: AllOf;
+}
+/**
+ * Returns true if the schema contains a valid allOf property
+ * @specification Json Schema 7
+ */
+export declare function IsAllOf(schema: XSchemaObject): schema is XAllOf;

package/assets/types/typebox/build/schema/types/anchor.d.mts

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XAnchor<Anchor extends string = string> {
+    $anchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $anchor property
+ */
+export declare function IsAnchor(schema: XSchemaObject): schema is XAnchor;

package/assets/types/typebox/build/schema/types/anyOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XAnyOf<AnyOf extends XSchema[] = XSchema[]> {
+    anyOf: AnyOf;
+}
+/**
+ * Returns true if the schema contains a valid anyOf property
+ * @specification Json Schema 7
+ */
+export declare function IsAnyOf(schema: XSchemaObject): schema is XAnyOf;

package/assets/types/typebox/build/schema/types/const.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XConst<Const extends unknown = unknown> {
+    const: Const;
+}
+/**
+ * Returns true if the schema contains a valid const property
+ * @specification Json Schema 7
+ */
+export declare function IsConst(value: XSchemaObject): value is XConst;

package/assets/types/typebox/build/schema/types/contains.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XContains<Contains extends XSchema = XSchema> {
+    contains: Contains;
+}
+/**
+ * Returns true if the schema contains a valid contains property
+ * @specification Json Schema 7
+ */
+export declare function IsContains(schema: XSchemaObject): schema is XContains;

package/assets/types/typebox/build/schema/types/contentEncoding.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XContentEncoding<ContentEncoding extends string = string> {
+    contentEncoding: ContentEncoding;
+}
+/**
+ * Returns true if the schema contains a valid contentEncoding property
+ * @specification Json Schema 7
+ */
+export declare function IsContentEncoding(schema: XSchemaObject): schema is XContentEncoding;

package/assets/types/typebox/build/schema/types/contentMediaType.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XContentMediaType<ContentMediaType extends string = string> {
+    contentMediaType: ContentMediaType;
+}
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export declare function IsContentMediaType(schema: XSchemaObject): schema is XContentMediaType;

package/assets/types/typebox/build/schema/types/default.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDefault<Default extends unknown = unknown> {
+    default: Default;
+}
+/**
+ * Returns true if the schema contains a valid contentMediaType property
+ * @specification Json Schema 7
+ */
+export declare function IsDefault(schema: XSchemaObject): schema is XDefault;

package/assets/types/typebox/build/schema/types/defs.d.mts

@@ -0,0 +1,6 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XDefs<Defs extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    $defs: Defs;
+}
+/** Returns true if the schema contains a valid $defs property */
+export declare function IsDefs(schema: XSchemaObject): schema is XDefs;

package/assets/types/typebox/build/schema/types/dependencies.d.mts

@@ -0,0 +1,11 @@
+import { type XSchemaObject } from './schema.mjs';
+type XDependenciesProperty = Record<PropertyKey, boolean | Record<PropertyKey, unknown> | string[]>;
+export interface XDependencies<Dependencies extends XDependenciesProperty = XDependenciesProperty> {
+    dependencies: Dependencies;
+}
+/**
+ * Returns true if the schema contains a valid dependencies property
+ * @specification Json Schema 7
+ */
+export declare function IsDependencies(schema: XSchemaObject): schema is XDependencies;
+export {};

package/assets/types/typebox/build/schema/types/dependentRequired.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDependentRequired<DependentRequired extends Record<PropertyKey, string[]> = Record<PropertyKey, string[]>> {
+    dependentRequired: DependentRequired;
+}
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsDependentRequired(schema: XSchemaObject): schema is XDependentRequired;

package/assets/types/typebox/build/schema/types/dependentSchemas.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XDependentSchemas<DependentSchemas extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    dependentSchemas: DependentSchemas;
+}
+/**
+ * Returns true if the schema contains a valid dependentRequired property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsDependentSchemas(schema: XSchemaObject): schema is XDependentSchemas;

package/assets/types/typebox/build/schema/types/dynamicAnchor.d.mts

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDynamicAnchor<Anchor extends string = string> {
+    $dynamicAnchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $dynamicAnchor property
+ */
+export declare function IsDynamicAnchor(schema: XSchemaObject): schema is XDynamicAnchor;

package/assets/types/typebox/build/schema/types/dynamicRef.d.mts

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XDynamicRef<Ref extends string = string> {
+    $dynamicRef: Ref;
+}
+/**
+ * Returns true if the schema contains a valid $dynamicRef property
+ */
+export declare function IsDynamicRef(schema: XSchemaObject): schema is XDynamicRef;

package/assets/types/typebox/build/schema/types/else.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XElse<Else extends XSchema = XSchema> {
+    else: Else;
+}
+/**
+ * Returns true if the schema contains a valid else property
+ * @specification Json Schema 7
+ */
+export declare function IsElse(schema: XSchemaObject): schema is XElse;

package/assets/types/typebox/build/schema/types/enum.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XEnum<Enum extends unknown[] = unknown[]> {
+    enum: Enum;
+}
+/**
+ * Returns true if the schema contains a valid enum property
+ * @specification Json Schema 7
+ */
+export declare function IsEnum(schema: XSchemaObject): schema is XEnum;

package/assets/types/typebox/build/schema/types/exclusiveMaximum.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XExclusiveMaximum<ExclusiveMaximum extends number | bigint = number | bigint> {
+    exclusiveMaximum: ExclusiveMaximum;
+}
+/**
+ * Returns true if the schema contains a valid exclusiveMaximum property
+ * @specification Json Schema 7
+ */
+export declare function IsExclusiveMaximum(schema: XSchemaObject): schema is XExclusiveMaximum;

package/assets/types/typebox/build/schema/types/exclusiveMinimum.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XExclusiveMinimum<ExclusiveMinimum extends number | bigint = number | bigint> {
+    exclusiveMinimum: ExclusiveMinimum;
+}
+/**
+ * Returns true if the schema contains a valid exclusiveMinimum property
+ * @specification Json Schema 7
+ */
+export declare function IsExclusiveMinimum(schema: XSchemaObject): schema is XExclusiveMinimum;

package/assets/types/typebox/build/schema/types/format.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XFormat<Format extends string = string> {
+    format: Format;
+}
+/**
+ * Returns true if the schema contains a valid format property
+ * @specification Json Schema 7
+ */
+export declare function IsFormat(schema: XSchemaObject): schema is XFormat;

package/assets/types/typebox/build/schema/types/id.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XId<Id extends string = string> {
+    $id: Id;
+}
+/**
+ * Returns true if the schema contains a valid $id property
+ * @specification Json Schema 7
+ */
+export declare function IsId(schema: XSchemaObject): schema is XId;

package/assets/types/typebox/build/schema/types/if.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XIf<If extends XSchema = XSchema> {
+    if: If;
+}
+/**
+ * Returns true if the schema contains a valid $id property
+ * @specification Json Schema 7
+ */
+export declare function IsIf(schema: XSchemaObject): schema is XIf;

package/assets/types/typebox/build/schema/types/index.d.mts

@@ -0,0 +1,53 @@
+export * from './_refine.mjs';
+export * from './additionalItems.mjs';
+export * from './additionalProperties.mjs';
+export * from './allOf.mjs';
+export * from './anchor.mjs';
+export * from './anyOf.mjs';
+export * from './const.mjs';
+export * from './contains.mjs';
+export * from './contentEncoding.mjs';
+export * from './contentMediaType.mjs';
+export * from './default.mjs';
+export * from './defs.mjs';
+export * from './dependencies.mjs';
+export * from './dependentRequired.mjs';
+export * from './dependentSchemas.mjs';
+export * from './dynamicAnchor.mjs';
+export * from './dynamicRef.mjs';
+export * from './else.mjs';
+export * from './enum.mjs';
+export * from './exclusiveMaximum.mjs';
+export * from './exclusiveMinimum.mjs';
+export * from './format.mjs';
+export * from './id.mjs';
+export * from './if.mjs';
+export * from './items.mjs';
+export * from './maximum.mjs';
+export * from './maxContains.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './minimum.mjs';
+export * from './minContains.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './multipleOf.mjs';
+export * from './not.mjs';
+export * from './oneOf.mjs';
+export * from './pattern.mjs';
+export * from './patternProperties.mjs';
+export * from './prefixItems.mjs';
+export * from './properties.mjs';
+export * from './propertyNames.mjs';
+export * from './recursiveAnchor.mjs';
+export * from './recursiveRef.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './schema.mjs';
+export * from './then.mjs';
+export * from './type.mjs';
+export * from './uniqueItems.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';

package/assets/types/typebox/build/schema/types/items.d.mts

@@ -0,0 +1,19 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XItemsSized<Items extends XSchema[] = XSchema[]> {
+    items: Items;
+}
+export interface XItemsUnsized<Items extends XSchema = XSchema> {
+    items: Items;
+}
+export interface XItems<Items extends (XSchema | XSchema[]) = (XSchema | XSchema[])> {
+    items: Items;
+}
+/**
+ * Returns true if the schema contains a valid items property
+ * @specification Json Schema 7
+ */
+export declare function IsItems(schema: XSchemaObject): schema is XItems;
+/** Returns true if this schema is a sized items variant */
+export declare function IsItemsSized(schema: XSchemaObject): schema is XItemsSized;
+/** Returns true if this schema is a unsized items variant */
+export declare function IsItemsUnsized(schema: XSchemaObject): schema is XItemsUnsized;

package/assets/types/typebox/build/schema/types/maxContains.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMaxContains<MaxContains extends number = number> {
+    maxContains: MaxContains;
+}
+/**
+ * Returns true if the schema contains a valid maxContains property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsMaxContains(schema: XSchemaObject): schema is XMaxContains;

package/assets/types/typebox/build/schema/types/maxItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMaxItems<MaxItems extends number = number> {
+    maxItems: MaxItems;
+}
+/**
+ * Returns true if the schema contains a valid maxItems property
+ * @specification Json Schema 7
+ */
+export declare function IsMaxItems(schema: XSchemaObject): schema is XMaxItems;

package/assets/types/typebox/build/schema/types/maxLength.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMaxLength<MaxLength extends number = number> {
+    maxLength: MaxLength;
+}
+/**
+ * Returns true if the schema contains a valid maxLength property
+ * @specification Json Schema 7
+ */
+export declare function IsMaxLength(schema: XSchemaObject): schema is XMaxLength;

package/assets/types/typebox/build/schema/types/maxProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMaxProperties<MaxProperties extends number = number> {
+    maxProperties: MaxProperties;
+}
+/**
+ * Returns true if the schema contains a valid maxProperties property
+ * @specification Json Schema 7
+ */
+export declare function IsMaxProperties(schema: XSchemaObject): schema is XMaxProperties;

package/assets/types/typebox/build/schema/types/maximum.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMaximum<Maximum extends number | bigint = number | bigint> {
+    maximum: Maximum;
+}
+/**
+ * Returns true if the schema contains a valid maximum property
+ * @specification Json Schema 7
+ */
+export declare function IsMaximum(schema: XSchemaObject): schema is XMaximum;

package/assets/types/typebox/build/schema/types/minContains.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMinContains<MinContains extends number = number> {
+    minContains: MinContains;
+}
+/**
+ * Returns true if the schema contains a valid maxContains property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsMinContains(schema: XSchemaObject): schema is XMinContains;

package/assets/types/typebox/build/schema/types/minItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMinItems<MinItems extends number = number> {
+    minItems: MinItems;
+}
+/**
+ * Returns true if the schema contains a valid minItems property
+ * @specification Json Schema 7
+ */
+export declare function IsMinItems(schema: XSchemaObject): schema is XMinItems;

package/assets/types/typebox/build/schema/types/minLength.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMinLength<MinLength extends number = number> {
+    minLength: MinLength;
+}
+/**
+ * Returns true if the schema contains a valid minLength property
+ * @specification Json Schema 7
+ */
+export declare function IsMinLength(schema: XSchemaObject): schema is XMinLength;

package/assets/types/typebox/build/schema/types/minProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMinProperties<MinProperties extends number = number> {
+    minProperties: MinProperties;
+}
+/**
+ * Returns true if the schema contains a valid minProperties property
+ * @specification Json Schema 7
+ */
+export declare function IsMinProperties(schema: XSchemaObject): schema is XMinProperties;

package/assets/types/typebox/build/schema/types/minimum.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMinimum<Minimum extends number | bigint = number | bigint> {
+    minimum: Minimum;
+}
+/**
+ * Returns true if the schema contains a valid minimum property
+ * @specification Json Schema 7
+ */
+export declare function IsMinimum(schema: XSchemaObject): schema is XMinimum;

package/assets/types/typebox/build/schema/types/multipleOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMultipleOf<MultipleOf extends number | bigint = number | bigint> {
+    multipleOf: MultipleOf;
+}
+/**
+ * Returns true if the schema contains a valid multipleOf property
+ * @specification Json Schema 7
+ */
+export declare function IsMultipleOf(schema: XSchemaObject): schema is XMultipleOf;

package/assets/types/typebox/build/schema/types/not.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XNot<Not extends XSchema = XSchema> {
+    not: Not;
+}
+/**
+ * Returns true if the schema contains a valid not property
+ * @specification Json Schema 7
+ */
+export declare function IsNot(schema: XSchemaObject): schema is XNot;

package/assets/types/typebox/build/schema/types/oneOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XOneOf<OneOf extends XSchema[] = XSchema[]> {
+    oneOf: OneOf;
+}
+/**
+ * Returns true if the schema contains a valid oneOf property
+ * @specification Json Schema 7
+ */
+export declare function IsOneOf(schema: XSchemaObject): schema is XOneOf;

package/assets/types/typebox/build/schema/types/pattern.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XPattern<Pattern extends string | RegExp = string | RegExp> {
+    pattern: Pattern;
+}
+/**
+ * Returns true if the schema contains a valid pattern property
+ * @specification Json Schema 7
+ */
+export declare function IsPattern(schema: XSchemaObject): schema is XPattern;

package/assets/types/typebox/build/schema/types/patternProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPatternProperties<PatternProperties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    patternProperties: PatternProperties;
+}
+/**
+ * Returns true if the schema contains a valid patternProperties property
+ * @specification Json Schema 7
+ */
+export declare function IsPatternProperties(schema: XSchemaObject): schema is XPatternProperties;

package/assets/types/typebox/build/schema/types/prefixItems.d.mts

@@ -0,0 +1,8 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPrefixItems<PrefixItems extends XSchema[] = XSchema[]> {
+    prefixItems: PrefixItems;
+}
+/**
+ * Returns true if the schema contains a valid prefixItems property
+ */
+export declare function IsPrefixItems(schema: XSchemaObject): schema is XPrefixItems;

package/assets/types/typebox/build/schema/types/properties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XProperties<Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    properties: Properties;
+}
+/**
+ * Returns true if the schema contains a valid properties property
+ * @specification Json Schema 7
+ */
+export declare function IsProperties(schema: XSchemaObject): schema is XProperties;

package/assets/types/typebox/build/schema/types/propertyNames.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPropertyNames<PropertyNames extends XSchema = XSchema> {
+    propertyNames: PropertyNames;
+}
+/**
+ * Returns true if the schema contains a valid propertyNames property
+ * @specification Json Schema 7
+ */
+export declare function IsPropertyNames(schema: XSchemaObject): schema is XPropertyNames;

package/assets/types/typebox/build/schema/types/recursiveAnchor.d.mts

@@ -0,0 +1,12 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XRecursiveAnchor<Anchor extends string = string> {
+    $recursiveAnchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property
+ */
+export declare function IsRecursiveAnchor(schema: XSchemaObject): schema is XRecursiveAnchor;
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property that is true
+ */
+export declare function IsRecursiveAnchorTrue(schema: XSchemaObject): schema is XRecursiveAnchor;