@regle/schemas 1.7.1 → 1.8.0-beta.1

package/dist/regle-schemas.d.ts

@@ -1246,24 +1246,6 @@ type Not<T extends boolean> = T extends true ? false : true;
  * {@linkcode Types} array is `true`, otherwise returns `false`.
  */
 
-/**
- * Checks if all the boolean types in the {@linkcode Types} array are `true`.
- */
-type And<Types extends boolean[]> = Types[number] extends true ? true : false;
-/**
- * Represents an equality type that returns {@linkcode Right} if
- * {@linkcode Left} is `true`,
- * otherwise returns the negation of {@linkcode Right}.
- */
-
-/**
- * @internal
- */
-declare const secret: unique symbol;
-/**
- * @internal
- */
-type Secret = typeof secret;
 /**
  * Checks if the given type is `never`.
  */
@@ -1271,47 +1253,7 @@ type IsNever$2<T> = [T] extends [never] ? true : false;
 /**
  * Checks if the given type is `any`.
  */
-type IsAny$2<T> = [T] extends [Secret] ? Not<IsNever$2<T>> : false;
-/**
- * Determines if the given type is `unknown`.
- */
-type IsUnknown$1<T> = [unknown] extends [T] ? Not<IsAny$2<T>> : false;
-/**
- * Determines if a type is either `never` or `any`.
- */
 
-/**
- * Subjective "useful" keys from a type. For objects it's just `keyof` but for
- * tuples/arrays it's the number keys.
- *
- * @example
- * ```ts
- * UsefulKeys<{ a: 1; b: 2 }> // 'a' | 'b'
- *
- * UsefulKeys<['a', 'b']> // '0' | '1'
- *
- * UsefulKeys<string[]> // number
- * ```
- */
-type UsefulKeys<T> = T extends any[] ? { [K in keyof T]: K }[number] : keyof T;
-/**
- * Extracts the keys from a type that are required (not optional).
- */
-type RequiredKeys<T> = Extract<{ [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T], keyof T>;
-/**
- * Gets the keys of an object type that are optional.
- */
-type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-/**
- * Extracts the keys from a type that are not `readonly`.
- */
-type ReadonlyKeys<T> = Extract<{ [K in keyof T]-?: ReadonlyEquivalent<{ [_K in K]: T[K] }, { -readonly [_K in K]: T[K] }> extends true ? never : K }[keyof T], keyof T>;
-/**
- * Determines if two types, are equivalent in a `readonly` manner.
- *
- * @internal
- */
-type ReadonlyEquivalent<X, Y> = Extends<(<T>() => T extends X ? true : false), (<T>() => T extends Y ? true : false)>;
 /**
  * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because:
  * 1. If either type is `never`, the result is `true` iff the other type is also `never`.
@@ -1323,24 +1265,6 @@ type Extends<Left, Right> = IsNever$2<Left> extends true ? IsNever$2<Right> : [L
  * excluding `any` or `never`.
  */
 
-/**
- * Checks if two types are strictly equal using
- * the TypeScript internal identical-to operator.
- *
- * @see {@link https://github.com/microsoft/TypeScript/issues/55188#issuecomment-1656328122 | much history}
- */
-type StrictEqualUsingTSInternalIdenticalToOperator<L, R> = (<T>() => T extends (L & T) | T ? true : false) extends (<T>() => T extends (R & T) | T ? true : false) ? IsNever$2<L> extends IsNever$2<R> ? true : false : false;
-/**
- * Checks that {@linkcode Left} and {@linkcode Right} extend each other.
- * Not quite the same as an equality check since `any` can make it resolve
- * to `true`. So should only be used when {@linkcode Left} and
- * {@linkcode Right} are known to avoid `any`.
- */
-type MutuallyExtends<Left, Right> = And<[Extends<Left, Right>, Extends<Right, Left>]>;
-/**
- * @internal
- */
-
 /**
  * Convert a union to an intersection.
  * `A | B | C` -\> `A & B & C`
@@ -1375,344 +1299,6 @@ type IsUnion<T> = Not<Extends<UnionToTuple$1<T>['length'], 1>>;
  * ```
  */
 //#endregion
-//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/overloads.d.ts
-/**
- * The simple(ish) way to get overload info from a function
- * {@linkcode FunctionType}. Recent versions of TypeScript will match any
- * function against a generic 10-overload type, filling in slots with
- * duplicates of the function. So, we can just match against a single type
- * and get all the overloads.
- *
- * For older versions of TypeScript, we'll need to painstakingly do
- * ten separate matches.
- */
-type TSPost53OverloadsInfoUnion<FunctionType> = FunctionType extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-  (...args: infer A5): infer R5;
-  (...args: infer A6): infer R6;
-  (...args: infer A7): infer R7;
-  (...args: infer A8): infer R8;
-  (...args: infer A9): infer R9;
-  (...args: infer A10): infer R10;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : never;
-/**
- * A function with `unknown` parameters and return type.
- */
-type UnknownFunction = (...args: unknown[]) => unknown;
-/**
- * `true` iff {@linkcode FunctionType} is
- * equivalent to `(...args: unknown[]) => unknown`,
- * which is what an overload variant looks like for a non-existent overload.
- * This is useful because older versions of TypeScript end up with
- * 9 "useless" overloads and one real one for parameterless/generic functions.
- *
- * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
- */
-type IsUselessOverloadInfo<FunctionType> = StrictEqualUsingTSInternalIdenticalToOperator<FunctionType, UnknownFunction>;
-/**
- * Old versions of TypeScript can sometimes seem to refuse to separate out
- * union members unless you put them each in a pointless tuple and add an
- * extra `infer X` expression. There may be a better way to work around this
- * problem, but since it's not a problem in newer versions of TypeScript,
- * it's not a priority right now.
- */
-type Tuplify<Union> = Union extends infer X ? [X] : never;
-/**
- * For older versions of TypeScript, we need two separate workarounds
- * to get overload info. First, we need need to use
- * {@linkcode DecreasingOverloadsInfoUnion} to get the overload info for
- * functions with 1-10 overloads. Then, we need to filter out the
- * "useless" overloads that are present in older versions of TypeScript,
- * for parameterless functions. To do this we use
- * {@linkcode IsUselessOverloadInfo} to remove useless overloads.
- *
- * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
- */
-type TSPre53OverloadsInfoUnion<FunctionType> = Tuplify<DecreasingOverloadsInfoUnion<FunctionType>> extends infer Tup ? Tup extends [infer Fn] ? IsUselessOverloadInfo<Fn> extends true ? never : Fn : never : never;
-/**
- * For versions of TypeScript below 5.3, we need to check for 10 overloads,
- * then 9, then 8, etc., to get a union of the overload variants.
- */
-type DecreasingOverloadsInfoUnion<F> = F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-  (...args: infer A5): infer R5;
-  (...args: infer A6): infer R6;
-  (...args: infer A7): infer R7;
-  (...args: infer A8): infer R8;
-  (...args: infer A9): infer R9;
-  (...args: infer A10): infer R10;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-  (...args: infer A5): infer R5;
-  (...args: infer A6): infer R6;
-  (...args: infer A7): infer R7;
-  (...args: infer A8): infer R8;
-  (...args: infer A9): infer R9;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-  (...args: infer A5): infer R5;
-  (...args: infer A6): infer R6;
-  (...args: infer A7): infer R7;
-  (...args: infer A8): infer R8;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-  (...args: infer A5): infer R5;
-  (...args: infer A6): infer R6;
-  (...args: infer A7): infer R7;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-  (...args: infer A5): infer R5;
-  (...args: infer A6): infer R6;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-  (...args: infer A5): infer R5;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-  (...args: infer A4): infer R4;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-  (...args: infer A3): infer R3;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) : F extends {
-  (...args: infer A1): infer R1;
-  (...args: infer A2): infer R2;
-} ? ((...p: A1) => R1) | ((...p: A2) => R2) : F extends ((...args: infer A1) => infer R1) ? ((...p: A1) => R1) : never;
-/**
- * Get a union of overload variants for a function {@linkcode FunctionType}.
- * Does a check for whether we can do the one-shot
- * 10-overload matcher (which works for ts\>5.3), and if not,
- * falls back to the more complicated utility.
- */
-type OverloadsInfoUnion<FunctionType> = IsNever$2<TSPost53OverloadsInfoUnion<(a: 1) => 2>> extends true ? TSPre53OverloadsInfoUnion<FunctionType> : TSPost53OverloadsInfoUnion<FunctionType>;
-/**
- * Allows inferring any function using the `infer` keyword.
- */
-
-/**
- * The simple(ish) way to get overload info from a constructor
- * {@linkcode ConstructorType}. Recent versions of TypeScript will match any
- * constructor against a generic 10-overload type, filling in slots with
- * duplicates of the constructor. So, we can just match against a single type
- * and get all the overloads.
- *
- * For older versions of TypeScript,
- * we'll need to painstakingly do ten separate matches.
- */
-type TSPost53ConstructorOverloadsInfoUnion<ConstructorType> = ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-  new (...args: infer A5): infer R5;
-  new (...args: infer A6): infer R6;
-  new (...args: infer A7): infer R7;
-  new (...args: infer A8): infer R8;
-  new (...args: infer A9): infer R9;
-  new (...args: infer A10): infer R10;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : never;
-/**
- * A constructor function with `unknown` parameters and return type.
- */
-type UnknownConstructor = new (...args: unknown[]) => unknown;
-/**
- * Same as {@linkcode IsUselessOverloadInfo}, but for constructors.
- */
-type IsUselessConstructorOverloadInfo<FunctionType> = StrictEqualUsingTSInternalIdenticalToOperator<FunctionType, UnknownConstructor>;
-/**
- * For older versions of TypeScript, we need two separate workarounds to
- * get constructor overload info. First, we need need to use
- * {@linkcode DecreasingConstructorOverloadsInfoUnion} to get the overload
- * info for constructors with 1-10 overloads. Then, we need to filter out the
- * "useless" overloads that are present in older versions of TypeScript,
- * for parameterless constructors. To do this we use
- * {@linkcode IsUselessConstructorOverloadInfo} to remove useless overloads.
- *
- * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related}
- */
-type TSPre53ConstructorOverloadsInfoUnion<ConstructorType> = Tuplify<DecreasingConstructorOverloadsInfoUnion<ConstructorType>> extends infer Tup ? Tup extends [infer Ctor] ? IsUselessConstructorOverloadInfo<Ctor> extends true ? never : Ctor : never : never;
-/**
- * For versions of TypeScript below 5.3, we need to check for 10 overloads,
- * then 9, then 8, etc., to get a union of the overload variants.
- */
-type DecreasingConstructorOverloadsInfoUnion<ConstructorType> = ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-  new (...args: infer A5): infer R5;
-  new (...args: infer A6): infer R6;
-  new (...args: infer A7): infer R7;
-  new (...args: infer A8): infer R8;
-  new (...args: infer A9): infer R9;
-  new (...args: infer A10): infer R10;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-  new (...args: infer A5): infer R5;
-  new (...args: infer A6): infer R6;
-  new (...args: infer A7): infer R7;
-  new (...args: infer A8): infer R8;
-  new (...args: infer A9): infer R9;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-  new (...args: infer A5): infer R5;
-  new (...args: infer A6): infer R6;
-  new (...args: infer A7): infer R7;
-  new (...args: infer A8): infer R8;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-  new (...args: infer A5): infer R5;
-  new (...args: infer A6): infer R6;
-  new (...args: infer A7): infer R7;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-  new (...args: infer A5): infer R5;
-  new (...args: infer A6): infer R6;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-  new (...args: infer A5): infer R5;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-  new (...args: infer A4): infer R4;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-  new (...args: infer A3): infer R3;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) : ConstructorType extends {
-  new (...args: infer A1): infer R1;
-  new (...args: infer A2): infer R2;
-} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) : ConstructorType extends (new (...args: infer A1) => infer R1) ? (new (...p: A1) => R1) : never;
-/**
- * Get a union of overload variants for a constructor
- * {@linkcode ConstructorType}. Does a check for whether we can do the
- * one-shot 10-overload matcher (which works for ts\>5.3), and if not,
- * falls back to the more complicated utility.
- */
-type ConstructorOverloadsUnion<ConstructorType> = IsNever$2<TSPost53ConstructorOverloadsInfoUnion<new (a: 1) => any>> extends true ? TSPre53ConstructorOverloadsInfoUnion<ConstructorType> : TSPost53ConstructorOverloadsInfoUnion<ConstructorType>;
-/**
- * Allows inferring any constructor using the `infer` keyword.
- */
-type InferConstructor<ConstructorType extends new (...args: any) => any> = ConstructorType;
-/**
- * A union type of the parameters allowed for any overload
- * of constructor {@linkcode ConstructorType}.
- */
-type ConstructorOverloadParameters<ConstructorType> = ConstructorOverloadsUnion<ConstructorType> extends InferConstructor<infer Ctor> ? ConstructorParameters<Ctor> : never;
-/**
- * Calculates the number of overloads for a given function type.
- */
-type NumOverloads<FunctionType> = UnionToTuple$1<OverloadsInfoUnion<FunctionType>>['length'];
-//#endregion
-//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/branding.d.ts
-/**
- * Represents a deeply branded type.
- *
- * Recursively walk a type and replace it with a branded type related to the
- * original. This is useful for equality-checking stricter than
- * `A extends B ? B extends A ? true : false : false`, because it detects the
- * difference between a few edge-case types that vanilla TypeScript
- * doesn't by default:
- * - `any` vs `unknown`
- * - `{ readonly a: string }` vs `{ a: string }`
- * - `{ a?: string }` vs `{ a: string | undefined }`
- *
- * __Note__: not very performant for complex types - this should only be used
- * when you know you need it. If doing an equality check, it's almost always
- * better to use {@linkcode StrictEqualUsingTSInternalIdenticalToOperator}.
- */
-type DeepBrand<T> = IsNever$2<T> extends true ? {
-  type: 'never';
-} : IsAny$2<T> extends true ? {
-  type: 'any';
-} : IsUnknown$1<T> extends true ? {
-  type: 'unknown';
-} : T extends string | number | boolean | symbol | bigint | null | undefined | void ? {
-  type: 'primitive';
-  value: T;
-} : T extends (new (...args: any[]) => any) ? {
-  type: 'constructor';
-  params: ConstructorOverloadParameters<T>;
-  instance: DeepBrand<InstanceType<Extract<T, new (...args: any) => any>>>;
-} : T extends ((...args: infer P) => infer R) ? NumOverloads<T> extends 1 ? {
-  type: 'function';
-  params: DeepBrand<P>;
-  return: DeepBrand<R>;
-  this: DeepBrand<ThisParameterType<T>>;
-  props: DeepBrand<Omit<T, keyof Function>>;
-} : UnionToTuple$1<OverloadsInfoUnion<T>> extends infer OverloadsTuple ? {
-  type: 'overloads';
-  overloads: { [K in keyof OverloadsTuple]: DeepBrand<OverloadsTuple[K]> };
-} : never : T extends any[] ? {
-  type: 'array';
-  items: { [K in keyof T]: T[K] };
-} : {
-  type: 'object';
-  properties: { [K in keyof T]: DeepBrand<T[K]> };
-  readonly: ReadonlyKeys<T>;
-  required: RequiredKeys<T>;
-  optional: OptionalKeys<T>;
-  constructorParams: DeepBrand<ConstructorOverloadParameters<T>>;
-};
-/**
- * Checks if two types are strictly equal using branding.
- */
-type StrictEqualUsingBranding<Left, Right> = MutuallyExtends<DeepBrand<Left>, DeepBrand<Right>>;
-//#endregion
-//#region ../../node_modules/.pnpm/expect-type@1.2.2/node_modules/expect-type/dist/messages.d.ts
-/**
- * Determines the printable type representation for a given type.
- */
-type PrintType<T> = IsUnknown$1<T> extends true ? 'unknown' : IsNever$2<T> extends true ? 'never' : IsAny$2<T> extends true ? never : boolean extends T ? 'boolean' : T extends boolean ? `literal boolean: ${T}` : string extends T ? 'string' : T extends string ? `literal string: ${T}` : number extends T ? 'number' : T extends number ? `literal number: ${T}` : bigint extends T ? 'bigint' : T extends bigint ? `literal bigint: ${T}` : T extends null ? 'null' : T extends undefined ? 'undefined' : T extends ((...args: any[]) => any) ? 'function' : '...';
-/**
- * Helper for showing end-user a hint why their type assertion is failing.
- * This swaps "leaf" types with a literal message about what the actual and
- * expected types are. Needs to check for `Not<IsAny<Actual>>` because
- * otherwise `LeafTypeOf<Actual>` returns `never`, which extends everything 🤔
- */
-type MismatchInfo<Actual, Expected> = And<[Extends<PrintType<Actual>, '...'>, Not<IsAny$2<Actual>>]> extends true ? And<[Extends<any[], Actual>, Extends<any[], Expected>]> extends true ? Array<MismatchInfo<Extract<Actual, any[]>[number], Extract<Expected, any[]>[number]>> : { [K in UsefulKeys<Actual> | UsefulKeys<Expected>]: MismatchInfo<K extends keyof Actual ? Actual[K] : never, K extends keyof Expected ? Expected[K] : never> } : StrictEqualUsingBranding<Actual, Expected> extends true ? Actual : `Expected: ${PrintType<Expected>}, Actual: ${PrintType<Exclude<Actual, Expected>>}`;
-/**
- * @internal
- */
-//#endregion
 //#region src/types/core/variants.types.d.ts
 
 type MaybeVariantStatus<TState extends Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = IsUnion<NonNullable<TState>> extends true ? Omit<RegleStatus<TState, TRules, TShortcuts>, '$fields' | keyof RegleStatus<TState, TRules, TShortcuts>['$fields']> & {
@@ -1722,9 +1308,9 @@ type ProcessChildrenFields<TState extends Record<string, any> | undefined, TRule
 type FindCorrespondingVariant<TState extends Record<string, any>, TRules extends any[]> = TRules extends [infer F, ...infer R] ? F extends ReglePartialRuleTree<TState> ? [F] : FindCorrespondingVariant<TState, R> : [];
 //#endregion
 //#region src/core/useRegle/useRegle.d.ts
-type useRegleFnOptions<TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends ReglePartialRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<AllRulesDeclarations>>, TAdditionalOptions extends Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> = TState extends MaybeInput<PrimitiveTypes> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState extends Record<string, any> ? Unwrap<TState> : {}>, TState extends Record<string, any> ? TRules : {}, TValidationGroups> & TAdditionalOptions;
+type useRegleFnOptions<TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends DeepExact<TRules, ReglePartialRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<AllRulesDeclarations>>>, TAdditionalOptions extends Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> = TState extends MaybeInput<PrimitiveTypes> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState extends Record<string, any> ? Unwrap<TState> : {}>, TState extends Record<string, any> ? (TRules extends Record<string, any> ? TRules : {}) : {}, TValidationGroups> & TAdditionalOptions;
 interface useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
-  <TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends ReglePartialRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TDecl extends RegleRuleDecl<NonNullable<TState>, Partial<AllRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = (isDeepExact<NoInferLegacy<TRules>, Unwrap<TState extends Record<string, any> ? TState : {}>> extends true ? {} : MismatchInfo<RegleRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<AllRulesDeclarations> & TCustomRules>, NoInferLegacy<TRules>>)>(...params: [state: Maybe<MaybeRef<TState> | DeepReactiveState<TState>>, rulesFactory: TState extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : TState extends Record<string, any> ? MaybeRef<TRules> | ((...args: any[]) => TRules) : {}, ...(HaveAnyRequiredProps<useRegleFnOptions<TState, TRules, TAdditionalOptions, TValidationGroups>> extends true ? [options: useRegleFnOptions<TState, TRules, TAdditionalOptions, TValidationGroups>] : [options?: useRegleFnOptions<TState, TRules, TAdditionalOptions, TValidationGroups>])]): NonNullable<TState> extends PrimitiveTypes ? RegleSingleField<NonNullable<TState>, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<TState extends Record<string, any> ? Unwrap<TState> : {}, TRules, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
+  <TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends DeepExact<TRules, ReglePartialRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<AllRulesDeclarations> & TCustomRules>>, TDecl extends RegleRuleDecl<NonNullable<TState>, Partial<AllRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>>(...params: [state: Maybe<MaybeRef<TState> | DeepReactiveState<TState>>, rulesFactory: TState extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : TState extends Record<string, any> ? MaybeRef<TRules> | ((...args: any[]) => TRules) : {}, ...(HaveAnyRequiredProps<useRegleFnOptions<TState, TRules, TAdditionalOptions, TValidationGroups>> extends true ? [options: useRegleFnOptions<TState, TRules, TAdditionalOptions, TValidationGroups>] : [options?: useRegleFnOptions<TState, TRules, TAdditionalOptions, TValidationGroups>])]): NonNullable<TState> extends PrimitiveTypes ? RegleSingleField<NonNullable<TState>, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<TState extends Record<string, any> ? Unwrap<TState> : {}, TRules extends Record<string, any> ? TRules : {}, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
   __config?: {
     rules?: () => CustomRulesDeclarationTree;
     modifiers?: RegleBehaviourOptions;
@@ -1751,6 +1337,21 @@ interface useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortc
  * Docs: {@link https://reglejs.dev/core-concepts/}
  */
 
+//#endregion
+//#region src/types/utils/mismatch.types.d.ts
+/**
+/**
+ * DeepExact<T, S> is a TypeScript utility type that recursively checks whether the structure of type S
+ * exactly matches the structure of type T, including all nested properties.
+ *
+ * Used in `useRegle` and `inferRules` to enforce that the rules object matches the expected shape exactly.
+ */
+type DeepExact<T, S> = NonNullable<S> extends MaybeRef<RegleRuleDecl> ? S : NonNullable<S> extends MaybeRef<RegleCollectionRuleDecl> ? S : [keyof T] extends [keyof ExtractFromGetter<S>] ? ExactObject<T, S> : { [K in keyof T as K extends keyof S ? never : K]: TypeError<`Unknown property: <${Coerce<K>}>`> };
+type ExactObject<T, S> = { [K in keyof S]: ExtendOnlyRealRecord<S[K]> extends true ? NonNullable<S[K]> extends MaybeRef<RegleRuleDecl> ? S[K] : K extends keyof T ? DeepExact<T[K], NonNullable<S[K]>> : S[K] : S[K] };
+type TypeError<Msg> = {
+  [' TypeError']: Msg;
+};
+type Coerce<T> = `${T & string}`;
 //#endregion
 //#region src/types/utils/object.types.d.ts
 type RemoveCommonKey<T extends readonly any[], K extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K>>, ...RemoveCommonKey<R, K>] : [];
@@ -1793,10 +1394,6 @@ type TupleToPlainObj<T> = { [I in keyof T & `${number}`]: T[I] };
 type HasNamedKeys<T> = IsUnion<T> extends true ? ProcessHasNamedKeys<LazyJoinDiscriminatedUnions<T>> : ProcessHasNamedKeys<T>;
 type ProcessHasNamedKeys<T> = { [K in keyof NonNullable<T>]: K extends string ? (string extends K ? never : K) : never }[keyof NonNullable<T>] extends never ? false : true;
 //#endregion
-//#region src/types/utils/mismatch.types.d.ts
-type isDeepExact<TRules, TTree> = { [K in keyof TRules]-?: CheckDeepExact<NonNullable<TRules[K]>, K extends keyof JoinDiscriminatedUnions<TTree> ? NonNullable<JoinDiscriminatedUnions<TTree>[K]> : never> }[keyof TRules] extends true ? true : false;
-type CheckDeepExact<TRules, TTree> = [TTree] extends [never] ? false : TRules extends RegleCollectionRuleDecl ? TTree extends Array<any> ? isDeepExact<NonNullable<TRules['$each']>, JoinDiscriminatedUnions<NonNullable<ArrayElement$1<TTree>>>> : TRules extends MaybeRef<RegleRuleDecl> ? true : TRules extends ReglePartialRuleTree<any> ? isDeepExact<UnwrapRef<TRules>, TTree> : false : TRules extends MaybeRef<RegleRuleDecl> ? true : TRules extends ReglePartialRuleTree<any> ? isDeepExact<UnwrapRef<TRules>, TTree> : false;
-//#endregion
 //#region src/types/utils/infer.types.d.ts
 
 //#endregion
@@ -2012,10 +1609,6 @@ type AllRulesDeclarations = CustomRulesDeclarationTree & DefaultValidatorsTree;
  * @public
  */
 type ReglePartialRuleTree<TForm extends Record<string, any> = Record<string, any>, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = { [TKey in keyof TForm]?: RegleFormPropertyType<TForm[TKey], TCustomRules> };
-/**
- * @public
- */
-type RegleRuleTree<TForm extends Record<string, any>, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = { [TKey in keyof TForm]: RegleFormPropertyType<TForm[TKey], TCustomRules> };
 /**
  * @public
  */

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@regle/schemas",
-  "version": "1.7.1",
+  "version": "1.8.0-beta.1",
   "description": "Schemas adapter for Regle",
   "dependencies": {
     "@standard-schema/spec": "1.0.0",
-    "@regle/core": "1.7.1",
-    "@regle/rules": "1.7.1"
+    "@regle/core": "1.8.0-beta.1",
+    "@regle/rules": "1.8.0-beta.1"
   },
   "peerDependencies": {
     "valibot": "^1.0.0",