zodselect 1.3.0 → 1.3.1

package/dist/refine-schema.d.ts

@@ -6,6 +6,8 @@ type DepthLimit = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type Exact<TShape, T> = {
     [K in keyof TShape]: K extends FieldKeys<T> ? TShape[K] extends ((schema: never) => unknown) | boolean | ZodType ? TShape[K] : TShape[K] extends object ? Exact<TShape[K], FieldObjects<FieldAt<T, K>>> : TShape[K] : never;
 };
+/** What {@link refineSchema} takes for `T`: `TShape`, with a key `T` doesn't have, at any depth, a type error even beside valid keys. */
+export type ExactRefineSchema<T extends ZodType<object> | ZodUnion, TShape> = TShape & Exact<TShape, z.infer<T>>;
 /** What the field `TKey` holds in any object of `T`. */
 type FieldAt<T, TKey> = T extends unknown ? TKey extends keyof T ? T[TKey] : never : never;
 /** The declared keys of every object in `T`, each of a union's own. */
@@ -32,6 +34,8 @@ export type RefinedUnionSchema<T extends ZodUnion, TShape> = ZodUnion<T['options
         [K in keyof Rest]: Rest[K] extends ZodType ? z.infer<Rest[K]> extends object ? RefinedTypeSchema<z.infer<Rest[K]>, TShape> : Extract<Rest[K], ZodType> : Extract<Rest[K], ZodType>;
     }
 ] : never : never>;
+/** The value of the fields of `T` that `TShape` picks: the output of {@link RefinedTypeSchema}. */
+export type RefinedValue<T extends object, TShape> = z.output<RefinedTypeSchema<T, TShape>>;
 /** One refined schema per variant of a union of objects (a plain object is its own one variant), so the result narrows by variant. */
 type RefinedVariants<T, TShape, TDepth extends number> = T extends object ? RefinedTypeSchema<T, TShape, TDepth> : never;
 type Refinement<T extends ZodType, TIsSimple extends boolean> = TIsSimple extends true ? boolean : ((schema: T) => ZodType) | boolean | ZodType;
@@ -56,7 +60,7 @@ type ZodifyLiteral<T, TElse> = [
     T
 ] extends [boolean | number | string] ? [T] extends [boolean] ? boolean extends T ? ZodBoolean : ZodLiteral<T> : string extends T ? [T] extends [string] ? ZodString : TElse : number extends T ? [T] extends [number] ? ZodNumber : TElse : ZodLiteral<T> : TElse;
 /** `shape`'s fields of `schema`. A key the schema doesn't have, at any depth, is a type error. */
-export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: TShape & Exact<TShape, z.infer<T>>): RefinedSchema<T, TShape, false>;
+export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: ExactRefineSchema<T, TShape>): RefinedSchema<T, TShape, false>;
 /**
  * {@link refineSchema} for a shape whose type is still generic, which the exact key check can't evaluate.
  * Prefer {@link refineSchema}: a key the schema doesn't have is skipped here, not refused.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Type-safe selection utility built on top of Zod. Allows for strongly typed field selection, schema merging, and runtime refinement for frontend or backend use.",
   "author": "SecureDataSystems",
   "license": "MIT",