@tsed/schema 8.34.0 → 8.36.0

package/lib/types/domain/JsonSchema.d.ts

@@ -1,15 +1,15 @@
-import { Type, ValueOf } from "@tsed/core";
-import { Hooks } from "@tsed/hooks";
-import type { JSONSchema7, JSONSchema7Definition, JSONSchema7Type, JSONSchema7TypeName, JSONSchema7Version } from "json-schema";
-import { VendorKeys } from "../constants/VendorKeys.js";
-import { IgnoreCallback } from "../interfaces/IgnoreCallback.js";
-import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
-import { type GenericsMap, GenericValue } from "../utils/generics.js";
 import { AliasMap, AliasType } from "./JsonAliasMap.js";
+import type { GenericValue, GenericsMap } from "./Generics.js";
+import type { Infer, PropsToShape, SchemaKey, SchemaMerge, SchemaOmit, SchemaPartial, SchemaPick, UnionToIntersection } from "./types.js";
+import type { JSONSchema7, JSONSchema7Definition, JSONSchema7Type, JSONSchema7TypeName, JSONSchema7Version } from "json-schema";
+import { Type, ValueOf } from "@tsed/core";
 import { Discriminator } from "./JsonDiscriminator.js";
+import { Hooks } from "@tsed/hooks";
+import { IgnoreCallback } from "./IgnoreCallback.js";
 import { JsonFormatTypes } from "./JsonFormatTypes.js";
 import { JsonLazyRef } from "./JsonLazyRef.js";
-import type { Infer, PropsToShape, SchemaKey, SchemaMerge, SchemaOmit, SchemaPartial, SchemaPick, UnionToIntersection } from "./types.js";
+import { JsonSchemaOptions } from "./JsonSchemaOptions.js";
+import { VendorKeys } from "../constants/VendorKeys.js";
 /**
  * Extended JSON Schema object supporting TypeScript types and Ts.ED enhancements.
  *
@@ -72,7 +72,7 @@ export type AnyJsonSchema<T = any> = JsonSchemaObject | JSONSchema7 | JsonSchema
  *   email: string;
  * }
  *
- * const userSchema = JsonSchema.from(User);
+ * const userSchema = s.from(User);
  *
  * // Generate JSON Schema output
  * const jsonSchema = userSchema.toJSON();
@@ -223,22 +223,22 @@ export declare class JsonSchema<T = JSONSchema7Type> extends Map<string, any> {
      *
      * ```typescript
      * // From a class
-     * const schema1 = JsonSchema.from(User);
+     * const schema1 = s.from(User);
      *
      * // From a primitive
-     * const schema2 = JsonSchema.from(String);
+     * const schema2 = s.from(String);
      *
      * // From a schema object
-     * const schema3 = JsonSchema.from({type: "string", minLength: 1});
+     * const schema3 = s.string().minLength(1);
      *
      * // From existing schema (no-op)
-     * const schema4 = JsonSchema.from(schema1);
+     * const schema4 = s.from(schema1);
      * ```
      *
      * @param item - The input to convert to a JsonSchema
      * @returns A JsonSchema instance representing the input
+     * @deprecated
      */
-    static from(item: Partial<JsonSchemaObject> | Type<any> | JsonSchema | undefined): JsonSchema<JSONSchema7Type>;
     static add<Keys extends keyof JsonSchema>(property: Keys, method: JsonSchema[Keys]): typeof JsonSchema;
     /**
      * Check if the schema has a property.
@@ -354,12 +354,16 @@ export declare class JsonSchema<T = JSONSchema7Type> extends Map<string, any> {
      * ```typescript
      * // For Paginated<User>
      * schema.genericOf([User]);
+     * schema.genericOf(User);
+     * schema.genericOf({T: [User]});
      * ```
      *
-     * @param generics - Arrays of generic type values to apply
+     * @param generics - Generic bindings to apply
      * @returns This schema instance for method chaining
      */
-    genericOf(...generics: GenericValue[][]): this;
+    genericOf(generics: GenericsMap): this;
+    genericOf(generic: GenericValue): this;
+    genericOf(...generics: Array<GenericValue[] | GenericValue>): this;
     /**
      * Mark this schema as nullable or non-nullable.
      *
@@ -565,7 +569,7 @@ export declare class JsonSchema<T = JSONSchema7Type> extends Map<string, any> {
      * Set the items' schema for array/set collections
      * @param items The schema for array/set items
      */
-    items<I = JSONSchema7Type>(items: JsonSchema<I> | AnyJsonSchema | AnyJsonSchema[]): JsonSchema<T extends Array<any> ? I[] : T extends Set<any> ? Set<I> : I>;
+    items<I = JSONSchema7Type>(items: JsonSchema<I> | AnyJsonSchema | AnyJsonSchema[], init?: boolean): JsonSchema<T extends Array<any> ? I[] : T extends Set<any> ? Set<I> : I>;
     $comment(comment: string): this;
     /**
      * Must be a non-negative integer.
@@ -646,7 +650,7 @@ export declare class JsonSchema<T = JSONSchema7Type> extends Map<string, any> {
      * The default value is an empty schema that allows any value for additional properties.
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
      */
-    additionalProperties<V>(additionalProperties: boolean | AnyJsonSchema | JsonSchema<V>): JsonSchema<Map<string, V>>;
+    additionalProperties<V>(additionalProperties: boolean | AnyJsonSchema | JsonSchema<V>, init?: boolean): JsonSchema<Map<string, V>>;
     /**
      * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
      * If specified, the value MUST be a schema or a boolean.
@@ -787,7 +791,7 @@ export declare class JsonSchema<T = JSONSchema7Type> extends Map<string, any> {
     toObject(options?: JsonSchemaOptions): any;
     toJSON(options?: JsonSchemaOptions): any;
     assign(obj: Partial<JSONSchema7> | JsonSchema | Record<string, unknown>): this;
-    set(key: string, value: any): this;
+    set(key: string, value: any, force?: boolean): this;
     /**
      * Return the JSON type as string
      */
@@ -812,11 +816,13 @@ export declare class JsonSchema<T = JSONSchema7Type> extends Map<string, any> {
     getRefSchema(): JsonSchema<JSONSchema7Type> | undefined;
     propertyKey(s: string): this;
     getPropertyKey(): string | symbol | undefined;
-    target(target: any): void;
+    target(target: any): this;
     isRequiredValue(property: string, value: any): boolean;
+    toCollection(): this;
+    unsetType(): this;
     protected setManyOf(keyword: "oneOf" | "anyOf" | "allOf", value: (AnyJsonSchema | null)[]): this | undefined;
-    protected mapToJsonSchema(item: any[]): JsonSchema[];
-    protected mapToJsonSchema(item: any): JsonSchema;
+    protected toSchema(item: any[]): JsonSchema[];
+    protected toSchema(item: any): JsonSchema;
     protected mapGenerics(jsonSchema: unknown, generics: GenericValue[][]): GenericsMap;
     protected mapProperties(properties: Record<string, any>): any;
 }

package/lib/types/{interfaces → domain}/JsonSchemaOptions.d.ts

@@ -1,5 +1,5 @@
-import { SpecTypes } from "../domain/SpecTypes.js";
-import type { GenericsMap } from "../utils/generics.js";
+import type { GenericsMap } from "./Generics.js";
+import { SpecTypes } from "./SpecTypes.js";
 /**
  * Configuration options for JSON schema generation.
  *
@@ -61,12 +61,26 @@ export interface JsonSchemaOptions {
      */
     inlineEnums?: boolean;
     /**
-     * Represents optional generic definitions that adhere to the JSON Schema standard.
+     * Inline resolvable local JSON Schema references in the compiled output.
      *
-     * This property allows the specification of generics when constructing or representing a JSON schema.
-     * It can be used to define reusable and parameterized components within the schema structure.
+     * External references and circular local references are preserved.
+     */
+    inlineRefs?: boolean;
+    /**
+     * Explicit generic bindings used during schema compilation.
+     *
+     * Prefer attaching generics directly to a local schema instance with the
+     * functional API:
+     *
+     * ```typescript
+     * from(Pagination).genericOf(Product)
+     * generic(Pagination).of(Product)
+     * ```
      *
-     * @type {GenericsMap|undefined}
+     * `options.generics` remains useful for low-level compilation flows where the
+     * generic bindings must be supplied externally, for example when compiling a
+     * shared class schema. When both are provided, the generics carried by the
+     * `JsonSchema` instance take precedence over `options.generics`.
      */
     generics?: GenericsMap;
     [key: string]: any;

package/lib/types/domain/__fixtures__/inspectOperationsPaths.d.ts

@@ -1,4 +1,4 @@
-import type { JsonMethodStore } from "../JsonMethodStore.js";
+import type { JsonMethodStore } from "../../components/stores/JsonMethodStore.js";
 export declare function inspectOperationsPaths(endpoint: JsonMethodStore): {
     method: string;
     path: string | RegExp;

package/lib/types/domain/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./DecoratorContext.js";
+export * from "./Generics.js";
+export * from "./IgnoreCallback.js";
+export * from "./JsonAliasMap.js";
+export * from "./JsonDiscriminator.js";
+export * from "./JsonEntityStore.js";
+export * from "./JsonFormatTypes.js";
+export * from "./JsonHookContext.js";
+export * from "./JsonLazyRef.js";
+export * from "./JsonMap.js";
+export * from "./JsonMedia.js";
+export * from "./JsonOpenSpec.js";
+export * from "./JsonOperation.js";
+export * from "./JsonOperationPathsMap.js";
+export * from "./JsonOperationRoute.js";
+export * from "./JsonParameter.js";
+export * from "./JsonParameterTypes.js";
+export * from "./JsonRequestBody.js";
+export * from "./JsonResponse.js";
+export * from "./JsonSchema.js";
+export * from "./JsonSchemaOptions.js";
+export * from "./SpecTypes.js";
+export * from "./types.js";

package/lib/types/domain/types.d.ts

@@ -8,7 +8,7 @@ import type { JsonSchema } from "./JsonSchema.js";
  * ### Usage
  *
  * ```typescript
- * const userSchema = JsonSchema.from({ type: "object" });
+ * const userSchema = s.object();
  * type User = Infer<typeof userSchema>; // Extracts the type
  * ```
  *

package/lib/types/fn/any.d.ts

@@ -1,5 +1,5 @@
-import type { JsonSchema } from "../domain/JsonSchema.js";
 import type { Infer } from "../domain/types.js";
+import type { JsonSchema } from "../domain/JsonSchema.js";
 /**
  * Declare a model with any type (By default: `integer`, `number`, `string`, `boolean`, `array`, `object`, `null`)
  *

package/lib/types/fn/boolean.d.ts

@@ -41,4 +41,4 @@
  *
  * @public
  */
-export declare function boolean(): import("../index.js").JsonSchema<boolean>;
+export declare function boolean(): import("@tsed/schema").JsonSchema<boolean>;

package/lib/types/fn/compile.d.ts

@@ -0,0 +1,21 @@
+import "../components/index.js";
+import { Type } from "@tsed/core";
+import { JsonSchema } from "../domain/index.js";
+import { JsonParameterStore } from "../components/index.js";
+import { JsonSchemaOptions } from "../domain/JsonSchemaOptions.js";
+/**
+ * Compile a class, parameter store, or `JsonSchema` into a plain JSON schema object.
+ *
+ * This is an alias of `getJsonSchema(...)`.
+ *
+ * @param model Class, parameter store, or `JsonSchema` to compile.
+ * @param options JSON schema generation options.
+ * @returns Compiled JSON schema object.
+ */
+export declare function compile(model: Type<any> | JsonParameterStore | JsonSchema<any>, options?: JsonSchemaOptions): any;
+/**
+ * @deprecated Use s.compile() instead
+ * @param model
+ * @param options
+ */
+export declare const getJsonSchema: typeof compile;

package/lib/types/fn/date.d.ts

@@ -5,7 +5,7 @@
  *
  * @schemaFunctional
  */
-export declare function date(): import("../index.js").JsonSchema<Date>;
+export declare function date(): import("@tsed/schema").JsonSchema<Date>;
 /**
  * Declare a new string model with `format: datetime`.
  *
@@ -13,7 +13,7 @@ export declare function date(): import("../index.js").JsonSchema<Date>;
  *
  * @schemaFunctional
  */
-export declare function datetime(): import("../index.js").JsonSchema<Date>;
+export declare function datetime(): import("@tsed/schema").JsonSchema<Date>;
 /**
  * Declare a new string model with `format: time`.
  *
@@ -21,4 +21,4 @@ export declare function datetime(): import("../index.js").JsonSchema<Date>;
  *
  * @schemaFunctional
  */
-export declare function time(): import("../index.js").JsonSchema<Date>;
+export declare function time(): import("@tsed/schema").JsonSchema<Date>;

package/lib/types/fn/email.d.ts

@@ -12,4 +12,4 @@
  *
  * @schemaFunctional
  */
-export declare function email(): import("../index.js").JsonSchema<string>;
+export declare function email(): import("@tsed/schema").JsonSchema<string>;

package/lib/types/fn/from.d.ts

@@ -1,16 +1,44 @@
 import { Type } from "@tsed/core";
-import { JsonSchema } from "../domain/JsonSchema.js";
 import type { CtorToType } from "../domain/types.js";
+import { JsonSchema } from "../domain/JsonSchema.js";
 /**
- * Create a new model from the given type.
+ * Create a new local schema instance from the given type.
+ *
+ * When the input is a class, `from()` returns a cloned `JsonSchema` that can be
+ * composed safely without mutating the schema stored on the class metadata.
+ * This makes `from()` the functional entry point for schema composition.
+ *
+ * Use @@get@@ when you intentionally need the shared class schema in order to
+ * patch or extend the metadata attached to a class definition.
  *
  * ```typescript
  * from(String)
+ * from(UserModel).description("Local description")
  * ```
  *
- *  * See @@JsonSchema@@ to discover available methods.
+ * See @@JsonSchema@@ to discover available methods.
  *
  * @schemaFunctional
  */
 export declare function from<TC extends Type<any> = Type<any>>(): JsonSchema<CtorToType<ObjectConstructor>>;
 export declare function from<TC extends Type<any> = Type<any>>(type?: TC): JsonSchema<CtorToType<TC>>;
+/**
+ * Get the shared schema instance attached to a class.
+ *
+ * Contrary to @@from@@, `get()` returns the schema stored in the class metadata.
+ * Mutating the returned instance updates the class-level schema definition and
+ * therefore affects every consumer of that class schema.
+ *
+ * This helper is intended for low-level or internal patching scenarios where the
+ * source schema must be updated in place.
+ *
+ * ```typescript
+ * get(UserModel).properties({
+ *   name: string()
+ * });
+ * ```
+ *
+ * @param type The class owning the shared schema metadata.
+ * @returns The shared `JsonSchema` instance for the class.
+ */
+export declare function get(type: Type<any>): JsonSchema<import("json-schema").JSONSchema7Type>;

package/lib/types/fn/generic.d.ts

@@ -0,0 +1,10 @@
+import { type GenericValue, type GenericsMap } from "../domain/Generics.js";
+import { Type } from "@tsed/core";
+import { from } from "./from.js";
+export declare function generic(type?: Type<any>): {
+    of: {
+        (generics: GenericsMap): ReturnType<typeof from>;
+        (generic: GenericValue): ReturnType<typeof from>;
+        (...generics: Array<GenericValue[] | GenericValue>): ReturnType<typeof from>;
+    };
+};

package/lib/types/fn/index.d.ts

@@ -1,15 +1,21 @@
+import { array, map, record, set } from "./collection.js";
+import { date, datetime, time } from "./date.js";
+import { from, get } from "./from.js";
+import { getJsonEntityStore, getJsonMethodStore } from "../registries/JsonEntitiesContainer.js";
 import type { Infer } from "../domain/types.js";
 import { allOf } from "./allOf.js";
 import { any } from "./any.js";
 import { anyOf } from "./anyOf.js";
 import { boolean } from "./boolean.js";
-import { array, map, record, set } from "./collection.js";
-import { date, datetime, time } from "./date.js";
+import { compile } from "./compile.js";
+import { compileSpec } from "./oas/compileSpec.js";
 import { email } from "./email.js";
 import { enums } from "./enums.js";
-import { from } from "./from.js";
+import { generic } from "./generic.js";
 import { integer } from "./integer.js";
 import { lazyRef } from "./lazyRef.js";
+import { mergeSchema } from "../utils/mergeSchema.js";
+import { mergeSpec } from "./oas/mergeSpec.js";
 import { number } from "./number.js";
 import { object } from "./object.js";
 import { oneOf } from "./oneOf.js";
@@ -45,6 +51,21 @@ export declare const s: {
     readonly string: typeof string;
     readonly uri: typeof uri;
     readonly url: typeof url;
+    readonly generic: typeof generic;
+    readonly get: typeof get;
+    readonly store: typeof getJsonEntityStore & {
+        get: typeof getJsonEntityStore;
+        method: typeof getJsonMethodStore;
+    };
+    readonly schema: {
+        readonly compile: typeof compile;
+        readonly merge: typeof mergeSchema;
+    };
+    readonly compile: typeof compile;
+    readonly oas: typeof compileSpec & {
+        compile: typeof compileSpec;
+        merge: typeof mergeSpec;
+    };
 };
 export declare namespace s {
     type infer<S> = Infer<S>;

package/lib/types/fn/integer.d.ts

@@ -6,4 +6,4 @@
  * @returns A schema configured for integer values
  * @schemaFunctional
  */
-export declare function integer(): import("../index.js").JsonSchema<number>;
+export declare function integer(): import("@tsed/schema").JsonSchema<number>;

package/lib/types/fn/lazyRef.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema } from "../domain/JsonSchema.js";
+import type { JsonSchema } from "../domain/index.js";
 /**
  * Declare a sub schema which will be resolved later. Use this function when you have a circular reference between two schemes.
  *

package/lib/types/fn/number.d.ts

@@ -47,4 +47,4 @@
  *
  * @public
  */
-export declare function number(): import("../index.js").JsonSchema<number>;
+export declare function number(): import("@tsed/schema").JsonSchema<number>;

package/lib/types/fn/oas/compileSpec.d.ts

@@ -0,0 +1,6 @@
+import { type GenerateSpecOptions } from "./generateSpec.js";
+import { OpenSpec2, OpenSpec3 } from "@tsed/openspec";
+import { type SpecSerializerOptions } from "./getSpec.js";
+import { Type } from "@tsed/core";
+export declare function compileSpec(model: Type<any>, options?: SpecSerializerOptions): Partial<OpenSpec3>;
+export declare function compileSpec(options: GenerateSpecOptions): OpenSpec2 | OpenSpec3;

package/lib/types/{utils → fn/oas}/getSpec.d.ts

@@ -1,6 +1,6 @@
 import { Type } from "@tsed/core";
+import { JsonSchemaOptions } from "../../domain/JsonSchemaOptions.js";
 import { OpenSpec3 } from "@tsed/openspec";
-import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
 export type JsonTokenOptions = ({
     token: Type<any>;
 } & Partial<SpecSerializerOptions>)[];

package/lib/types/{utils → fn/oas}/getSpecType.d.ts

@@ -1,5 +1,5 @@
 import { OpenSpec2, OpenSpec3 } from "@tsed/openspec";
-import { SpecTypes } from "../domain/SpecTypes.js";
+import { SpecTypes } from "../../domain/index.js";
 /**
  * @ignore
  * @param version

package/lib/types/{utils → fn/oas}/transformToOS2.d.ts

@@ -1,4 +1,4 @@
-import { OpenSpec2, OpenSpec3, type OS2Security, OS3Operation } from "@tsed/openspec";
+import { type OS2Security, OS3Operation, OpenSpec2, OpenSpec3 } from "@tsed/openspec";
 export declare function transformSecurity(securitySchemes: any): Record<string, OS2Security>;
 export declare function transformInformation(server: any): {
     host: string | undefined;

package/lib/types/fn/object.d.ts

@@ -17,4 +17,4 @@ import { JsonSchema } from "../domain/JsonSchema.js";
  * @returns A new object model with the specified properties
  * @schemaFunctional
  */
-export declare function object<P extends Record<string, JsonSchema<any>> = Record<string, JsonSchema<any>>>(properties?: P): JsonSchema<import("../index.js").PropsToShape<P>>;
+export declare function object<P extends Record<string, JsonSchema<any>> = Record<string, JsonSchema<any>>>(properties?: P): JsonSchema<import("@tsed/schema").PropsToShape<P>>;

package/lib/types/fn/string.d.ts

@@ -45,4 +45,4 @@
  *
  * @public
  */
-export declare function string(): import("../index.js").JsonSchema<string>;
+export declare function string(): import("@tsed/schema").JsonSchema<string>;

package/lib/types/fn/uri.d.ts

@@ -5,4 +5,4 @@
  *
  * @schemaFunctional
  */
-export declare function uri(): import("../index.js").JsonSchema<string>;
+export declare function uri(): import("@tsed/schema").JsonSchema<string>;

package/lib/types/fn/url.d.ts

@@ -5,4 +5,4 @@
  *
  * @schemaFunctional
  */
-export declare function url(): import("../index.js").JsonSchema<string>;
+export declare function url(): import("@tsed/schema").JsonSchema<string>;

package/lib/types/hooks/alterOneOf.d.ts

@@ -1,3 +1,3 @@
 import type { JsonSchema } from "../domain/JsonSchema.js";
-import type { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
+import type { JsonSchemaOptions } from "../domain/JsonSchemaOptions.js";
 export declare function alterOneOf(obj: any, schema: JsonSchema, options: JsonSchemaOptions): any;

package/lib/types/hooks/alterRequiredGroups.d.ts

@@ -1,5 +1,5 @@
 import type { JsonSchema } from "../domain/JsonSchema.js";
-import type { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
+import type { JsonSchemaOptions } from "../domain/JsonSchemaOptions.js";
 /**
  * @ignore
  */