@tstdl/base 0.91.51 → 0.92.0

package/schema/converters/openapi-converter.js

@@ -0,0 +1,113 @@
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { fromEntries, objectEntries } from '../../utils/object/object.js';
+import { isDefined, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
+import { ArraySchema } from '../schemas/array.js';
+import { BooleanSchema } from '../schemas/boolean.js';
+import { DateSchema } from '../schemas/date.js';
+import { EnumerationSchema } from '../schemas/enumeration.js';
+import { LiteralSchema } from '../schemas/literal.js';
+import { nullable, NullableSchema } from '../schemas/nullable.js';
+import { NumberSchema } from '../schemas/number.js';
+import { ObjectSchema } from '../schemas/object.js';
+import { OptionalSchema } from '../schemas/optional.js';
+import { StringSchema } from '../schemas/string.js';
+import { UnionSchema } from '../schemas/union.js';
+import { schemaTestableToSchema } from '../testable.js';
+export function convertToOpenApiSchema(testable) {
+    const schema = schemaTestableToSchema(testable);
+    return {
+        ...convertToOpenApiSchemaBase(schema),
+        ...(isNotNull(schema.description) ? { description: schema.description } : undefined),
+        ...(isDefined(schema.example) ? { example: schema.example } : undefined)
+    };
+}
+function convertToOpenApiSchemaBase(schema) {
+    if (schema instanceof ObjectSchema) {
+        const entries = objectEntries(schema.properties);
+        const convertedEntries = entries.map(([property, propertySchema]) => [property, convertToOpenApiSchema(stripOptional(propertySchema))]);
+        return {
+            type: 'object',
+            properties: fromEntries(convertedEntries),
+            required: entries
+                .filter(([, propertySchema]) => !(propertySchema instanceof OptionalSchema) && !((propertySchema instanceof NullableSchema) && (propertySchema.schema instanceof OptionalSchema)))
+                .map(([property]) => property)
+        };
+    }
+    if (schema instanceof StringSchema) {
+        return {
+            type: 'string'
+        };
+    }
+    if (schema instanceof DateSchema) {
+        return {
+            type: 'string',
+            format: 'date-time'
+        };
+    }
+    if (schema instanceof NumberSchema) {
+        return {
+            type: schema.integer ? 'integer' : 'number',
+            ...(isNumber(schema.minimum) ? { minimum: schema.minimum } : undefined),
+            ...(isNumber(schema.maximum) ? { maximum: schema.maximum } : undefined)
+        };
+    }
+    if (schema instanceof BooleanSchema) {
+        return {
+            type: 'boolean'
+        };
+    }
+    if (schema instanceof LiteralSchema) {
+        return {
+            type: typeof schema.value,
+            enum: [schema.value]
+        };
+    }
+    if (schema instanceof ArraySchema) {
+        return {
+            type: 'array',
+            items: convertToOpenApiSchema(schema.itemSchema),
+            ...(isNumber(schema.minimum) ? { minItems: schema.minimum } : undefined),
+            ...(isNumber(schema.maximum) ? { maxItems: schema.maximum } : undefined)
+        };
+    }
+    if (schema instanceof EnumerationSchema) {
+        const hasString = schema.allowedValues.some(isString);
+        const hasNumber = schema.allowedValues.some(isNumber);
+        if (hasString && hasNumber) {
+            throw new NotSupportedError('Enum must be either string or number but not both.');
+        }
+        return {
+            type: hasString ? 'string' : 'number',
+            enum: schema.allowedValues
+        };
+    }
+    if (schema instanceof NullableSchema) {
+        if (schema.schema instanceof EnumerationSchema) {
+            const enumSchema = convertToOpenApiSchema(schema.schema);
+            return {
+                ...enumSchema,
+                enum: [...enumSchema.enum, null],
+                nullable: true
+            };
+        }
+        return {
+            ...convertToOpenApiSchema(schema.schema),
+            nullable: true
+        };
+    }
+    if (schema instanceof UnionSchema) {
+        return {
+            oneOf: schema.schemas.map((innerSchema) => convertToOpenApiSchema(innerSchema))
+        };
+    }
+    throw new NotSupportedError(`Schema "${schema.name}" not supported.`);
+}
+function stripOptional(schema) {
+    if ((schema instanceof OptionalSchema)) {
+        return schema.schema;
+    }
+    if ((schema instanceof NullableSchema) && (schema.schema instanceof OptionalSchema)) {
+        return nullable(schema.schema.schema);
+    }
+    return schema;
+}

package/schema/decorators/description.d.ts

@@ -0,0 +1,3 @@
+import { type Decorator } from '../../reflection/index.js';
+import type { SchemaTypeReflectionData } from './types.js';
+export declare function Description(options?: SchemaTypeReflectionData): Decorator<'class' | 'property'>;

package/schema/decorators/description.js

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createDecorator } from '../../reflection/index.js';
+export function Description(options = {}) {
+    return createDecorator({
+        class: true,
+        property: true,
+        data: { schema: options },
+        mergeData: true
+    });
+}

package/schema/decorators/property.d.ts

@@ -2,9 +2,11 @@ import type { SetRequired } from 'type-fest';
 import type { Decorator } from '../../reflection/index.js';
 import type { TypedOmit } from '../../types.js';
 import type { SchemaTestable } from '../schema.js';
-import type { SchemaPropertyReflectionData } from './types.js';
+import type { SchemaPropertyReflectionData, SchemaTestableProvider } from './types.js';
 export type SchemaPropertyDecoratorOptions = SchemaPropertyReflectionData;
 export type SchemaPropertyDecoratorOptionsWithRequiredSchema = SetRequired<SchemaPropertyReflectionData, 'schema'>;
 export type SchemaPropertyDecoratorOptionsWithoutSchema = TypedOmit<SchemaPropertyReflectionData, 'schema'>;
 export declare function Property(schema: SchemaTestable, options?: SchemaPropertyDecoratorOptionsWithoutSchema): Decorator<'property' | 'accessor'>;
 export declare function Property(options: SchemaPropertyDecoratorOptionsWithRequiredSchema): Decorator<'property' | 'accessor'>;
+export declare function PropertySchema(schemaProvider: SchemaTestableProvider, options?: SchemaPropertyDecoratorOptionsWithoutSchema): Decorator<'property' | 'accessor'>;
+export declare function PropertySchema(options: SchemaPropertyDecoratorOptionsWithRequiredSchema): Decorator<'property' | 'accessor'>;

package/schema/decorators/property.js

@@ -1,13 +1,21 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { isDefined } from '../../utils/type-guards.js';
-import { isSchemaTestable } from '../testable.js';
+import { isDefined, isFunction } from '../../utils/type-guards.js';
 import { createSchemaPropertyDecorator } from './utils.js';
 export function Property(schemaOrOptions, optionsOrNothing) {
     if (isDefined(optionsOrNothing)) {
-        return createSchemaPropertyDecorator({ ...optionsOrNothing, schema: schemaOrOptions });
+        return createSchemaPropertyDecorator({ ...optionsOrNothing, schema: () => schemaOrOptions });
     }
-    if (isSchemaTestable(schemaOrOptions)) {
-        return createSchemaPropertyDecorator({ schema: schemaOrOptions });
+    if (isFunction(schemaOrOptions)) {
+        return createSchemaPropertyDecorator({ schema: () => schemaOrOptions });
     }
     return createSchemaPropertyDecorator(schemaOrOptions);
 }
+export function PropertySchema(schemaProviderOrOptions, optionsOrNothing) {
+    if (isDefined(optionsOrNothing)) {
+        return createSchemaPropertyDecorator({ ...optionsOrNothing, schema: schemaProviderOrOptions });
+    }
+    if (isFunction(schemaProviderOrOptions)) {
+        return createSchemaPropertyDecorator({ schema: schemaProviderOrOptions });
+    }
+    return createSchemaPropertyDecorator(schemaProviderOrOptions);
+}

package/schema/decorators/types.d.ts

@@ -1,16 +1,16 @@
 import type { Decorator } from '../../reflection/types.js';
-import type { SchemaTestable } from '../schema.js';
+import type { SchemaOptions, SchemaTestable } from '../schema.js';
 import type { ObjectSchemaFactory, ObjectSchemaOptions } from '../schemas/object.js';
 export type SchemaClassDecorator = Decorator<'class'>;
 export type SchemaPropertyDecorator = Decorator<'property' | 'accessor'>;
-export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey'>> & {
+export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey' | 'description' | 'example'>> & {
     schema?: SchemaTestable;
     factory?: ObjectSchemaFactory<any>;
 };
-export type SchemaPropertyReflectionData = {
-    schema?: SchemaTestable;
+export type SchemaTestableProvider = (data: SchemaPropertyReflectionData) => SchemaTestable;
+export type SchemaPropertyReflectionData = Partial<Pick<SchemaOptions<any>, 'description' | 'example'>> & {
+    schema?: SchemaTestableProvider;
     array?: boolean;
     optional?: boolean;
     nullable?: boolean;
-    data?: Record<PropertyKey, any>;
 };

package/schema/schema.d.ts

@@ -22,9 +22,16 @@ type NormalizePrimitiveToConstructor<T> = Or<IsEqual<T, string>, IsEqual<T, Stri
 export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
 export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
 export declare const OPTIONAL: unique symbol;
+export type SchemaOptions<T> = {
+    description?: string | null;
+    example?: T | undefined;
+};
 export declare abstract class Schema<T = unknown> {
     readonly [OPTIONAL]: boolean;
+    readonly description: string | null;
+    readonly example: T | undefined;
     abstract readonly name: string;
+    constructor(options?: SchemaOptions<T>);
     /**
      * Test an unknown value to see whether it corresponds to the schema.
      * @param schema schema to test against

package/schema/schema.js

@@ -1,5 +1,11 @@
 import { JsonPath } from '../json-path/json-path.js';
 export class Schema {
+    description;
+    example;
+    constructor(options) {
+        this.description = options?.description ?? null;
+        this.example = options?.example;
+    }
     /**
      * Test an unknown value to see whether it corresponds to the schema.
      * @param schema schema to test against

package/schema/schemas/any.d.ts

@@ -1,8 +1,9 @@
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
-import { Schema, type SchemaTestResult } from '../schema.js';
+import { Schema, type SchemaOptions, type SchemaTestResult } from '../schema.js';
+export type AnySchemaOptions = SchemaOptions<any>;
 export declare class AnySchema extends Schema<any> {
     readonly name = "any";
     _test(value: any): SchemaTestResult<any>;
 }
-export declare function any(): AnySchema;
-export declare function Any(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function any(options?: AnySchemaOptions): AnySchema;
+export declare function Any(options?: AnySchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/any.js

@@ -1,4 +1,4 @@
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 export class AnySchema extends Schema {
     name = 'any';
@@ -6,9 +6,9 @@ export class AnySchema extends Schema {
         return { valid: true, value };
     }
 }
-export function any() {
-    return new AnySchema();
+export function any(options) {
+    return new AnySchema(options);
 }
 export function Any(options) {
-    return Property(any(), options);
+    return PropertySchema((data) => any({ description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/array.d.ts

@@ -1,15 +1,20 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { TypedOmit } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 import type { Coercible } from '../types.js';
-export type ArraySchemaOptions = Coercible;
+export type ArraySchemaOptions<T> = SchemaOptions<T[]> & Coercible & {
+    minimum?: number;
+    maximum?: number;
+};
 export declare class ArraySchema<T> extends Schema<T[]> {
     #private;
     readonly name: string;
     readonly itemSchema: Schema<T>;
-    constructor(itemSchema: SchemaTestable<T>, options?: ArraySchemaOptions);
+    readonly minimum: number | null;
+    readonly maximum: number | null;
+    constructor(itemSchema: SchemaTestable<T>, options?: ArraySchemaOptions<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;
 }
-export declare function array<T>(schema: SchemaTestable<T>, options?: ArraySchemaOptions): ArraySchema<T>;
-export declare function Array(schema: SchemaTestable, options?: ArraySchemaOptions & TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;
+export declare function array<T>(schema: SchemaTestable<T>, options?: ArraySchemaOptions<T>): ArraySchema<T>;
+export declare function Array(schema: SchemaTestable, options?: ArraySchemaOptions<unknown> & TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/schema/schemas/array.js

@@ -2,17 +2,21 @@ import { SchemaError } from '../../schema/schema.error.js';
 import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isArray } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class ArraySchema extends Schema {
     #options;
     name;
     itemSchema;
+    minimum;
+    maximum;
     constructor(itemSchema, options = {}) {
-        super();
+        super(options);
         this.#options = options;
         this.itemSchema = schemaTestableToSchema(itemSchema);
+        this.minimum = options.minimum ?? null;
+        this.maximum = options.maximum ?? null;
         lazyProperty(this, 'name', () => `Array[${this.itemSchema.name}]`);
     }
     _test(value, path, options) {
@@ -37,5 +41,5 @@ export function array(schema, options) {
     return new ArraySchema(schema, options);
 }
 export function Array(schema, options) {
-    return Property(array(schema, options), options);
+    return PropertySchema((data) => array(schema, { description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/bigint.d.ts

@@ -1,10 +1,10 @@
-import type { JsonPath } from '../../json-path/json-path.js';
 import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import type { SchemaPropertyDecorator } from '../decorators/types.js';
-import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-export declare class BigIntSchema extends Schema<bigint> {
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type BigIntSchemaOptions = SimpleSchemaOptions<bigint>;
+export declare class BigIntSchema extends SimpleSchema<bigint> {
     readonly name = "bigint";
-    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<bigint>;
+    constructor(options?: BigIntSchemaOptions);
 }
-export declare function bigint(): BigIntSchema;
-export declare function BigIntProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function bigint(options?: BigIntSchemaOptions): BigIntSchema;
+export declare function BigIntProperty(options?: BigIntSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/bigint.js

@@ -1,20 +1,37 @@
-import { SchemaError } from '../../schema/schema.error.js';
 import { isBigInt } from '../../utils/type-guards.js';
-import { typeOf } from '../../utils/type-of.js';
-import { Property } from '../decorators/index.js';
-import { Schema } from '../schema.js';
-export class BigIntSchema extends Schema {
+import { PropertySchema } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SimpleSchema } from './simple.js';
+export class BigIntSchema extends SimpleSchema {
     name = 'bigint';
-    _test(value, path, options) {
-        if (isBigInt(value)) {
-            return { valid: true, value };
-        }
-        return { valid: false, error: SchemaError.expectedButGot('bigint', typeOf(value), path, { fast: options.fastErrors }) };
+    constructor(options) {
+        super('bigint', isBigInt, options, {
+            coercers: {
+                number(value, path, coerceOptions) {
+                    try {
+                        const bigIntValue = BigInt(value);
+                        return { success: true, value: bigIntValue, valid: true };
+                    }
+                    catch (error) {
+                        return { success: false, error: SchemaError.couldNotCoerce('bigint', 'number', path, { fast: coerceOptions.fastErrors, customMessage: error.message }) };
+                    }
+                },
+                string(value, path, coerceOptions) {
+                    try {
+                        const bigIntValue = BigInt(value);
+                        return { success: true, value: bigIntValue, valid: true };
+                    }
+                    catch (error) {
+                        return { success: false, error: SchemaError.couldNotCoerce('bigint', 'string', path, { fast: coerceOptions.fastErrors, customMessage: error.message }) };
+                    }
+                }
+            }
+        });
     }
 }
-export function bigint() {
-    return new BigIntSchema();
+export function bigint(options) {
+    return new BigIntSchema(options);
 }
 export function BigIntProperty(options) {
-    return Property(bigint(), options);
+    return PropertySchema((data) => bigint({ description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/boolean.d.ts

@@ -1,6 +1,6 @@
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-export type BooleanSchemaOptions = SimpleSchemaOptions;
+export type BooleanSchemaOptions = SimpleSchemaOptions<boolean>;
 export declare class BooleanSchema extends SimpleSchema<boolean> {
     readonly name = "boolean";
     constructor(options?: BooleanSchemaOptions);

package/schema/schemas/boolean.js

@@ -1,5 +1,5 @@
 import { isBoolean, isString } from '../../utils/type-guards.js';
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class BooleanSchema extends SimpleSchema {
     name = 'boolean';
@@ -33,5 +33,5 @@ export function boolean(options) {
     return new BooleanSchema(options);
 }
 export function BooleanProperty(options) {
-    return Property(boolean(options), options);
+    return PropertySchema((data) => boolean({ description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/date.d.ts

@@ -1,6 +1,6 @@
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-export type DateSchemaOptions = SimpleSchemaOptions & {
+export type DateSchemaOptions = SimpleSchemaOptions<globalThis.Date> & {
     integer?: boolean;
 };
 export declare class DateSchema extends SimpleSchema<globalThis.Date> {

package/schema/schemas/date.js

@@ -1,5 +1,5 @@
 import { isValidDate } from '../../utils/type-guards.js';
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class DateSchema extends SimpleSchema {
@@ -25,5 +25,5 @@ export function date(options) {
     return new DateSchema(options);
 }
 export function DateProperty(options) {
-    return Property(date(options), options);
+    return PropertySchema((data) => date({ description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/defaulted.d.ts

@@ -1,12 +1,13 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type DefaultSchemaOptions<T, D> = SchemaOptions<T | D>;
 export declare class DefaultSchema<T, D> extends Schema<T | D> {
     readonly name: string;
     readonly schema: Schema<T>;
     readonly defaultValue: D;
-    constructor(schema: SchemaTestable<T>, defaultValue: D);
+    constructor(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | D>;
 }
-export declare function defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D): DefaultSchema<T, D>;
-export declare function Defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D>): DefaultSchema<T, D>;
+export declare function Defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/defaulted.js

@@ -1,14 +1,14 @@
 import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isNullOrUndefined } from '../../utils/type-guards.js';
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class DefaultSchema extends Schema {
     name;
     schema;
     defaultValue;
-    constructor(schema, defaultValue) {
-        super();
+    constructor(schema, defaultValue, options) {
+        super(options);
         this.schema = schemaTestableToSchema(schema);
         this.defaultValue = defaultValue;
         lazyProperty(this, 'name', () => `Defaulted[${this.schema.name}]`);
@@ -20,9 +20,9 @@ export class DefaultSchema extends Schema {
         return this.schema._test(value, path, options);
     }
 }
-export function defaulted(schema, defaultValue) {
-    return new DefaultSchema(schema, defaultValue);
+export function defaulted(schema, defaultValue, options) {
+    return new DefaultSchema(schema, defaultValue, options);
 }
 export function Defaulted(schema, defaultValue, options) {
-    return Property(defaulted(schema, defaultValue), options);
+    return PropertySchema((data) => defaulted(schema, defaultValue, { description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/deferred.d.ts

@@ -9,4 +9,4 @@ export declare class DeferredSchema<T extends SchemaTestable> extends Schema<Sch
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<SchemaOutput<T>>;
 }
 export declare function deferred<T extends SchemaTestable>(schema: () => T): DeferredSchema<T>;
-export declare function Deferred<T extends SchemaTestable>(schema: () => T, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Deferred(schema: () => SchemaTestable, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/deferred.js

@@ -1,5 +1,5 @@
 import { lazyProperty } from '../../utils/object/lazy-property.js';
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class DeferredSchema extends Schema {
@@ -19,5 +19,5 @@ export function deferred(schema) {
     return new DeferredSchema(schema);
 }
 export function Deferred(schema, options) {
-    return Property(deferred(schema), options);
+    return PropertySchema(() => deferred(schema), options);
 }

package/schema/schemas/enumeration.d.ts

@@ -1,12 +1,13 @@
 import type { Enumeration as EnumerationType, EnumerationValue } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-export type EnumerationSchemaOptions = SimpleSchemaOptions;
+export type EnumerationSchemaOptions<T extends EnumerationType> = SimpleSchemaOptions<EnumerationValue<T>>;
 export declare class EnumerationSchema<const T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
     #private;
     readonly name: string;
     readonly enumeration: EnumerationType;
-    constructor(enumeration: T, options?: EnumerationSchemaOptions);
+    readonly allowedValues: readonly EnumerationValue<T>[];
+    constructor(enumeration: T, options?: EnumerationSchemaOptions<T>);
 }
-export declare function enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions): EnumerationSchema<T>;
-export declare function Enumeration(enumeration: EnumerationType, options?: EnumerationSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions<T>): EnumerationSchema<T>;
+export declare function Enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions<T> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/enumeration.js

@@ -1,12 +1,13 @@
 import { enumValues } from '../../utils/enum.js';
 import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isArray, isString } from '../../utils/type-guards.js';
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class EnumerationSchema extends SimpleSchema {
     #allowedValuesSet;
     name;
     enumeration;
+    allowedValues;
     constructor(enumeration, options) {
         const allowedValues = isArray(enumeration) ? enumeration : enumValues(enumeration);
         const allowedValuesString = allowedValues.map((value) => (isString(value) ? `"${value}"` : String(value))).join(', ');
@@ -18,6 +19,7 @@ export class EnumerationSchema extends SimpleSchema {
             gotValueFormatter: (value) => isString(value) ? `"${value}"` : String(value)
         });
         this.enumeration = enumeration;
+        this.allowedValues = allowedValues;
         this.#allowedValuesSet = new Set(allowedValues);
         lazyProperty(this, 'name', () => `Enumeration[${allowedValuesString}]`);
     }
@@ -26,5 +28,5 @@ export function enumeration(enumeration, options) {
     return new EnumerationSchema(enumeration, options);
 }
 export function Enumeration(enums, options) {
-    return Property(enumeration(enums, options), options);
+    return PropertySchema((data) => enumeration(enums, { description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/function.d.ts

@@ -1,9 +1,9 @@
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-export type FunctionSchemaOptions = SimpleSchemaOptions;
+export type FunctionSchemaOptions = SimpleSchemaOptions<Function>;
 export declare class FunctionSchema extends SimpleSchema<Function> {
     readonly name = "function";
     constructor(options?: FunctionSchemaOptions);
 }
-export declare function func(): FunctionSchema;
-export declare function FunctionProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function func(options?: FunctionSchemaOptions): FunctionSchema;
+export declare function FunctionProperty(options?: FunctionSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/function.js

@@ -1,5 +1,6 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 import { isFunction } from '../../utils/type-guards.js';
-import { Property } from '../decorators/index.js';
+import { PropertySchema } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class FunctionSchema extends SimpleSchema {
     name = 'function';
@@ -7,9 +8,9 @@ export class FunctionSchema extends SimpleSchema {
         super('function', isFunction, options);
     }
 }
-export function func() {
-    return new FunctionSchema();
+export function func(options) {
+    return new FunctionSchema(options);
 }
 export function FunctionProperty(options) {
-    return Property(func(), options);
+    return PropertySchema((data) => func({ description: data.description, example: data.example, ...options }), options);
 }

package/schema/schemas/instance.d.ts

@@ -1,12 +1,13 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { AbstractConstructor } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
-import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type InstanceSchemaOptions<T extends AbstractConstructor> = SchemaOptions<InstanceType<T>>;
 export declare class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {
     readonly name: string;
     readonly type: T;
-    constructor(type: T);
+    constructor(type: T, options?: InstanceSchemaOptions<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<InstanceType<T>>;
 }
-export declare function instance<T extends AbstractConstructor>(type: T): InstanceSchema<T>;
-export declare function Instance(type: AbstractConstructor, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T>): InstanceSchema<T>;
+export declare function Instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;