@naturalcycles/nodejs-lib 15.54.0 → 15.56.0

package/dist/validation/ajv/ajvSchema.js

@@ -59,6 +59,12 @@ export class AjvSchema {
         else {
             jsonSchema = schema;
         }
+        // This is our own helper which marks a schema as optional
+        // in case it is going to be used in an object schema,
+        // where we need to mark the given property as not-required.
+        // But once all compilation is done, the presence of this field
+        // really upsets Ajv.
+        delete jsonSchema.optionalField;
         const ajvSchema = new AjvSchema(jsonSchema, cfg);
         AjvSchema.cacheAjvSchema(schema, ajvSchema);
         return ajvSchema;

package/dist/validation/ajv/getAjv.js

@@ -91,7 +91,7 @@ export function createAjv(opt) {
     });
     ajv.addKeyword({
         keyword: 'instanceof',
-        modifying: true,
+        modifying: false,
         schemaType: 'string',
         validate(instanceOf, data, _schema, _ctx) {
             if (typeof data !== 'object')
@@ -354,6 +354,23 @@ export function createAjv(opt) {
         keyword: 'hasIsOfTypeCheck',
         schemaType: 'boolean',
     });
+    ajv.addKeyword({
+        keyword: 'optionalValues',
+        type: ['string', 'number', 'boolean'],
+        modifying: true,
+        errors: false,
+        schemaType: 'array',
+        validate: function validate(optionalValues, data, _schema, ctx) {
+            if (!optionalValues)
+                return true;
+            if (!optionalValues.includes(data))
+                return true;
+            if (ctx?.parentData && ctx.parentDataProperty) {
+                ctx.parentData[ctx.parentDataProperty] = undefined;
+            }
+            return true;
+        },
+    });
     return ajv;
 }
 const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

package/dist/validation/ajv/jsonSchemaBuilder.d.ts

@@ -9,16 +9,16 @@ export declare const j: {
         infer: typeof objectInfer;
         any(): JsonSchemaObjectBuilder<AnyObject, AnyObject, false>;
         stringMap<S extends JsonSchemaTerminal<any, any, any>>(schema: S): JsonSchemaObjectBuilder<StringMap<SchemaIn<S>>, StringMap<SchemaOut<S>>>;
-        /**
-         * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
-         */
-        withEnumKeys<const T extends readonly (string | number)[] | StringEnum | NumberEnum, S extends JsonSchemaTerminal<any, any, any>, K extends string | number = EnumKeyUnion<T>>(keys: T, schema: S): JsonSchemaObjectBuilder<Record<K, SchemaIn<S>>, Record<K, SchemaOut<S>>>;
+        withEnumKeys: typeof withEnumKeys;
     };
     array<IN, OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>): JsonSchemaArrayBuilder<IN, OUT, Opt>;
     set<IN, OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>): JsonSchemaSet2Builder<IN, OUT, Opt>;
     buffer(): JsonSchemaBufferBuilder;
     enum<const T extends readonly (string | number | boolean | null)[] | StringEnum | NumberEnum>(input: T, opt?: JsonBuilderRuleOpt): JsonSchemaEnumBuilder<T extends readonly (infer U)[] ? U : T extends StringEnum ? T[keyof T] : T extends NumberEnum ? T[keyof T] : never>;
     oneOf<B extends readonly JsonSchemaAnyBuilder<any, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
+    and(): {
+        silentBob: () => never;
+    };
 };
 export declare class JsonSchemaTerminal<IN, OUT, Opt> {
     protected schema: JsonSchema;
@@ -73,8 +73,15 @@ export declare class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTermin
      */
     final(): JsonSchemaTerminal<IN, OUT, Opt>;
 }
-export declare class JsonSchemaStringBuilder<IN extends string = string, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+export declare class JsonSchemaStringBuilder<IN extends string | undefined = string, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
     constructor();
+    /**
+     * @param optionalValues List of values that should be considered/converted as `undefined`.
+     *
+     * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+     * due to how mutability works in Ajv.
+     */
+    optional(optionalValues?: string[]): JsonSchemaStringBuilder<IN | undefined, OUT | undefined, true>;
     regex(pattern: RegExp, opt?: JsonBuilderRuleOpt): this;
     pattern(pattern: string, opt?: JsonBuilderRuleOpt): this;
     minLength(minLength: number): this;
@@ -134,8 +141,15 @@ export interface JsonSchemaIsoDateOptions {
     after?: string;
     sameOrAfter?: string;
 }
-export declare class JsonSchemaNumberBuilder<IN extends number = number, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+export declare class JsonSchemaNumberBuilder<IN extends number | undefined = number, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
     constructor();
+    /**
+     * @param optionalValues List of values that should be considered/converted as `undefined`.
+     *
+     * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+     * due to how mutability works in Ajv.
+     */
+    optional(optionalValues?: number[]): JsonSchemaNumberBuilder<IN | undefined, OUT | undefined, true>;
     integer(): this;
     branded<B extends number>(): JsonSchemaNumberBuilder<B, B, Opt>;
     multipleOf(multipleOf: number): this;
@@ -160,8 +174,15 @@ export declare class JsonSchemaNumberBuilder<IN extends number = number, OUT = I
     utcOffset(): this;
     utcOffsetHour(): this;
 }
-export declare class JsonSchemaBooleanBuilder<IN extends boolean = boolean, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+export declare class JsonSchemaBooleanBuilder<IN extends boolean | undefined = boolean, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
     constructor();
+    /**
+     * @param optionalValue One of the two possible boolean values that should be considered/converted as `undefined`.
+     *
+     * This `optionalValue` feature only works when the current schema is nested in an object or array schema,
+     * due to how mutability works in Ajv.
+     */
+    optional(optionalValue?: boolean): JsonSchemaBooleanBuilder<IN | undefined, OUT | undefined, true>;
 }
 export declare class JsonSchemaObjectBuilder<IN extends AnyObject, OUT extends AnyObject, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
     constructor(props?: AnyObject, opt?: JsonSchemaObjectBuilderOpts);
@@ -276,6 +297,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
     maxItems?: number;
     uniqueItems?: boolean;
     enum?: any;
+    hasIsOfTypeCheck?: boolean;
     email?: JsonSchemaStringEmailOptions;
     Set2?: JsonSchema;
     Buffer?: true;
@@ -289,7 +311,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
         truncate?: number;
     };
     errorMessages?: StringMap<string>;
-    hasIsOfTypeCheck?: boolean;
+    optionalValues?: (string | number | boolean)[];
 }
 declare function object(props: AnyObject): never;
 declare function object<IN extends AnyObject>(props: {
@@ -312,6 +334,18 @@ declare function objectDbEntity<IN extends BaseDBEntity & AnyObject, EXTRA_KEYS
 } : {
     updated: BuilderFor<IN['updated']>;
 })): JsonSchemaObjectBuilder<IN, IN, false>;
+/**
+ * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
+ */
+declare function withEnumKeys<const T extends readonly (string | number)[] | StringEnum | NumberEnum, S extends JsonSchemaAnyBuilder<any, any, any>, K extends string | number = EnumKeyUnion<T>, Opt extends boolean = SchemaOpt<S>>(keys: T, schema: S): JsonSchemaObjectBuilder<Opt extends true ? {
+    [P in K]?: SchemaIn<S>;
+} : {
+    [P in K]: SchemaIn<S>;
+}, Opt extends true ? {
+    [P in K]?: SchemaOut<S>;
+} : {
+    [P in K]: SchemaOut<S>;
+}, false>;
 type Expand<T> = T extends infer O ? {
     [K in keyof O]: O[K];
 } : never;
@@ -340,4 +374,5 @@ interface JsonBuilderRuleOpt {
 type EnumKeyUnion<T> = T extends readonly (infer U)[] ? U : T extends StringEnum | NumberEnum ? T[keyof T] : never;
 type SchemaIn<S> = S extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
 type SchemaOut<S> = S extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never;
+type SchemaOpt<S> = S extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt : false;
 export {};

package/dist/validation/ajv/jsonSchemaBuilder.js

@@ -35,30 +35,7 @@ export const j = {
                 },
             });
         },
-        /**
-         * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
-         */
-        withEnumKeys(keys, schema) {
-            let enumValues;
-            if (Array.isArray(keys)) {
-                _assert(isEveryItemPrimitive(keys), 'Every item in the key list should be string, number or symbol');
-                enumValues = keys;
-            }
-            else if (typeof keys === 'object') {
-                const enumType = getEnumType(keys);
-                _assert(enumType === 'NumberEnum' || enumType === 'StringEnum', 'The key list should be StringEnum or NumberEnum');
-                if (enumType === 'NumberEnum') {
-                    enumValues = _numberEnumValues(keys);
-                }
-                else if (enumType === 'StringEnum') {
-                    enumValues = _stringEnumValues(keys);
-                }
-            }
-            _assert(enumValues, 'The key list should be an array of values, NumberEnum or a StringEnum');
-            const typedValues = enumValues;
-            const props = Object.fromEntries(typedValues.map(key => [key, schema]));
-            return new JsonSchemaObjectBuilder(props, { hasIsOfTypeCheck: false });
-        },
+        withEnumKeys,
     }),
     array(itemSchema) {
         return new JsonSchemaArrayBuilder(itemSchema);
@@ -101,6 +78,13 @@ export const j = {
             oneOf: schemas,
         });
     },
+    and() {
+        return {
+            silentBob: () => {
+                throw new Error('...strike back!');
+            },
+        };
+    },
 };
 const TS_2500 = 16725225600; // 2500-01-01
 const TS_2500_MILLIS = TS_2500 * 1000;
@@ -227,6 +211,16 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
             type: 'string',
         });
     }
+    /**
+     * @param optionalValues List of values that should be considered/converted as `undefined`.
+     *
+     * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+     * due to how mutability works in Ajv.
+     */
+    optional(optionalValues) {
+        _objectAssign(this.schema, { optionalValues });
+        return super.optional();
+    }
     regex(pattern, opt) {
         return this.pattern(pattern.source, opt);
     }
@@ -379,6 +373,16 @@ export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
             type: 'number',
         });
     }
+    /**
+     * @param optionalValues List of values that should be considered/converted as `undefined`.
+     *
+     * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+     * due to how mutability works in Ajv.
+     */
+    optional(optionalValues) {
+        _objectAssign(this.schema, { optionalValues });
+        return super.optional();
+    }
     integer() {
         _objectAssign(this.schema, { type: 'integer' });
         return this;
@@ -477,6 +481,18 @@ export class JsonSchemaBooleanBuilder extends JsonSchemaAnyBuilder {
             type: 'boolean',
         });
     }
+    /**
+     * @param optionalValue One of the two possible boolean values that should be considered/converted as `undefined`.
+     *
+     * This `optionalValue` feature only works when the current schema is nested in an object or array schema,
+     * due to how mutability works in Ajv.
+     */
+    optional(optionalValue) {
+        if (typeof optionalValue !== 'undefined') {
+            _objectAssign(this.schema, { optionalValues: [optionalValue] });
+        }
+        return super.optional();
+    }
 }
 export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
     constructor(props, opt) {
@@ -678,3 +694,27 @@ function objectDbEntity(props) {
         ...props,
     });
 }
+/**
+ * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
+ */
+function withEnumKeys(keys, schema) {
+    let enumValues;
+    if (Array.isArray(keys)) {
+        _assert(isEveryItemPrimitive(keys), 'Every item in the key list should be string, number or symbol');
+        enumValues = keys;
+    }
+    else if (typeof keys === 'object') {
+        const enumType = getEnumType(keys);
+        _assert(enumType === 'NumberEnum' || enumType === 'StringEnum', 'The key list should be StringEnum or NumberEnum');
+        if (enumType === 'NumberEnum') {
+            enumValues = _numberEnumValues(keys);
+        }
+        else if (enumType === 'StringEnum') {
+            enumValues = _stringEnumValues(keys);
+        }
+    }
+    _assert(enumValues, 'The key list should be an array of values, NumberEnum or a StringEnum');
+    const typedValues = enumValues;
+    const props = Object.fromEntries(typedValues.map(key => [key, schema]));
+    return new JsonSchemaObjectBuilder(props, { hasIsOfTypeCheck: false });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.54.0",
+  "version": "15.56.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",

package/src/validation/ajv/ajvSchema.ts

@@ -79,6 +79,13 @@ export class AjvSchema<IN = unknown, OUT = IN> {
       jsonSchema = schema
     }
 
+    // This is our own helper which marks a schema as optional
+    // in case it is going to be used in an object schema,
+    // where we need to mark the given property as not-required.
+    // But once all compilation is done, the presence of this field
+    // really upsets Ajv.
+    delete jsonSchema.optionalField
+
     const ajvSchema = new AjvSchema<IN, OUT>(jsonSchema, cfg)
     AjvSchema.cacheAjvSchema(schema, ajvSchema)
 

package/src/validation/ajv/getAjv.ts

@@ -109,7 +109,7 @@ export function createAjv(opt?: Options): Ajv {
 
   ajv.addKeyword({
     keyword: 'instanceof',
-    modifying: true,
+    modifying: false,
     schemaType: 'string',
     validate(instanceOf: string, data: unknown, _schema, _ctx) {
       if (typeof data !== 'object') return false
@@ -396,6 +396,30 @@ export function createAjv(opt?: Options): Ajv {
     schemaType: 'boolean',
   })
 
+  ajv.addKeyword({
+    keyword: 'optionalValues',
+    type: ['string', 'number', 'boolean'],
+    modifying: true,
+    errors: false,
+    schemaType: 'array',
+    validate: function validate(
+      optionalValues: (string | number | boolean)[],
+      data: string | number | boolean,
+      _schema,
+      ctx,
+    ) {
+      if (!optionalValues) return true
+
+      if (!optionalValues.includes(data)) return true
+
+      if (ctx?.parentData && ctx.parentDataProperty) {
+        ctx.parentData[ctx.parentDataProperty] = undefined
+      }
+
+      return true
+    },
+  })
+
   return ajv
 }
 

package/src/validation/ajv/jsonSchemaBuilder.ts

@@ -87,47 +87,7 @@ export const j = {
       )
     },
 
-    /**
-     * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
-     */
-    withEnumKeys<
-      const T extends readonly (string | number)[] | StringEnum | NumberEnum,
-      S extends JsonSchemaTerminal<any, any, any>,
-      K extends string | number = EnumKeyUnion<T>,
-    >(
-      keys: T,
-      schema: S,
-    ): JsonSchemaObjectBuilder<Record<K, SchemaIn<S>>, Record<K, SchemaOut<S>>> {
-      let enumValues: readonly (string | number)[] | undefined
-      if (Array.isArray(keys)) {
-        _assert(
-          isEveryItemPrimitive(keys),
-          'Every item in the key list should be string, number or symbol',
-        )
-        enumValues = keys
-      } else if (typeof keys === 'object') {
-        const enumType = getEnumType(keys)
-        _assert(
-          enumType === 'NumberEnum' || enumType === 'StringEnum',
-          'The key list should be StringEnum or NumberEnum',
-        )
-        if (enumType === 'NumberEnum') {
-          enumValues = _numberEnumValues(keys as NumberEnum)
-        } else if (enumType === 'StringEnum') {
-          enumValues = _stringEnumValues(keys as StringEnum)
-        }
-      }
-
-      _assert(enumValues, 'The key list should be an array of values, NumberEnum or a StringEnum')
-
-      const typedValues = enumValues as readonly K[]
-      const props = Object.fromEntries(typedValues.map(key => [key, schema])) as any
-
-      return new JsonSchemaObjectBuilder<Record<K, SchemaIn<S>>, Record<K, SchemaOut<S>>, false>(
-        props,
-        { hasIsOfTypeCheck: false },
-      )
-    },
+    withEnumKeys,
   }),
 
   array<IN, OUT, Opt>(
@@ -193,6 +153,14 @@ export const j = {
       oneOf: schemas,
     })
   },
+
+  and() {
+    return {
+      silentBob: () => {
+        throw new Error('...strike back!')
+      },
+    }
+  },
 }
 
 const TS_2500 = 16725225600 // 2500-01-01
@@ -338,7 +306,7 @@ export class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTerminal<IN, O
 }
 
 export class JsonSchemaStringBuilder<
-  IN extends string = string,
+  IN extends string | undefined = string,
   OUT = IN,
   Opt extends boolean = false,
 > extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
@@ -348,6 +316,23 @@ export class JsonSchemaStringBuilder<
     })
   }
 
+  /**
+   * @param optionalValues List of values that should be considered/converted as `undefined`.
+   *
+   * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+   * due to how mutability works in Ajv.
+   */
+  override optional(
+    optionalValues?: string[],
+  ): JsonSchemaStringBuilder<IN | undefined, OUT | undefined, true> {
+    _objectAssign(this.schema, { optionalValues })
+    return super.optional() as unknown as JsonSchemaStringBuilder<
+      IN | undefined,
+      OUT | undefined,
+      true
+    >
+  }
+
   regex(pattern: RegExp, opt?: JsonBuilderRuleOpt): this {
     return this.pattern(pattern.source, opt)
   }
@@ -540,7 +525,7 @@ export interface JsonSchemaIsoDateOptions {
 }
 
 export class JsonSchemaNumberBuilder<
-  IN extends number = number,
+  IN extends number | undefined = number,
   OUT = IN,
   Opt extends boolean = false,
 > extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
@@ -550,6 +535,23 @@ export class JsonSchemaNumberBuilder<
     })
   }
 
+  /**
+   * @param optionalValues List of values that should be considered/converted as `undefined`.
+   *
+   * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+   * due to how mutability works in Ajv.
+   */
+  override optional(
+    optionalValues?: number[],
+  ): JsonSchemaNumberBuilder<IN | undefined, OUT | undefined, true> {
+    _objectAssign(this.schema, { optionalValues })
+    return super.optional() as unknown as JsonSchemaNumberBuilder<
+      IN | undefined,
+      OUT | undefined,
+      true
+    >
+  }
+
   integer(): this {
     _objectAssign(this.schema, { type: 'integer' })
     return this
@@ -670,7 +672,7 @@ export class JsonSchemaNumberBuilder<
 }
 
 export class JsonSchemaBooleanBuilder<
-  IN extends boolean = boolean,
+  IN extends boolean | undefined = boolean,
   OUT = IN,
   Opt extends boolean = false,
 > extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
@@ -679,6 +681,26 @@ export class JsonSchemaBooleanBuilder<
       type: 'boolean',
     })
   }
+
+  /**
+   * @param optionalValue One of the two possible boolean values that should be considered/converted as `undefined`.
+   *
+   * This `optionalValue` feature only works when the current schema is nested in an object or array schema,
+   * due to how mutability works in Ajv.
+   */
+  override optional(
+    optionalValue?: boolean,
+  ): JsonSchemaBooleanBuilder<IN | undefined, OUT | undefined, true> {
+    if (typeof optionalValue !== 'undefined') {
+      _objectAssign(this.schema, { optionalValues: [optionalValue] })
+    }
+
+    return super.optional() as unknown as JsonSchemaBooleanBuilder<
+      IN | undefined,
+      OUT | undefined,
+      true
+    >
+  }
 }
 
 export class JsonSchemaObjectBuilder<
@@ -1036,6 +1058,8 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
 
   enum?: any
 
+  hasIsOfTypeCheck?: boolean
+
   // Below we add custom Ajv keywords
 
   email?: JsonSchemaStringEmailOptions
@@ -1046,7 +1070,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
   instanceof?: string | string[]
   transform?: { trim?: true; toLowerCase?: true; toUpperCase?: true; truncate?: number }
   errorMessages?: StringMap<string>
-  hasIsOfTypeCheck?: boolean
+  optionalValues?: (string | number | boolean)[]
 }
 
 function object(props: AnyObject): never
@@ -1096,6 +1120,54 @@ function objectDbEntity(props: AnyObject): any {
   })
 }
 
+/**
+ * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
+ */
+function withEnumKeys<
+  const T extends readonly (string | number)[] | StringEnum | NumberEnum,
+  S extends JsonSchemaAnyBuilder<any, any, any>,
+  K extends string | number = EnumKeyUnion<T>,
+  Opt extends boolean = SchemaOpt<S>,
+>(
+  keys: T,
+  schema: S,
+): JsonSchemaObjectBuilder<
+  Opt extends true ? { [P in K]?: SchemaIn<S> } : { [P in K]: SchemaIn<S> },
+  Opt extends true ? { [P in K]?: SchemaOut<S> } : { [P in K]: SchemaOut<S> },
+  false
+> {
+  let enumValues: readonly (string | number)[] | undefined
+  if (Array.isArray(keys)) {
+    _assert(
+      isEveryItemPrimitive(keys),
+      'Every item in the key list should be string, number or symbol',
+    )
+    enumValues = keys
+  } else if (typeof keys === 'object') {
+    const enumType = getEnumType(keys)
+    _assert(
+      enumType === 'NumberEnum' || enumType === 'StringEnum',
+      'The key list should be StringEnum or NumberEnum',
+    )
+    if (enumType === 'NumberEnum') {
+      enumValues = _numberEnumValues(keys as NumberEnum)
+    } else if (enumType === 'StringEnum') {
+      enumValues = _stringEnumValues(keys as StringEnum)
+    }
+  }
+
+  _assert(enumValues, 'The key list should be an array of values, NumberEnum or a StringEnum')
+
+  const typedValues = enumValues as readonly K[]
+  const props = Object.fromEntries(typedValues.map(key => [key, schema])) as any
+
+  return new JsonSchemaObjectBuilder<
+    Opt extends true ? { [P in K]?: SchemaIn<S> } : { [P in K]: SchemaIn<S> },
+    Opt extends true ? { [P in K]?: SchemaOut<S> } : { [P in K]: SchemaOut<S> },
+    false
+  >(props, { hasIsOfTypeCheck: false })
+}
+
 type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
 
 type ExactMatch<A, B> =
@@ -1137,3 +1209,4 @@ type EnumKeyUnion<T> =
 
 type SchemaIn<S> = S extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never
 type SchemaOut<S> = S extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never
+type SchemaOpt<S> = S extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt : false