@tstdl/base 0.91.0-beta1 → 0.91.0-beta11

package/authentication/authentication.api.d.ts

@@ -1,5 +1,5 @@
 import { type ApiDefinition } from '../api/types.js';
-import { type ObjectSchema, type ObjectSchemaOrType } from '../schema/index.js';
+import { ObjectSchema, type ObjectSchemaOrType } from '../schema/index.js';
 import type { SchemaTestable } from '../schema/schema.js';
 import type { Record } from '../types.js';
 import type { TokenPayload } from './index.js';
@@ -15,9 +15,9 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                subject: string;
-                secret: string;
-                data: unknown;
+                readonly subject: string;
+                readonly secret: string;
+                readonly data: unknown;
             }>;
             result: ObjectSchema<TokenPayload<import("type-fest").EmptyObject>>;
             credentials: true;
@@ -29,7 +29,7 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                data: unknown;
+                readonly data: unknown;
             }>;
             result: ObjectSchema<TokenPayload<import("type-fest").EmptyObject>>;
             credentials: true;
@@ -41,8 +41,8 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                subject: string;
-                data: unknown;
+                readonly subject: string;
+                readonly data: unknown;
             }>;
             result: ObjectSchema<TokenPayload<import("type-fest").EmptyObject>>;
             credentials: true;
@@ -54,7 +54,7 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                data: unknown;
+                readonly data: unknown;
             }>;
             result: ObjectSchema<TokenPayload<import("type-fest").EmptyObject>>;
             credentials: true;
@@ -75,8 +75,8 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                subject: string;
-                data: import("type-fest").EmptyObject;
+                readonly subject: string;
+                readonly data: import("type-fest").EmptyObject;
             }>;
             result: import("../schema/index.js").LiteralSchema<"ok">;
         };
@@ -84,8 +84,8 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                token: string;
-                newSecret: string;
+                readonly token: string;
+                readonly newSecret: string;
             }>;
             result: import("../schema/index.js").LiteralSchema<"ok">;
         };
@@ -93,7 +93,7 @@ export declare const authenticationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                secret: string;
+                readonly secret: string;
             }>;
             result: typeof SecretCheckResult;
         };
@@ -110,9 +110,9 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                subject: string;
-                secret: string;
-                data: AuthenticationData;
+                readonly subject: string;
+                readonly secret: string;
+                readonly data: AuthenticationData;
             }>;
             result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
             credentials: true;
@@ -124,7 +124,7 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                data: AuthenticationData;
+                readonly data: AuthenticationData;
             }>;
             result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
             credentials: true;
@@ -136,8 +136,8 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                subject: string;
-                data: AuthenticationData;
+                readonly subject: string;
+                readonly data: AuthenticationData;
             }>;
             result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
             credentials: true;
@@ -149,7 +149,7 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                data: AuthenticationData;
+                readonly data: AuthenticationData;
             }>;
             result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
             credentials: true;
@@ -170,8 +170,8 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                subject: string;
-                data: AdditionalInitSecretResetData;
+                readonly subject: string;
+                readonly data: AdditionalInitSecretResetData;
             }>;
             result: import("../schema/index.js").LiteralSchema<"ok">;
         };
@@ -179,8 +179,8 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                token: string;
-                newSecret: string;
+                readonly token: string;
+                readonly newSecret: string;
             }>;
             result: import("../schema/index.js").LiteralSchema<"ok">;
         };
@@ -188,7 +188,7 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
-                secret: string;
+                readonly secret: string;
             }>;
             result: typeof SecretCheckResult;
         };
@@ -203,9 +203,9 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            subject: string;
-            secret: string;
-            data: AuthenticationData;
+            readonly subject: string;
+            readonly secret: string;
+            readonly data: AuthenticationData;
         }>;
         result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
         credentials: true;
@@ -217,7 +217,7 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            data: AuthenticationData;
+            readonly data: AuthenticationData;
         }>;
         result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
         credentials: true;
@@ -229,8 +229,8 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            subject: string;
-            data: AuthenticationData;
+            readonly subject: string;
+            readonly data: AuthenticationData;
         }>;
         result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
         credentials: true;
@@ -242,7 +242,7 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            data: AuthenticationData;
+            readonly data: AuthenticationData;
         }>;
         result: ObjectSchema<TokenPayload<AdditionalTokenPayload>>;
         credentials: true;
@@ -263,8 +263,8 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            subject: string;
-            data: AdditionalInitSecretResetData;
+            readonly subject: string;
+            readonly data: AdditionalInitSecretResetData;
         }>;
         result: import("../schema/index.js").LiteralSchema<"ok">;
     };
@@ -272,8 +272,8 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            token: string;
-            newSecret: string;
+            readonly token: string;
+            readonly newSecret: string;
         }>;
         result: import("../schema/index.js").LiteralSchema<"ok">;
     };
@@ -281,7 +281,7 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
-            secret: string;
+            readonly secret: string;
         }>;
         result: typeof SecretCheckResult;
     };

package/examples/api/basic-overview.js

@@ -18,7 +18,7 @@ import { configureHttpClient } from '../../http/client/module.js';
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
 import { inject } from '../../injector/inject.js';
 import { WebServerModule } from '../../module/modules/web-server.module.js';
-import { Number, Property, array, boolean, number, object } from '../../schema/index.js';
+import { NumberProperty, Property, array, boolean, number, object } from '../../schema/index.js';
 import { timeout } from '../../utils/timing.js';
 import { Agent } from 'undici';
 class User {
@@ -26,7 +26,7 @@ class User {
     name;
 }
 __decorate([
-    Number({ coerce: true }),
+    NumberProperty({ coerce: true }),
     __metadata("design:type", Number)
 ], User.prototype, "id", void 0);
 __decorate([

package/image-service/image-service.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Enumeration, Number, Optional } from '../schema/index.js';
+import { Enumeration, NumberProperty, Optional } from '../schema/index.js';
 export var ImageResizeMode;
 (function (ImageResizeMode) {
     ImageResizeMode["Fit"] = "fit";
@@ -49,11 +49,11 @@ __decorate([
     __metadata("design:type", String)
 ], ImageOptions.prototype, "resizeMode", void 0);
 __decorate([
-    Number({ optional: true, coerce: true }),
+    NumberProperty({ optional: true, coerce: true }),
     __metadata("design:type", Number)
 ], ImageOptions.prototype, "width", void 0);
 __decorate([
-    Number({ optional: true, coerce: true }),
+    NumberProperty({ optional: true, coerce: true }),
     __metadata("design:type", Number)
 ], ImageOptions.prototype, "height", void 0);
 __decorate([
@@ -62,7 +62,7 @@ __decorate([
     __metadata("design:type", String)
 ], ImageOptions.prototype, "origin", void 0);
 __decorate([
-    Number({ optional: true, coerce: true }),
+    NumberProperty({ optional: true, coerce: true }),
     __metadata("design:type", Number)
 ], ImageOptions.prototype, "quality", void 0);
 __decorate([

package/mail/mail.client.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Property } from '../schema/decorators/property.js';
-import { Boolean } from '../schema/index.js';
+import { BooleanProperty } from '../schema/index.js';
 import { Optional } from '../schema/schemas/optional.js';
 export class MailClientAuthConfig {
     user;
@@ -38,7 +38,7 @@ __decorate([
     __metadata("design:type", Number)
 ], MailClientConfig.prototype, "port", void 0);
 __decorate([
-    Boolean({ optional: true }),
+    BooleanProperty({ optional: true }),
     __metadata("design:type", Boolean)
 ], MailClientConfig.prototype, "secure", void 0);
 __decorate([

package/orm/entity.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Number, Property, any, record } from '../schema/index.js';
+import { NumberProperty, Property, any, record } from '../schema/index.js';
 export class EntityMetadata {
     revision;
     revisionTimestamp;
@@ -28,7 +28,7 @@ __decorate([
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "createTimestamp", void 0);
 __decorate([
-    Number({ nullable: true }),
+    NumberProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "deleteTimestamp", void 0);
 __decorate([

package/orm/schema-converter.d.ts

@@ -19,8 +19,12 @@ export declare const mySchemaUsers: PgTableWithColumns<{
             driverParam: string;
             notNull: false;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: undefined;
             baseColumn: never;
+            generated: undefined;
         }, {}, {}>;
         name: import("drizzle-orm/pg-core").PgColumn<{
             name: "name";
@@ -31,8 +35,12 @@ export declare const mySchemaUsers: PgTableWithColumns<{
             driverParam: string;
             notNull: false;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
+            generated: undefined;
         }, {}, {}>;
         age: import("drizzle-orm/pg-core").PgColumn<{
             name: "";
@@ -43,8 +51,12 @@ export declare const mySchemaUsers: PgTableWithColumns<{
             driverParam: string | number;
             notNull: false;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: undefined;
             baseColumn: never;
+            generated: undefined;
         }, {}, {}>;
         color: import("drizzle-orm/pg-core").PgColumn<{
             name: "color";
@@ -55,8 +67,12 @@ export declare const mySchemaUsers: PgTableWithColumns<{
             driverParam: string;
             notNull: false;
             hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: ["red", "green", "blue"];
             baseColumn: never;
+            generated: undefined;
         }, {}, {}>;
     };
     dialect: "pg";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.0-beta1",
+  "version": "0.91.0-beta11",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -111,7 +111,7 @@
     "luxon": "^3.4",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.21"
+    "type-fest": "4.22"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -142,12 +142,12 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.4",
-    "drizzle-orm": "^0.31",
+    "drizzle-orm": "^0.32",
     "handlebars": "^4.7",
     "koa": "^2.15",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.7",
+    "mongodb": "^6.8",
     "nodemailer": "^6.9",
     "pg": "^8.12",
     "playwright": "^1.45",

package/schema/decorators/utils.js

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { createPropertyOrAccessorDecorator } from '../../reflection/index.js';
-export function createSchemaPropertyDecorator(data) {
+import { filterUndefinedObjectProperties } from '../../utils/object/object.js';
+export function createSchemaPropertyDecorator(data = {}) {
     return createPropertyOrAccessorDecorator({
-        data: { schema: data },
+        data: { schema: filterUndefinedObjectProperties(data) },
         mergeData: true
     });
 }

package/schema/schema.d.ts

@@ -19,10 +19,11 @@ export type SchemaTestResult<T> = {
     error: SchemaError;
 };
 type NormalizePrimitiveToConstructor<T> = Or<IsEqual<T, string>, IsEqual<T, String>> extends true ? typeof String : Or<IsEqual<T, number>, IsEqual<T, Number>> extends true ? typeof Number : Or<IsEqual<T, boolean>, IsEqual<T, Boolean>> extends true ? typeof Boolean : Or<IsEqual<T, bigint>, IsEqual<T, BigInt>> extends true ? typeof BigInt : Or<IsEqual<T, symbol>, IsEqual<T, Symbol>> extends true ? typeof Symbol : never;
-type NormalizeConstructorToPrimitve<T> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends BigInt ? bigint : T extends Symbol ? symbol : T;
 export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
-export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? NormalizeConstructorToPrimitve<U> : never;
+export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
+export declare const OPTIONAL: unique symbol;
 export declare abstract class Schema<T = unknown> {
+    readonly [OPTIONAL]: boolean;
     /**
      * Test an unknown value to see whether it corresponds to the schema.
      * @param schema schema to test against

package/schema/schemas/array.d.ts

@@ -1,5 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator } from '../decorators/index.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';
 export declare class ArraySchema<T> extends Schema<T[]> {
     readonly itemSchema: Schema<T>;
@@ -7,4 +8,4 @@ export declare class ArraySchema<T> extends Schema<T[]> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;
 }
 export declare function array<T>(schema: SchemaTestable<T>): ArraySchema<T>;
-export declare function Array(schema: SchemaTestable): SchemaPropertyDecorator;
+export declare function Array(schema: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/schema/schemas/array.js

@@ -11,21 +11,23 @@ export class ArraySchema extends Schema {
         this.itemSchema = schemaTestableToSchema(itemSchema);
     }
     _test(value, path, options) {
-        if (isArray(value)) {
-            for (let i = 0; i < value.length; i++) {
-                const result = this.itemSchema._test(value[i], path.add(i), options);
-                if (!result.valid) {
-                    return result;
-                }
+        if (!isArray(value)) {
+            return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
+        }
+        const values = [];
+        for (let i = 0; i < value.length; i++) {
+            const result = this.itemSchema._test(value[i], path.add(i), options);
+            if (!result.valid) {
+                return result;
             }
-            return { valid: true, value: value };
+            values.push(result.value);
         }
-        return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
+        return { valid: true, value: values };
     }
 }
 export function array(schema) {
     return new ArraySchema(schema);
 }
-export function Array(schema) {
-    return Property(schema, { array: true });
+export function Array(schema, options) {
+    return Property(schema, { ...options, array: true });
 }

package/schema/schemas/bigint.d.ts

@@ -1,8 +1,9 @@
 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> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<bigint>;
 }
 export declare function bigint(): BigIntSchema;
-export declare function BigInt(): SchemaPropertyDecorator;
+export declare function BigIntProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/bigint.js

@@ -14,6 +14,6 @@ export class BigIntSchema extends Schema {
 export function bigint() {
     return new BigIntSchema();
 }
-export function BigInt() {
-    return Property(bigint());
+export function BigIntProperty(options) {
+    return Property(bigint(), options);
 }

package/schema/schemas/boolean.d.ts

@@ -7,9 +7,5 @@ export declare class BooleanSchema extends SimpleSchema<boolean> {
     constructor(options?: BooleanSchemaOptions);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<boolean>;
 }
-export declare function boolean(): BooleanSchema;
-export declare function Boolean(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link Boolean()} instead
- */
-export declare function BooleanProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function boolean(options?: BooleanSchemaOptions): BooleanSchema;
+export declare function BooleanProperty(options?: BooleanSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/boolean.js

@@ -36,15 +36,9 @@ export class BooleanSchema extends SimpleSchema {
         return { valid: false, error: SchemaError.expectedButGot('boolean', typeOf(value), path, { fast: options.fastErrors }) };
     }
 }
-export function boolean() {
-    return new BooleanSchema();
+export function boolean(options) {
+    return new BooleanSchema(options);
 }
-export function Boolean(options) {
-    return Property(boolean(), options);
-}
-/**
- * @deprecated use {@link Boolean()} instead
- */
 export function BooleanProperty(options) {
-    return Boolean(options);
+    return Property(boolean(options), options);
 }

package/schema/schemas/date.d.ts

@@ -7,4 +7,4 @@ export declare class DateSchema extends SimpleSchema<globalThis.Date> {
     constructor(options?: DateSchemaOptions);
 }
 export declare function date(options?: DateSchemaOptions): DateSchema;
-export declare function Date(options?: SchemaPropertyDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;
+export declare function DateProperty(options?: SchemaPropertyDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/date.js

@@ -23,6 +23,6 @@ export class DateSchema extends SimpleSchema {
 export function date(options) {
     return new DateSchema(options);
 }
-export function Date(options) {
+export function DateProperty(options) {
     return Property(date(options), options);
 }

package/schema/schemas/function.d.ts

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

package/schema/schemas/function.js

@@ -0,0 +1,14 @@
+import { isFunction } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class FunctionSchema extends SimpleSchema {
+    constructor(options) {
+        super('function', isFunction, options);
+    }
+}
+export function func() {
+    return new FunctionSchema();
+}
+export function FunctionProperty(options) {
+    return Property(func(), options);
+}

package/schema/schemas/index.d.ts

@@ -5,6 +5,7 @@ export * from './boolean.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './enumeration.js';
+export * from './function.js';
 export * from './instance.js';
 export * from './literal.js';
 export * from './never.js';

package/schema/schemas/index.js

@@ -5,6 +5,7 @@ export * from './boolean.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './enumeration.js';
+export * from './function.js';
 export * from './instance.js';
 export * from './literal.js';
 export * from './never.js';

package/schema/schemas/nullable.d.ts

@@ -1,5 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator } from '../decorators/index.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';
 export declare class NullableSchema<T> extends Schema<T | null> {
     readonly schema: Schema<T>;
@@ -7,4 +8,4 @@ export declare class NullableSchema<T> extends Schema<T | null> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null>;
 }
 export declare function nullable<T>(schema: SchemaTestable<T>): NullableSchema<T>;
-export declare function Nullable(): SchemaPropertyDecorator;
+export declare function Nullable(schema?: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'nullable'>): SchemaPropertyDecorator;

package/schema/schemas/nullable.js

@@ -21,6 +21,6 @@ export class NullableSchema extends Schema {
 export function nullable(schema) {
     return new NullableSchema(schema);
 }
-export function Nullable() {
-    return createSchemaPropertyDecorator({ nullable: true });
+export function Nullable(schema, options) {
+    return createSchemaPropertyDecorator({ schema, ...options, nullable: true });
 }

package/schema/schemas/number.d.ts

@@ -7,9 +7,5 @@ export declare class NumberSchema extends SimpleSchema<number> {
     constructor(options?: NumberSchemaOptions);
 }
 export declare function number(options?: NumberSchemaOptions): NumberSchema;
-export declare function Number(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
-export declare function Integer(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link Number()} instead
- */
 export declare function NumberProperty(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
+export declare function Integer(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/number.js

@@ -24,15 +24,9 @@ export class NumberSchema extends SimpleSchema {
 export function number(options) {
     return new NumberSchema(options);
 }
-export function Number(options) {
+export function NumberProperty(options) {
     return Property(number(options), options);
 }
 export function Integer(options) {
     return Property(number({ ...options, integer: true }), options);
 }
-/**
- * @deprecated use {@link Number()} instead
- */
-export function NumberProperty(options) {
-    return Number(options);
-}

package/schema/schemas/object.d.ts

@@ -1,7 +1,10 @@
 import type { EmptyObject, Merge } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { AbstractConstructor, OneOrMany, PartialProperty, Record, SimplifyObject, Type, TypedOmit } from '../../types.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import type { AbstractConstructor, OneOrMany, PartialProperty, Record as RecordType, SimplifyObject, Type, TypedOmit } from '../../types.js';
+import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { SchemaPropertyDecorator } from '../decorators/types.js';
+import { type OPTIONAL, Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type Record<K extends PropertyKey = PropertyKey, V = any> = RecordType<K, V>;
 export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
 export type ObjectSchemaFactory<T> = {
     type: Type<T>;
@@ -19,6 +22,14 @@ export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey
     factory?: ObjectSchemaFactory<T> | null;
 };
 export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
+export type OptionalProperties<T> = {
+    [P in keyof T]: T[P] extends {
+        [OPTIONAL]: true;
+    } ? P : never;
+}[keyof T];
+export type ObjectSchemaPropertiesType<TP extends ObjectSchemaProperties> = SimplifyObject<{
+    [P in keyof PartialProperty<TP, OptionalProperties<TP>>]: SchemaOutput<TP[P]>;
+}>;
 export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
 export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
     private readonly propertyKeys;
@@ -31,45 +42,47 @@ export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
     constructor(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
 }
-export declare function object<K extends PropertyKey, V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
+export declare function object<const K extends PropertyKey, const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey: SchemaTestable<K>;
 }): ObjectSchema<Record<K, V>>;
-export declare function object<K extends PropertyKey>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, unknown>> & {
+export declare function object<const K extends PropertyKey>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, unknown>> & {
     unknownProperties?: undefined;
     unknownPropertiesKey: SchemaTestable<K>;
 }): ObjectSchema<Record<K, unknown>>;
-export declare function object<V>(properties: Record<never>, options: ObjectSchemaOptions<Record<PropertyKey, V>> & {
+export declare function object<const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<PropertyKey, V>> & {
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey?: undefined;
 }): ObjectSchema<Record<PropertyKey, V>>;
-export declare function object<T extends Record, K extends PropertyKey, V>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<K, V>> & {
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, V>> & {
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<SimplifyObject<T & Record<K, V>>>;
-export declare function object<T extends Record, K extends PropertyKey>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<K, unknown>> & {
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, unknown>> & {
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<SimplifyObject<T & Record<K, unknown>>>;
-export declare function object<T extends Record, V>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<PropertyKey, V>> & {
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, unknown>>;
+export declare function object<const TP extends ObjectSchemaProperties, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>> & {
     unknownProperties: SchemaTestable<V>;
-}): ObjectSchema<SimplifyObject<T & Record<PropertyKey, V>>>;
-export declare function object<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T> & {
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>>;
+export declare function object<const TP extends ObjectSchemaProperties>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>> & {
     unknownProperties?: undefined;
     unknownPropertiesKey?: undefined;
-}): ObjectSchema<T>;
-export declare function object<T extends Record, K extends PropertyKey, V>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T, K, V>): ObjectSchema<SimplifyObject<T & Record<K, V>>>;
-export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
-export declare function record<K extends PropertyKey, V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
-export declare function assign<T1 extends Record, T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
-export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
-export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
-export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
-export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record, T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
-export declare function partial<T extends Record>(schema: ObjectSchema<T>): ObjectSchema<Partial<T>>;
-export declare function partial<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
-export declare function pick<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
-export declare function omit<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>, K, V>): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
+export declare function explicitObject<const T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
+export declare function record<const K extends PropertyKey, const V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
+export declare function assign<const T1 extends Record, const T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record, const T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
+export declare function partial<const T extends Record>(schema: ObjectSchemaOrType<T>): ObjectSchema<Partial<T>>;
+export declare function partial<const T extends Record, const K extends keyof T>(schema: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
+export declare function pick<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Pick<T, K>>>;
+export declare function omit<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
 export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
-declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | null;
+declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | ObjectSchema<T> | null;
+export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
+export declare function Record<K extends PropertyKey, V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
 export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
 export {};

package/schema/schemas/object.js

@@ -6,6 +6,7 @@ import { memoizeSingle } from '../../utils/function/memoize.js';
 import { filterObject, mapObjectValues, objectKeys } from '../../utils/object/object.js';
 import { assert, isDefined, isFunction, isLiteralObject, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 import { array } from './array.js';
@@ -79,21 +80,15 @@ export function record(key, value, options) {
     return object({}, { ...options, unknownPropertiesKey: key, unknownProperties: value });
 }
 export function assign(...schemasOrTypes) {
-    const schemas = schemasOrTypes.map((schemaOrType) => {
-        if (schemaOrType instanceof ObjectSchema) {
-            return schemaOrType;
-        }
-        const typeSchema = getSchemaFromReflection(schemaOrType);
-        assert(typeSchema instanceof ObjectSchema, 'assign() only works with object schemas.');
-        return typeSchema;
-    });
+    const schemas = schemasOrTypes.map(getObjectSchema);
     return object(schemas.reduce((result, schema) => ({ ...result, ...schema.properties }), {}), {
         mask: schemas.findLast((schema) => isNotNull(schema.mask))?.mask,
         unknownProperties: schemas.findLast((schema) => isNotNull(schema.unknownProperties))?.unknownProperties,
         unknownPropertiesKey: schemas.findLast((schema) => isNotNull(schema.unknownPropertiesKey))?.unknownPropertiesKey
     });
 }
-export function partial(schema, keyOrKeys) {
+export function partial(schemaOrType, keyOrKeys) {
+    const schema = getObjectSchema(schemaOrType);
     const keys = isUndefined(keyOrKeys) ? undefined : toArray(keyOrKeys);
     const mapper = isUndefined(keys)
         ? (propertySchema) => optional(propertySchema)
@@ -104,7 +99,8 @@ export function partial(schema, keyOrKeys) {
         unknownPropertiesKey: schema.unknownPropertiesKey
     });
 }
-export function pick(schema, keys) {
+export function pick(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
     const keyArray = toArray(keys);
     return object(filterObject(schema.properties, (_, key) => keyArray.includes(key)), {
         mask: schema.mask,
@@ -112,7 +108,8 @@ export function pick(schema, keys) {
         unknownPropertiesKey: schema.unknownPropertiesKey
     });
 }
-export function omit(schema, keys) {
+export function omit(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
     const keysArray = toArray(keys);
     return object(filterObject(schema.properties, (_, key) => !keysArray.includes(key)), {
         mask: schema.mask,
@@ -158,7 +155,7 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     for (const [key, propertyMetadata] of metadata.properties) {
         const reflectionData = propertyMetadata.data.tryGet('schema');
         if (isUndefined(reflectionData?.schema) && (propertyMetadata.type == Object)) {
-            throw new Error(`Schema of property "${String(key)}" on type ${type.name} is inferred as Object. This is most likely unwanted and happens when the property is defined as partial or the type is an union. Use an explicit @Property(Object) if wanted.`);
+            throw new Error(`Schema of property "${String(key)}" on type ${type.name} is inferred as Object. This is most likely unwanted and happens when the property is defined as partial or the type is an union. Use an explicit @Property(Object) if this is wanted.`);
         }
         let propertySchema = reflectionData?.schema ?? propertyMetadata.type;
         if (reflectionData?.array == true) {
@@ -174,4 +171,16 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     }
     return properties;
 }
+export function getObjectSchema(schemaOrType) {
+    if (schemaOrType instanceof ObjectSchema) {
+        return schemaOrType;
+    }
+    if (isFunction(schemaOrType)) {
+        return getObjectSchema(getSchemaFromReflection(schemaOrType));
+    }
+    throw new Error('Could not infer ObjectSchema.');
+}
+export function Record(key, value, options) {
+    return Property(record(key, value, options), options);
+}
 export const emptyObjectSchema = explicitObject({});

package/schema/schemas/optional.d.ts

@@ -1,10 +1,12 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { SchemaPropertyDecorator } from '../decorators/types.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import type { TypedOmit } from '../../types.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type OPTIONAL, Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class OptionalSchema<T> extends Schema<T | undefined> {
+    readonly [OPTIONAL]: true;
     readonly schema: Schema<T>;
     constructor(schema: SchemaTestable<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | undefined>;
 }
 export declare function optional<T>(schema: SchemaTestable<T>): OptionalSchema<T>;
-export declare function Optional(schema?: SchemaTestable): SchemaPropertyDecorator;
+export declare function Optional(schema?: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'optional'>): SchemaPropertyDecorator;

package/schema/schemas/optional.js

@@ -1,5 +1,5 @@
 import { isUndefined } from '../../utils/type-guards.js';
-import { createSchemaPropertyDecorator } from '../decorators/utils.js';
+import { createSchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class OptionalSchema extends Schema {
@@ -21,6 +21,6 @@ export class OptionalSchema extends Schema {
 export function optional(schema) {
     return new OptionalSchema(schema);
 }
-export function Optional(schema) {
-    return createSchemaPropertyDecorator({ schema, optional: true });
+export function Optional(schema, options) {
+    return createSchemaPropertyDecorator({ schema, ...options, optional: true });
 }

package/schema/schemas/readable-stream.d.ts

@@ -5,4 +5,4 @@ export declare class ReadableStreamSchema extends SimpleSchema<ReadableStream> {
     constructor(options?: ReadableStreamSchemaOptions);
 }
 export declare function readableStream(options?: ReadableStreamSchemaOptions): ReadableStreamSchema;
-export declare function ReadableStream(options?: SchemaPropertyDecoratorOptions & ReadableStreamSchemaOptions): SchemaPropertyDecorator;
+export declare function ReadableStreamProperty(options?: SchemaPropertyDecoratorOptions & ReadableStreamSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/readable-stream.js

@@ -9,6 +9,6 @@ export class ReadableStreamSchema extends SimpleSchema {
 export function readableStream(options) {
     return new ReadableStreamSchema(options);
 }
-export function ReadableStream(options) {
+export function ReadableStreamProperty(options) {
     return Property(readableStream(options), options);
 }

package/schema/schemas/regexp.d.ts

@@ -5,4 +5,4 @@ export declare class RegExpSchema extends SimpleSchema<RegExp> {
     constructor(options?: RegExpSchemaOptions);
 }
 export declare function regExp(options?: RegExpSchemaOptions): RegExpSchema;
-export declare function RegExp(options?: SchemaPropertyDecoratorOptions & RegExpSchemaOptions): SchemaPropertyDecorator;
+export declare function RegExpProperty(options?: SchemaPropertyDecoratorOptions & RegExpSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/regexp.js

@@ -22,6 +22,6 @@ export class RegExpSchema extends SimpleSchema {
 export function regExp(options) {
     return new RegExpSchema(options);
 }
-export function RegExp(options) {
+export function RegExpProperty(options) {
     return Property(regExp(options), options);
 }

package/schema/schemas/string.d.ts

@@ -7,8 +7,4 @@ export declare class StringSchema extends SimpleSchema<string> {
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;
-export declare function String(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link String()} instead
- */
 export declare function StringProperty(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/string.js

@@ -19,12 +19,6 @@ export class StringSchema extends SimpleSchema {
 export function string(options) {
     return new StringSchema(options);
 }
-export function String(options) {
-    return Property(string(options), options);
-}
-/**
- * @deprecated use {@link String()} instead
- */
 export function StringProperty(options) {
-    return String(options);
+    return Property(string(options), options);
 }

package/schema/schemas/symbol.d.ts

@@ -1,12 +1,8 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class SymbolSchema extends Schema<symbol> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<symbol>;
 }
 export declare function symbol(): SymbolSchema;
-export declare function Symbol(): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link Symbol()} instead
- */
-export declare function SymbolProperty(): SchemaPropertyDecorator;
+export declare function SymbolProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/symbol.js

@@ -14,12 +14,6 @@ export class SymbolSchema extends Schema {
 export function symbol() {
     return new SymbolSchema();
 }
-export function Symbol() {
-    return Property(symbol());
-}
-/**
- * @deprecated use {@link Symbol()} instead
- */
-export function SymbolProperty() {
-    return Symbol();
+export function SymbolProperty(options) {
+    return Property(symbol(), options);
 }

package/schema/schemas/uint8-array.d.ts

@@ -11,4 +11,4 @@ export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
     constructor(options?: Uint8ArraySchemaOptions);
 }
 export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;
-export declare function Uint8Array(schemaOptions?: Uint8ArraySchemaOptions, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Uint8ArrayProperty(schemaOptions?: Uint8ArraySchemaOptions, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/uint8-array.js

@@ -6,8 +6,8 @@ export class Uint8ArraySchema extends SimpleSchema {
     constructor(options) {
         super('Uint8Array', isUint8Array, options, {
             constraints: [
-                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= options.minimumLength) ? ({ success: true }) : ({ success: false, error: `size must be at least ${options.minimumLength} bytes.` }) : null,
-                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= options.maximumLength) ? ({ success: true }) : ({ success: false, error: `size must be at most ${options.maximumLength} bytes.` }) : null
+                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= options.minimumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at least ${options.minimumLength} bytes.` }) : null,
+                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= options.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${options.maximumLength} bytes.` }) : null
             ]
         });
     }
@@ -15,6 +15,6 @@ export class Uint8ArraySchema extends SimpleSchema {
 export function uint8Array(options) {
     return new Uint8ArraySchema(options);
 }
-export function Uint8Array(schemaOptions, options) {
+export function Uint8ArrayProperty(schemaOptions, options) {
     return Property(uint8Array(schemaOptions), options);
 }

package/schema/testable.js

@@ -2,6 +2,7 @@ import { isFunction } from '../utils/type-guards.js';
 import { Schema } from './schema.js';
 import { bigint } from './schemas/bigint.js';
 import { boolean } from './schemas/boolean.js';
+import { func } from './schemas/function.js';
 import { number } from './schemas/number.js';
 import { getSchemaFromReflection } from './schemas/object.js';
 import { string } from './schemas/string.js';
@@ -21,6 +22,8 @@ export function schemaTestableToSchema(testable) {
             return bigint();
         case Symbol:
             return symbol();
+        case Function:
+            return func();
         default:
             return getSchemaFromReflection(testable);
     }