@tsed/schema 8.13.5 → 8.14.0

package/lib/esm/components/default/anyMapper.js

@@ -1,7 +1,6 @@
 import { JsonLazyRef } from "../../domain/JsonLazyRef.js";
 import { JsonSchema } from "../../domain/JsonSchema.js";
 import { execMapper, execOneOfMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { mapGenericsOptions } from "../../utils/generics.js";
 import { toRef } from "../../utils/ref.js";
 export function anyMapper(input, options = {}) {
     if (typeof input !== "object" || input === null) {
@@ -16,7 +15,7 @@ export function anyMapper(input, options = {}) {
     }
     if (input.$kind && input.$isJsonDocument) {
         const kind = execOneOfMapper([input.$kind, "map"], options);
-        const schema = execMapper(kind, [input], mapGenericsOptions(options));
+        const schema = execMapper(kind, [input], options);
         return input.canRef ? toRef(input, schema, options) : schema;
     }
     return execMapper("object", [input], options);

package/lib/esm/components/default/classMapper.js

@@ -1,37 +1,17 @@
 import { getValue, setValue } from "@tsed/core";
 import { JsonEntityStore } from "../../domain/JsonEntityStore.js";
 import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { mapGenericsOptions, popGenerics } from "../../utils/generics.js";
 import { createRef, createRefName } from "../../utils/ref.js";
 export function classMapper(value, options) {
     const store = JsonEntityStore.from(value.class);
     const name = createRefName(store.schema.getName() || value.getName(), options);
-    if (value.hasGenerics) {
-        // Inline generic
-        const { type, properties, additionalProperties, items, ...props } = value.toJSON(options);
-        const schema = {
-            ...execMapper("any", [store.schema], {
-                ...options,
-                ...popGenerics(value),
-                root: false
-            }),
-            ...props
-        };
-        if (schema.title) {
-            const name = createRefName(schema.title, options);
-            setValue(options.components, `schemas.${name}`, schema);
-            delete schema.title;
-            return createRef(name, value, options);
-        }
-        return schema;
-    }
     if (!getValue(options, `components.schemas.${name}`)) {
         // avoid infinite calls
         setValue(options, `components.schemas.${name}`, {});
-        options.components.schemas[name] = execMapper("any", [store.schema], mapGenericsOptions({
+        options.components.schemas[name] = execMapper("any", [store.schema], {
             ...options,
             root: false
-        }));
+        });
     }
     return createRef(name, value, options);
 }

package/lib/esm/components/default/genericsMapper.js

@@ -1,57 +1,71 @@
-import { isClass, isPrimitiveClass } from "@tsed/core";
-import { JsonEntityStore } from "../../domain/JsonEntityStore.js";
+import { isObject } from "@tsed/core";
+import { VendorKeys } from "../../constants/VendorKeys.js";
+import { JsonSchema } from "../../domain/JsonSchema.js";
 import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { popGenerics } from "../../utils/generics.js";
-import { getJsonType } from "../../utils/getJsonType.js";
+import { toRef } from "../../utils/ref.js";
+function getNestedSchema(propertyKey, schema, options) {
+    if ("isLazyRef" in schema) {
+        return null;
+    }
+    if (schema.isGeneric) {
+        const genericLabel = schema.get(VendorKeys.GENERIC_LABEL);
+        const genericValue = options.generics?.[genericLabel];
+        if (!genericValue) {
+            return null;
+        }
+        const [model, next] = genericValue;
+        const refSchema = JsonSchema.from(model);
+        const modelSchema = execMapper("schema", [refSchema], {
+            ...options,
+            generics: next
+        });
+        if (next || !refSchema.isClass) {
+            return modelSchema;
+        }
+        return toRef(refSchema, modelSchema, options);
+    }
+    if (schema?.has("items")) {
+        const nestedSchema = getNestedSchema(propertyKey, schema.get("items"), options);
+        if (nestedSchema) {
+            return {
+                type: "array",
+                items: nestedSchema
+            };
+        }
+    }
+    if (schema.has("additionalProperties") && isObject(schema.get("additionalProperties"))) {
+        const nestedSchema = getNestedSchema(propertyKey, schema.get("additionalProperties"), options);
+        if (nestedSchema) {
+            return {
+                type: "object",
+                additionalProperties: nestedSchema
+            };
+        }
+    }
+    return null;
+}
 /**
  * @ignore
  */
-export function genericsMapper(obj, options) {
-    const { generics } = options;
-    if (generics && obj.$ref) {
-        if (generics.has(obj.$ref)) {
-            let type = generics.get(obj.$ref);
-            if (isPrimitiveClass(type)) {
-                return {
-                    type: getJsonType(type)
-                };
-            }
-            if (type === Date) {
-                return {
-                    type: "string",
-                    format: "date-time"
-                };
-            }
-            if (type.toJSON) {
-                return type.toJSON({
-                    ...options,
-                    generics: undefined
-                });
-            }
-            if (type === Object) {
-                return {
-                    type: "object"
-                };
-            }
-            if (isClass(type)) {
-                const model = {
-                    class: type
-                };
-                if (options.nestedGenerics.length === 0) {
-                    return execMapper("class", [model], {
-                        ...options,
-                        generics: undefined
-                    });
-                }
-                const store = JsonEntityStore.from(model.class);
-                return execMapper("schema", [store.schema], {
-                    ...options,
-                    ...popGenerics(options),
-                    root: false
-                });
+export function genericsMapper(baseObj, schema, options) {
+    if (schema.genericLabels?.length && schema.has("properties")) {
+        const properties = schema.get("properties");
+        let hasProps = false;
+        const additionalObj = Object.entries(properties || {}).reduce((obj, [propertyKey, jsonSchema]) => {
+            const nestedSchema = getNestedSchema(propertyKey, jsonSchema, options);
+            if (nestedSchema) {
+                obj[propertyKey] = nestedSchema;
+                hasProps = true;
             }
+            return obj;
+        }, {});
+        if (hasProps) {
+            return {
+                allOf: [toRef(schema, baseObj, options), { properties: additionalObj, type: "object" }]
+            };
         }
+        return baseObj;
     }
-    return obj;
+    return baseObj;
 }
 registerJsonSchemaMapper("generics", genericsMapper);

package/lib/esm/components/default/lazyRefMapper.js

@@ -1,5 +1,4 @@
 import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { mapGenericsOptions } from "../../utils/generics.js";
 import { createRef, toRef } from "../../utils/ref.js";
 export function lazyRefMapper(jsonLazyRef, options) {
     const name = jsonLazyRef.name;
@@ -7,7 +6,7 @@ export function lazyRefMapper(jsonLazyRef, options) {
         return createRef(name, jsonLazyRef.schema, options);
     }
     options.$refs = [...(options.$refs || []), jsonLazyRef.target];
-    const schema = jsonLazyRef.getType() && execMapper("schema", [jsonLazyRef.schema], mapGenericsOptions(options));
+    const schema = jsonLazyRef.getType() && execMapper("schema", [jsonLazyRef.schema], options);
     return toRef(jsonLazyRef.schema, schema, options);
 }
 registerJsonSchemaMapper("lazyRef", lazyRefMapper);

package/lib/esm/components/default/mapMapper.js

@@ -1,5 +1,4 @@
 import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { mapGenericsOptions } from "../../utils/generics.js";
 /**
  * Serialize class which inherit from Map like JsonMap, JsonOperation, JsonParameter.
  * @param input
@@ -8,7 +7,6 @@ import { mapGenericsOptions } from "../../utils/generics.js";
  * @ignore
  */
 export function mapMapper(input, { ignore = [], ...options } = {}) {
-    options = mapGenericsOptions(options);
     return Array.from(input.entries()).reduce((obj, [key, value]) => {
         if (ignore.includes(key)) {
             return obj;

package/lib/esm/components/default/nextMapper.js

@@ -0,0 +1,74 @@
+import { JsonSchema } from "../../domain/JsonSchema.js";
+import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
+import { getGenericsOptions } from "../../utils/generics.js";
+import { mergeSchema } from "../../utils/mergeSchema.js";
+function getMapper(input, mapper, root) {
+    if (input.isClass && !input.isLocalSchema && !root) {
+        return mapper || "class";
+    }
+    return "any";
+}
+function buildAndMergeSchemas(mapper, schema1, schema2, options) {
+    const schema = execMapper(getMapper(schema2, mapper, options.root), [schema2], {
+        ...options,
+        root: false,
+        mapper: mapper === "next" ? options.mapper : undefined
+    });
+    let extraSchema = execMapper(options.root ? "any" : mapper, [schema1], {
+        ...options,
+        root: false,
+        generics: undefined,
+        mapper: mapper === "next" ? options.mapper : undefined
+    });
+    if ((schema.$ref || schema.allOf) && extraSchema.type && Object.keys(extraSchema).length === 1) {
+        extraSchema = {};
+    }
+    if (schema1.canRef) {
+        const name = extraSchema.$ref.split("/").pop();
+        const titleSchema = options.components.schemas[name];
+        options.components.schemas[name] = mergeSchema(schema, titleSchema);
+        return extraSchema;
+    }
+    return mergeSchema(schema, extraSchema);
+}
+export function itemMapper(input, options) {
+    if (input && input instanceof JsonSchema) {
+        if (!input.isCollection && input?.itemSchema?.()) {
+            const { generics, mapper } = getGenericsOptions(input, options);
+            const schema1 = input;
+            const schema2 = input.itemSchema();
+            return buildAndMergeSchemas("next", schema1, schema2, { ...options, generics, mapper });
+        }
+    }
+    return execMapper("next", [input], options);
+}
+export function nextMapper(input, options) {
+    if (input && input instanceof JsonSchema && !input.isLocalSchema) {
+        const refSchema = input.getRefSchema();
+        if (refSchema) {
+            let { generics, mapper } = getGenericsOptions(input, options);
+            mapper = getMapper(input, mapper);
+            return buildAndMergeSchemas(mapper, input, refSchema, {
+                ...options,
+                generics
+            });
+        }
+    }
+    return execMapper(getMapper(input, options.mapper), [input], {
+        ...options,
+        root: false,
+        mapper: undefined
+    });
+}
+registerJsonSchemaMapper("item", itemMapper);
+registerJsonSchemaMapper("next", nextMapper);
+registerJsonSchemaMapper("properties", nextMapper);
+registerJsonSchemaMapper("items", nextMapper);
+registerJsonSchemaMapper("additionalProperties", nextMapper);
+registerJsonSchemaMapper("propertyNames", nextMapper);
+registerJsonSchemaMapper("contains", nextMapper);
+registerJsonSchemaMapper("dependencies", nextMapper);
+registerJsonSchemaMapper("patternProperties", nextMapper);
+registerJsonSchemaMapper("additionalItems", nextMapper);
+registerJsonSchemaMapper("not", nextMapper);
+registerJsonSchemaMapper("definitions", nextMapper);

package/lib/esm/components/default/objectMapper.js

@@ -1,4 +1,5 @@
 import { isArray } from "@tsed/core";
+import { VendorKeys } from "../../constants/VendorKeys.js";
 import { alterIgnore } from "../../hooks/alterIgnore.js";
 import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
 /**
@@ -8,16 +9,20 @@ import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchem
  * @ignore
  */
 export function objectMapper(input, options) {
-    const { specType, operationIdFormatter, root, components, genericTypes, nestedGenerics, useAlias, genericLabels, ...ctx } = options;
+    const { specType, operationIdFormatter, root, components, useAlias, ...ctx } = options;
     return Object.entries(input).reduce((obj, [key, value]) => {
         if (options.withIgnoredProps !== false && !alterIgnore(value, ctx)) {
             const opts = {
                 ...options,
-                groups: input?.$forwardGroups || value?.$forwardGroups ? options.groups : undefined
+                parent: value,
+                groups: input?.get?.(VendorKeys.FORWARD_GROUPS) || value?.get?.(VendorKeys.FORWARD_GROUPS) ? options.groups : undefined
             };
-            // remove groups to avoid bad schema generation over children models
             obj[key] = execMapper("item", [value], opts);
             obj[key] = execMapper("nullable", [obj[key], value], opts);
+            if (value.isGeneric && obj[key]?.type) {
+                const { type, ...rest } = obj[key];
+                obj[key] = rest;
+            }
         }
         return obj;
     }, isArray(input) ? [] : {});

package/lib/esm/components/default/ofMapper.js

@@ -1,10 +1,7 @@
 import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-export function ofMapper(input, options, parent) {
+export function ofMapper(input, options) {
     return input.map((value) => {
-        return execMapper("item", [value], {
-            ...options,
-            genericLabels: parent.genericLabels
-        });
+        return execMapper("item", [value], options);
     });
 }
 registerJsonSchemaMapper("anyOf", ofMapper);

package/lib/esm/components/default/requiredMapper.js

@@ -14,7 +14,7 @@ function mapRequiredProps(obj, schema, options = {}) {
 }
 function extractRequiredProps(obj, schema, options) {
     let required = obj.required || [];
-    required = [...required, ...schema.$required];
+    required = [...required, ...schema.getRequiredFields()];
     if (schema.get("properties")) {
         required = Object.entries(schema.get("properties")).reduce((required, [key, prop]) => {
             if (prop && prop.$selfRequired !== undefined) {
@@ -26,7 +26,7 @@ function extractRequiredProps(obj, schema, options) {
     return alterRequiredGroups(uniq(required), schema, options);
 }
 export function requiredMapper(obj, schema, options) {
-    if (options.groups && options.groups.includes("partial")) {
+    if (options.groups && options.groups?.includes("partial")) {
         if (obj.discriminator) {
             return {
                 ...obj,

package/lib/esm/components/default/schemaMapper.js

@@ -13,6 +13,7 @@ const IGNORES = ["name", "$required", "$hooks", "_nestedGenerics", SpecTypes.OPE
 const IGNORES_OPENSPEC = [];
 /**
  * @ignore
+ * TODO check if we can remove this
  */
 function isEmptyProperties(key, value) {
     return typeof value === "object" && ["items", "properties", "additionalProperties"].includes(key) && Object.keys(value).length === 0;
@@ -28,7 +29,8 @@ function shouldMapAlias(key, value, useAlias) {
  */
 function shouldSkipKey(key, { specType = SpecTypes.JSON, customKeys = false }) {
     return (IGNORES.includes(key) ||
-        (key.startsWith("#") && (customKeys === false || specType !== SpecTypes.JSON)) ||
+        key.startsWith("x-") ||
+        (key.startsWith("#") && (!customKeys || specType !== SpecTypes.JSON)) ||
         (specType !== SpecTypes.JSON && IGNORES_OPENSPEC.includes(key)));
 }
 function isExample(key, value, options) {
@@ -81,17 +83,13 @@ function mapKeys(schema, options) {
 }
 function serializeSchema(schema, options) {
     let obj = mapKeys(schema, options);
-    if (schema.isClass) {
+    if (schema.isClass && !schema.isLocalSchema) {
         obj = execMapper("inheritedClass", [obj], {
             ...options,
             root: false,
-            target: schema.getComputedType()
+            target: schema.class
         });
     }
-    obj = execMapper("generics", [obj], {
-        ...options,
-        root: false
-    });
     if (schema.has(options.specType)) {
         obj = {
             ...obj,
@@ -106,6 +104,7 @@ function serializeSchema(schema, options) {
     obj = alterOneOf(obj, schema, options);
     obj = execMapper("enums", [obj, schema], options);
     obj = execMapper("discriminatorMapping", [obj, schema], options);
+    obj = execMapper("generics", [obj, schema], options);
     return obj;
 }
 export function schemaMapper(schema, opts) {

package/lib/esm/components/index.js

@@ -1,24 +1,18 @@
 /**
  * @file Automatically generated by @tsed/barrels.
  */
-export * from "./async-api/channelsMapper.js";
-export * from "./async-api/generate.js";
-export * from "./async-api/messageMapper.js";
-export * from "./async-api/payloadMapper.js";
-export * from "./async-api/responseMapper.js";
 export * from "./default/anyMapper.js";
 export * from "./default/classMapper.js";
 export * from "./default/discriminatorMappingMapper.js";
 export * from "./default/enumsMapper.js";
 export * from "./default/genericsMapper.js";
 export * from "./default/inheritedClassMapper.js";
-export * from "./default/itemMapper.js";
 export * from "./default/lazyRefMapper.js";
 export * from "./default/mapMapper.js";
+export * from "./default/nextMapper.js";
 export * from "./default/nullableMapper.js";
 export * from "./default/objectMapper.js";
 export * from "./default/ofMapper.js";
-export * from "./default/propertiesMapper.js";
 export * from "./default/requiredMapper.js";
 export * from "./default/schemaMapper.js";
 export * from "./open-spec/discriminatorMappingMapper.js";

package/lib/esm/components/open-spec/nullableMapper.js

@@ -1,10 +1,14 @@
 import { cleanObject } from "@tsed/core";
 import { SpecTypes } from "../../domain/SpecTypes.js";
 import { registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-export function nullableMapperOpenApi(obj, schema) {
+import { nullableMapper } from "../default/nullableMapper.js";
+export function nullableMapperOpenApi(obj, schema, options) {
     if (!schema?.isNullable) {
         return obj;
     }
+    if (options.specVersion === "3.1.0") {
+        return nullableMapper(obj, schema);
+    }
     if (obj.$ref) {
         return cleanObject({
             ...obj,

package/lib/esm/components/open-spec/operationInParameterMapper.js

@@ -1,22 +1,18 @@
 import { camelCase } from "change-case";
 import { JsonParameterTypes } from "../../domain/JsonParameterTypes.js";
 import { execMapper, hasMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { popGenerics } from "../../utils/generics.js";
 function mapOptions(parameter, options = {}) {
     return {
         ...options,
-        groups: parameter.groups,
-        groupsName: parameter.groupsName
+        groups: parameter.schema().getGroups(),
+        groupsName: parameter.schema().getGroupsName()
     };
 }
 export function operationInParameterMapper(jsonParameter, opts) {
     const options = mapOptions(jsonParameter, opts);
     const schemas = { ...(options.components?.schemas || {}) };
     const { type, schema, ...parameter } = execMapper("map", [jsonParameter], options);
-    const jsonSchema = execMapper("item", [jsonParameter.$schema], {
-        ...options,
-        ...popGenerics(jsonParameter)
-    });
+    const jsonSchema = execMapper("item", [jsonParameter.schema()], options);
     parameter.required = parameter.required || jsonParameter.get("in") === JsonParameterTypes.PATH;
     const paramOpts = {
         ...options,

package/lib/esm/components/open-spec/operationInQueryMapper.js

@@ -1,6 +1,6 @@
 import { cleanObject } from "@tsed/core";
 import { registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { createRefName } from "../../utils/ref.js";
+import { createRefName, getSchemaFromRef } from "../../utils/ref.js";
 function buildExamples(property, examples) {
     if (!examples) {
         return undefined;
@@ -23,32 +23,37 @@ function buildExamples(property, examples) {
     return hasKey ? newExamples : undefined;
 }
 function inlineReference(parameter, { jsonParameter, ...options }) {
-    const name = createRefName(jsonParameter.$schema.getName(), options);
+    const name = createRefName(jsonParameter.schema().itemSchema().getName(), options);
     const schema = options.components?.schemas?.[name];
     if (schema && !options.oldSchemas?.[name]) {
-        delete options.components.schemas[jsonParameter.$schema.getName()];
+        delete options.components?.schemas?.[jsonParameter.schema().itemSchema().getName()];
     }
     return Object.entries(schema?.properties || {}).reduce((params, [key, { description, ...prop }]) => {
-        return [
-            ...params,
-            cleanObject({
-                ...parameter,
-                name: key,
-                required: (schema?.required || []).includes(key),
-                description,
-                schema: prop,
-                style: prop.$ref ? "deepObject" : undefined,
-                examples: buildExamples(key, parameter.examples)
-            })
-        ];
+        const style = parameter.style || (prop.$ref && !getSchemaFromRef(prop.$ref, options)?.enum) ? "deepObject" : undefined;
+        params.push(cleanObject({
+            ...parameter,
+            style,
+            explode: style === "deepObject" ? true : parameter.explode,
+            name: key,
+            required: (schema?.required || []).includes(key),
+            description,
+            schema: prop,
+            examples: buildExamples(key, parameter.examples)
+        }));
+        return params;
     }, []);
 }
-export function operationInQueryMapper(parameter, { jsonSchema, jsonParameters, ...options }) {
+export function operationInQueryMapper(parameter, { jsonSchema, ...options }) {
     if (jsonSchema.$ref) {
         if (!parameter.name) {
             return inlineReference(parameter, options);
         }
-        parameter.style = "deepObject";
+        const schema = getSchemaFromRef(jsonSchema.$ref, options);
+        // if the reference is an enum, we don't need to set the style or explode
+        if (!schema?.enum) {
+            parameter.style = "deepObject";
+            parameter.explode = true;
+        }
     }
     parameter.schema = jsonSchema;
     return parameter;

package/lib/esm/components/open-spec/operationMediaMapper.js

@@ -1,6 +1,9 @@
 import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
 export function operationMediaMapper(jsonMedia, options) {
-    let groups = [...(jsonMedia.groups || [])];
-    return execMapper("map", [jsonMedia], { ...options, groups, groupsName: jsonMedia.groupsName });
+    return execMapper("map", [jsonMedia], {
+        ...options,
+        groups: [...(jsonMedia.schema().getGroups() || [])],
+        groupsName: jsonMedia.schema().getGroupsName()
+    });
 }
 registerJsonSchemaMapper("operationMedia", operationMediaMapper);

package/lib/esm/components/open-spec/operationRequestBodyMapper.js

@@ -46,9 +46,9 @@ function buildSchemaFromBodyParameters(parameters, options) {
         delete props.description;
     }
     return {
-        schema: schema.toJSON(options),
         required: false,
-        ...props
+        ...props,
+        schema: schema.toJSON(options)
     };
 }
 export function operationRequestBodyMapper(bodyParameters, { consumes, ...options }) {

package/lib/esm/constants/VendorKeys.js

@@ -0,0 +1,11 @@
+export var VendorKeys;
+(function (VendorKeys) {
+    VendorKeys["GENERIC_LABELS"] = "genericLabels";
+    VendorKeys["GENERIC_LABEL"] = "genericLabel";
+    VendorKeys["GENERIC_OF"] = "genericOf";
+    VendorKeys["NULLABLE"] = "nullable";
+    VendorKeys["FORWARD_GROUPS"] = "forwardGroups";
+    VendorKeys["GROUPS"] = "groups";
+    VendorKeys["GROUPS_NAME"] = "groupsName";
+    VendorKeys["ALLOWED_GROUPS"] = "allowedGroups";
+})(VendorKeys || (VendorKeys = {}));

package/lib/esm/decorators/collections/collectionOf.js

@@ -1,3 +1,4 @@
+import { DecoratorTypes } from "@tsed/core";
 import { JsonEntityStore } from "../../domain/JsonEntityStore.js";
 /**
  * Set the type of the item collection. The possible value is String, Boolean, Number, Date, Object, Class, etc...
@@ -37,6 +38,7 @@ export function CollectionOf(type, collectionType) {
     }
     const schema = {};
     let contains = false;
+    const nestedGenerics = [];
     const decorator = (...args) => {
         const store = JsonEntityStore.from(...args);
         if (collectionType) {
@@ -46,6 +48,14 @@ export function CollectionOf(type, collectionType) {
         store.type = type;
         store.itemSchema.type(type);
         store.schema.assign(schema);
+        if (nestedGenerics.length) {
+            if (store.is(DecoratorTypes.PARAM)) {
+                store.parameter.itemSchema().genericOf(...nestedGenerics);
+            }
+            else {
+                store.itemSchema.genericOf(...nestedGenerics);
+            }
+        }
         if (store.isArray && contains) {
             store.schema.set("contains", store.schema.get("items"));
             store.schema.delete("items");
@@ -79,9 +89,6 @@ export function CollectionOf(type, collectionType) {
         schema.maxProperties = maxProperties;
         return decorator;
     };
-    /**
-     * @deprecated Since 2025-05-12. Use Contains decorator instead.
-     */
     decorator.Contains = () => {
         contains = true;
         return decorator;
@@ -93,6 +100,10 @@ export function CollectionOf(type, collectionType) {
         schema.uniqueItems = uniqueItems;
         return decorator;
     };
+    decorator.Nested = (...generics) => {
+        nestedGenerics.push(generics);
+        return decorator;
+    };
     return decorator;
 }
 /**

package/lib/esm/decorators/common/description.js

@@ -1,4 +1,4 @@
-import { decoratorTypeOf, DecoratorTypes } from "@tsed/core";
+import { DecoratorTypes } from "@tsed/core";
 import { JsonEntityFn } from "./jsonEntityFn.js";
 /**
  * Add a description to the class, method or property
@@ -54,17 +54,14 @@ import { JsonEntityFn } from "./jsonEntityFn.js";
  */
 export function Description(description) {
     return JsonEntityFn((store, args) => {
-        switch (decoratorTypeOf(args)) {
-            case DecoratorTypes.PROP:
-            case DecoratorTypes.CLASS:
-                store.schema.description(description);
-                break;
-            case DecoratorTypes.PARAM:
-                store.parameter.description(description);
-                break;
-            case DecoratorTypes.METHOD:
-                store.operation?.description(description);
-                break;
+        if (store.is(DecoratorTypes.PROP) || store.is(DecoratorTypes.CLASS)) {
+            store.schema.description(description);
+        }
+        else if (store.is(DecoratorTypes.PARAM)) {
+            store.parameter.description(description);
+        }
+        else if (store.is(DecoratorTypes.METHOD)) {
+            store.operation?.description(description);
         }
     });
 }

package/lib/esm/decorators/common/discriminatorKey.js

@@ -3,6 +3,6 @@ import { JsonEntityFn } from "./jsonEntityFn.js";
 import { Property } from "./property.js";
 export function DiscriminatorKey() {
     return useDecorators(Property(), JsonEntityFn((store) => {
-        store.discriminatorKey();
+        store.parent.schema.discriminatorKey(String(store.propertyKey));
     }));
 }