@tsed/schema 8.13.4 → 8.14.0-rc.1

package/lib/esm/fn/url.js

@@ -1,10 +1,10 @@
 import { JsonFormatTypes } from "../domain/JsonFormatTypes.js";
-import { from } from "./from.js";
+import { string } from "./string.js";
 /**
  * Declare a new string model with `format: url`.
  *
  * See @@JsonSchema@@ to discover available methods.
  */
 export function url() {
-    return from(String).format(JsonFormatTypes.URL);
+    return string().format(JsonFormatTypes.URL);
 }

package/lib/esm/index.js

@@ -1,24 +1,18 @@
 /**
  * @file Automatically generated by @tsed/barrels.
  */
-export * from "./components/async-api/channelsMapper.js";
-export * from "./components/async-api/generate.js";
-export * from "./components/async-api/messageMapper.js";
-export * from "./components/async-api/payloadMapper.js";
-export * from "./components/async-api/responseMapper.js";
 export * from "./components/default/anyMapper.js";
 export * from "./components/default/classMapper.js";
 export * from "./components/default/discriminatorMappingMapper.js";
 export * from "./components/default/enumsMapper.js";
 export * from "./components/default/genericsMapper.js";
 export * from "./components/default/inheritedClassMapper.js";
-export * from "./components/default/itemMapper.js";
 export * from "./components/default/lazyRefMapper.js";
 export * from "./components/default/mapMapper.js";
+export * from "./components/default/nextMapper.js";
 export * from "./components/default/nullableMapper.js";
 export * from "./components/default/objectMapper.js";
 export * from "./components/default/ofMapper.js";
-export * from "./components/default/propertiesMapper.js";
 export * from "./components/default/requiredMapper.js";
 export * from "./components/default/schemaMapper.js";
 export * from "./components/index.js";
@@ -38,6 +32,7 @@ export * from "./components/open-spec/pathsMapper.js";
 export * from "./constants/httpStatusMessages.js";
 export * from "./constants/jsonSchemaProperties.js";
 export * from "./constants/OperationVerbs.js";
+export * from "./constants/VendorKeys.js";
 export * from "./decorators/class/children.js";
 export * from "./decorators/class/discriminatorValue.js";
 export * from "./decorators/collections/collectionContains.js";
@@ -190,12 +185,12 @@ export * from "./utils/mapOpenSpec3.js";
 export * from "./utils/mapOpenSpecInfo.js";
 export * from "./utils/mapOperationOptions.js";
 export * from "./utils/matchGroups.js";
+export * from "./utils/mergeSchema.js";
 export * from "./utils/mergeSpec.js";
 export * from "./utils/operationIdFormatter.js";
 export * from "./utils/ref.js";
 export * from "./utils/removeHiddenOperation.js";
 export * from "./utils/serializeEnumValues.js";
-export * from "./utils/somethingOf.js";
 export * from "./utils/toJsonMapCollection.js";
 export * from "./utils/toJsonRegex.js";
 export * from "./utils/transformToOS2.js";

package/lib/esm/utils/generics.js

@@ -1,33 +1,4 @@
-/**
- * @ignore
- * @param genericLabels
- * @param genericTypes
- */
-export function getGenericsMap(genericLabels, genericTypes) {
-    return genericLabels.reduce((map, item, index) => map.set(item, genericTypes[index]), new Map());
-}
-/**
- * @ignore
- * @param options
- */
-export function mapGenericsOptions(options) {
-    if (options.genericLabels && options.genericTypes) {
-        const { genericLabels, genericTypes, ...ops } = options;
-        return {
-            ...ops,
-            generics: getGenericsMap(genericLabels, genericTypes)
-        };
-    }
-    return options;
-}
-/**
- * @ignore
- * @param value
- */
-export function popGenerics(value) {
-    const [genericTypes, ...out] = value.nestedGenerics;
-    return {
-        genericTypes,
-        nestedGenerics: out
-    };
+export function getGenericsOptions(value, options) {
+    const generics = value.getGenericOf();
+    return { generics: generics || options.generics, mapper: generics ? "schema" : "class" };
 }

package/lib/esm/utils/getJsonSchema.js

@@ -1,36 +1,51 @@
 import "../components/index.js";
-import { getValue } from "@tsed/core";
+import { getValue, isClass, isPlainObject, nameOf } from "@tsed/core";
+import { JsonParameterStore } from "../domain/JsonParameterStore.js";
 import { SpecTypes } from "../domain/SpecTypes.js";
 import { execMapper } from "../registries/JsonSchemaMapperContainer.js";
 import { getJsonEntityStore } from "./getJsonEntityStore.js";
 /**
  * @ignore
  */
-const CACHE_KEY = "$cache:schemes";
+const CACHES = new Map();
 /**
  * @ignore
  */
 function getKey(options) {
-    return JSON.stringify(options);
+    return JSON.stringify(options, (key, value) => {
+        if (value && !isPlainObject(value) && isClass(value)) {
+            return nameOf(value);
+        }
+        return value;
+    });
 }
 /**
  * @ignore
  */
-function get(entity, options) {
-    const cache = entity.store.get(CACHE_KEY) || new Map();
+function get(model, options) {
+    const cache = CACHES.get(model) || new Map();
+    CACHES.set(model, cache);
     const key = getKey(options);
     if (!cache.has(key)) {
-        const schema = execMapper("schema", [entity.schema], options);
+        const entity = getJsonEntityStore(model);
+        let mapper = "schema";
+        if (entity instanceof JsonParameterStore) {
+            options = {
+                ...options,
+                root: true,
+                groups: entity.schema.getGroups()
+            };
+            mapper = "item";
+        }
+        const schema = execMapper(mapper, [entity.schema], options);
         if (Object.keys(getValue(options, "components.schemas", {})).length) {
             schema.definitions = options.components.schemas;
         }
         cache.set(key, schema);
     }
-    entity.store.set(CACHE_KEY, cache);
     return cache.get(key);
 }
 export function getJsonSchema(model, options = {}) {
-    const entity = getJsonEntityStore(model);
     const specType = options.specType || SpecTypes.JSON;
     options = {
         endpoint: true,
@@ -42,13 +57,5 @@ export function getJsonSchema(model, options = {}) {
             schemas: {}
         }
     };
-    if (entity.decoratorType === "parameter") {
-        options = {
-            ...options,
-            genericTypes: entity.nestedGenerics[0],
-            nestedGenerics: entity.nestedGenerics,
-            groups: entity.parameter?.groups
-        };
-    }
-    return get(entity, options);
+    return get(model, options);
 }

package/lib/esm/utils/mergeSchema.js

@@ -0,0 +1,98 @@
+import { isObject, uniq } from "@tsed/core";
+function mergeProps(properties1, properties2) {
+    if (!properties1 || !properties2) {
+        return properties1 || properties2 || {};
+    }
+    const keys = [...new Set(Object.keys(properties1 || []).concat(Object.keys(properties2 || [])))];
+    return keys.reduce((acc, key) => {
+        if (properties1?.[key] && properties2?.[key]) {
+            acc[key] = mergeSchema(properties1[key], properties2[key]);
+        }
+        else if (properties1?.[key]) {
+            acc[key] = properties1[key];
+        }
+        else if (properties2?.[key]) {
+            acc[key] = properties2[key];
+        }
+        return acc;
+    }, {});
+}
+function mergeManyOf(kind, schema1, schema2) {
+    const refs = new Set();
+    if (schema1.$ref && schema2.type && (schema2.readOnly || schema2.writeOnly) && kind === "allOf") {
+        const { type, ...rest } = schema2;
+        schema2 = rest;
+    }
+    let of = [...(schema1[kind] || [schema1]), ...(schema2[kind] || [schema2])].filter((schema) => {
+        if ("$ref" in schema) {
+            if (refs.has(schema.$ref)) {
+                return false;
+            }
+            refs.add(schema.$ref);
+            return true;
+        }
+        return Object.keys(schema).length > 0;
+    });
+    if (of.length > 2) {
+        of = of.reduce((current, item, index) => {
+            if (item.$ref) {
+                return current.concat(item);
+            }
+            if (current.at(-1)?.type === item.type && item.type !== "array") {
+                current[current.length - 1] = mergeSchema(current.at(-1), item);
+                return current;
+            }
+            return current.concat(item);
+        }, []);
+    }
+    return of.length > 1
+        ? {
+            [kind]: of,
+            ...(schema1.nullable || schema2.nullable ? { nullable: true } : {})
+        }
+        : of[0];
+}
+export function mergeSchema(schema1, schema2) {
+    if (schema1.$ref && schema2.$ref && schema1.$ref === schema2.$ref) {
+        return schema1; // If both refs are the same, return one of them
+    }
+    // Handle allOf, oneOf, anyOf
+    if (schema1.allOf || schema2.allOf) {
+        return mergeManyOf("allOf", schema1, schema2);
+    }
+    if (schema1.oneOf || schema2.oneOf) {
+        const schema = mergeManyOf("oneOf", schema1, schema2);
+        if ("discriminator" in schema1 || "discriminator" in schema2) {
+            // If either schema has a discriminator, we should not merge oneOf
+            return {
+                ...schema,
+                discriminator: schema1.discriminator || schema2.discriminator,
+                required: uniq([...(schema1.required || []), ...(schema2.required || [])])
+            };
+        }
+        return schema;
+    }
+    if (schema1.anyOf || schema2.anyOf) {
+        return mergeManyOf("anyOf", schema1, schema2);
+    }
+    if (schema1.$ref || schema2.$ref) {
+        return mergeManyOf("allOf", schema1, schema2);
+    }
+    const mergedSchema = { ...schema1, ...schema2 };
+    if (schema1.properties || schema2.properties) {
+        // Handle properties
+        mergedSchema.properties = mergeProps(schema1.properties, schema2.properties);
+    }
+    if (isObject(schema1.additionalProperties) && isObject(schema2.additionalProperties)) {
+        // Right now we only merge additionalProperties if both schemas have it as an object
+        mergedSchema.additionalProperties = {
+            ...schema1.additionalProperties,
+            ...schema2.additionalProperties
+        };
+    }
+    if (schema1.required || schema2.required) {
+        // Handle required fields
+        mergedSchema.required = uniq([...(schema1.required || []), ...(schema2.required || [])]);
+    }
+    return mergedSchema;
+}

package/lib/esm/utils/ref.js

@@ -1,6 +1,15 @@
-import { cleanObject, setValue } from "@tsed/core";
+import { setValue } from "@tsed/core";
 import { pascalCase } from "change-case";
 import { SpecTypes } from "../domain/SpecTypes.js";
+import { mergeSchema } from "./mergeSchema.js";
+export function getSchemaFromRef($ref, options) {
+    const { components } = options;
+    if (components?.schemas && $ref) {
+        const host = getHost(options);
+        const refName = $ref.replace(`${host}/`, "");
+        return components.schemas[refName];
+    }
+}
 /**
  * ignore
  * @param options
@@ -23,19 +32,11 @@ export function createRefName(name, options) {
  */
 export function createRef(name, schema, options) {
     const host = getHost(options);
-    const ref = {
+    return mergeSchema({
         $ref: `${host}/${name}`
-    };
-    const readOnly = schema.isReadOnly;
-    const writeOnly = schema.isWriteOnly;
-    return cleanObject({
-        readOnly: readOnly ? true : undefined,
-        writeOnly: writeOnly ? true : undefined,
-        ...(readOnly || writeOnly
-            ? {
-                anyOf: [ref]
-            }
-            : ref)
+    }, {
+        ...(schema.isReadOnly ? { readOnly: true } : {}),
+        ...(schema.isWriteOnly ? { writeOnly: true } : {})
     });
 }
 /**

package/lib/types/components/default/classMapper.d.ts

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

package/lib/types/components/default/genericsMapper.d.ts

@@ -1,5 +1,12 @@
-import { GenericsContext } from "../../utils/generics.js";
+import type { JSONSchema7 } from "json-schema";
+import { JsonSchema } from "../../domain/JsonSchema.js";
+import type { JsonSchemaOptions } from "../../interfaces/JsonSchemaOptions.js";
 /**
  * @ignore
  */
-export declare function genericsMapper(obj: any, options: GenericsContext): any;
+export declare function genericsMapper(baseObj: JSONSchema7, schema: JsonSchema, options: JsonSchemaOptions): JSONSchema7 | {
+    allOf: (JSONSchema7 | {
+        properties: JSONSchema7;
+        type: string;
+    })[];
+};

package/lib/types/components/default/lazyRefMapper.d.ts

@@ -1,3 +1,3 @@
 import { JsonLazyRef } from "../../domain/JsonLazyRef.js";
 import { JsonSchemaOptions } from "../../interfaces/JsonSchemaOptions.js";
-export declare function lazyRefMapper(jsonLazyRef: JsonLazyRef, options: JsonSchemaOptions): any;
+export declare function lazyRefMapper(jsonLazyRef: JsonLazyRef, options: JsonSchemaOptions): import("json-schema").JSONSchema7;

package/lib/types/components/default/nextMapper.d.ts

@@ -0,0 +1,5 @@
+import { type Type } from "@tsed/core";
+import { JsonSchema } from "../../domain/JsonSchema.js";
+import type { JsonSchemaOptions } from "../../interfaces/JsonSchemaOptions.js";
+export declare function itemMapper(input: JsonSchema | Type, options: JsonSchemaOptions): any;
+export declare function nextMapper(input: JsonSchema | Type | any, options: JsonSchemaOptions): any;

package/lib/types/components/default/ofMapper.d.ts

@@ -1,3 +1,3 @@
 import type { JsonSchema } from "../../domain/JsonSchema.js";
 import type { JsonSchemaOptions } from "../../interfaces/JsonSchemaOptions.js";
-export declare function ofMapper(input: (any | JsonSchema)[], options: JsonSchemaOptions, parent: JsonSchema): any[];
+export declare function ofMapper(input: (any | JsonSchema)[], options: JsonSchemaOptions): any[];

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

@@ -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/types/components/open-spec/nullableMapper.d.ts

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

package/lib/types/components/open-spec/operationInQueryMapper.d.ts

@@ -1,2 +1,2 @@
 import type { JsonParameterOptions } from "./operationInParameterMapper.js";
-export declare function operationInQueryMapper(parameter: any, { jsonSchema, jsonParameters, ...options }: JsonParameterOptions): any;
+export declare function operationInQueryMapper(parameter: any, { jsonSchema, ...options }: JsonParameterOptions): any;

package/lib/types/constants/VendorKeys.d.ts

@@ -0,0 +1,10 @@
+export declare enum VendorKeys {
+    GENERIC_LABELS = "genericLabels",
+    GENERIC_LABEL = "genericLabel",
+    GENERIC_OF = "genericOf",
+    NULLABLE = "nullable",
+    FORWARD_GROUPS = "forwardGroups",
+    GROUPS = "groups",
+    GROUPS_NAME = "groupsName",
+    ALLOWED_GROUPS = "allowedGroups"
+}

package/lib/types/decorators/collections/collectionOf.d.ts

@@ -1,5 +1,6 @@
 export interface ArrayOfChainedDecorators {
     (...args: any): any;
+    Nested(...generics: any[]): this;
     /**
      * An array instance is valid against `minItems` if its size is greater than, or equal to, the value of this keyword.
      *
@@ -28,7 +29,6 @@ export interface ArrayOfChainedDecorators {
      * Set the type of the item collection. The possible value is String, Boolean, Number, Date, Object, Class, etc...
      *
      * The array instance will be valid against "contains" if at least one of its elements is valid against the given schema.
-     * @deprecated Since 2025-05-12. Use Contains decorator instead.
      */
     Contains(): this;
     /**

package/lib/types/decorators/generics/genericOf.d.ts

@@ -1,4 +1,7 @@
 import { GenericValue } from "../../utils/generics.js";
+/**
+ * @ignore
+ */
 export interface GenericOfChainedDecorators {
     (...args: any): any;
     /**

package/lib/types/decorators/generics/generics.d.ts

@@ -3,12 +3,12 @@
  *
  * See @@GenericOf@@ decorator for more details.
  *
- * @param generics
  * @decorator
  * @validation
  * @swagger
  * @schema
  * @input
  * @generics
+ * @param genericLabels
  */
-export declare function Generics(...generics: string[]): ClassDecorator;
+export declare function Generics(...genericLabels: string[]): ClassDecorator;

package/lib/types/decorators/operations/returns.d.ts

@@ -88,8 +88,10 @@ export interface ReturnsChainedDecorators {
     /**
      * Add an inline title for the return model.
      * @param title
+     * @deprecated use Label instead
      */
     Title(title: string): this;
+    Label(label: string): this;
     /**
      * Use group to filter model
      * @param groups
@@ -170,7 +172,7 @@ export interface ReturnsChainedDecorators {
  *
  * Deprecated version:
  *
- * ```typescript
+ * ```ts
  * import {ReturnsArray} from "@tsed/platform-http";
  * import {Returns} from "@tsed/schema";
  *
@@ -183,14 +185,14 @@ export interface ReturnsChainedDecorators {
  *
  * ### Declaring a generic model <Badge text="6+"/>
  *
- * Sometime, it might be useful to use generic models. TypeScript doesn't store the generic type in the metadata. This is why we need to
+ * Sometimes, it might be useful to use generic models. TypeScript doesn't store the generic type in the metadata. This is why we need to
  * declare explicitly the generic models with the decorators.
  *
- * One of the generic's usage, can be a paginated list. With Returns decorator it's now possible to declare generic type and generate the appropriate OpenSpec documentation.
+ * One of the generic's usage can be a paginated list. With Returns decorator it's now possible to declare a generic type and generate the appropriate OpenSpec documentation.
  *
  * Starting with the pagination model, by using @@Generics@@ and @@CollectionOf@@:
  *
- * ```typescript
+ * ```ts
  * @Generics("T")
  * class Pagination<T> {
  *  @CollectionOf("T")
@@ -213,7 +215,7 @@ export interface ReturnsChainedDecorators {
  * }
  * ```
  *
- * Finally, we can use our models on a method as following:
+ * Finally, we can use our models on a method as follows:
  *
  * ```typescript
  * class Controller {
@@ -225,11 +227,11 @@ export interface ReturnsChainedDecorators {
  * }
  * ```
  *
- * ### Declaring a nested generics models <Badge text="6+"/>
+ * ### Declaring nested generics models <Badge text="6+"/>
  *
- * It's also possible to declare a nested generics models in order to have this type `Pagination<Submission<Product>>`:
+ * It's also possible to declare a nested generics model to have this type `Pagination<Submission<Product>>`:
  *
- * ```typescript
+ * ```ts
  * import {Post, Generics, Property, Returns} from "@tsed/schema";
  *
  * class Controller {
@@ -243,7 +245,7 @@ export interface ReturnsChainedDecorators {
  *
  * And here is the Submission model:
  *
- * ```typescript
+ * ```ts
  * import {Generics, Property} from "@tsed/schema";
  *
  * @Generics("T")

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

@@ -51,16 +51,26 @@ export declare abstract class JsonEntityStore implements JsonEntityStoreOptions
     readonly isStore = true;
     readonly parent: JsonEntityStore;
     readonly target: Type<any>;
+    constructor(options: JsonEntityStoreOptions);
     /**
      *
      */
     protected _type: Type<any>;
+    [key: string]: any;
+    get type(): Type<any> | any;
+    /**
+     * Get original type without transformation
+     * @param value
+     */
+    set type(value: Type<any> | any);
     /**
      * Ref to JsonSchema
      */
     protected _schema: JsonSchema;
-    [key: string]: any;
-    constructor(options: JsonEntityStoreOptions);
+    /**
+     * Return the JsonSchema
+     */
+    get schema(): JsonSchema;
     /**
      * Return the class name of the entity.
      * @returns {string}
@@ -73,26 +83,16 @@ export declare abstract class JsonEntityStore implements JsonEntityStoreOptions
     get isDate(): boolean;
     get isObject(): boolean;
     get isClass(): boolean;
-    /**
-     * Return the JsonSchema
-     */
-    get schema(): JsonSchema;
-    get nestedGenerics(): Type<any>[][];
-    set nestedGenerics(nestedGenerics: Type<any>[][]);
-    get type(): Type<any> | any;
-    /**
-     * Get original type without transformation
-     * @param value
-     */
-    set type(value: Type<any> | any);
     /**
      * Return the itemSchema computed type. if the type is a function used for recursive model, the function will be called to
      * get the right type.
      */
-    get computedType(): any;
+    get computedType(): Type<any>;
     get itemSchema(): JsonSchema;
     get parentSchema(): JsonSchema;
     get isDiscriminatorChild(): boolean;
+    get path(): string;
+    set path(path: string);
     static from<T extends JsonClassStore = JsonClassStore>(target: Type<any>): T;
     static from<T extends JsonPropertyStore = JsonPropertyStore>(target: Type<any> | any, propertyKey: string | symbol): T;
     static from<T extends JsonParameterStore = JsonParameterStore>(target: Type<any> | any, propertyKey: string | symbol, index: number): T;
@@ -104,9 +104,11 @@ export declare abstract class JsonEntityStore implements JsonEntityStoreOptions
     get<T = any>(key: string, defaultValue?: any): T;
     set(key: string, value?: any): Store;
     toString(): string;
+    getBestType(): any;
+    is(input: DecoratorTypes.CLASS): this is JsonClassStore;
+    is(input: DecoratorTypes.PROP): this is JsonPropertyStore;
+    is(input: DecoratorTypes.METHOD): this is JsonMethodStore;
+    is(input: DecoratorTypes.PARAM): this is JsonParameterStore;
     protected abstract build(): void;
     protected buildType(type: any): void;
-    set path(path: string);
-    get path(): string;
-    getBestType(): any;
 }

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

@@ -3,9 +3,8 @@ import { JsonMap } from "./JsonMap.js";
 import { JsonSchema } from "./JsonSchema.js";
 export declare class JsonMedia extends JsonMap<OS3MediaType<JsonSchema>> {
     $kind: string;
-    groups: string[];
-    groupsName: string;
-    allowedGroups?: Set<string>;
-    schema(schema: JsonSchema): this;
-    examples(examples: any): this;
+    constructor(obj?: Partial<OS3MediaType<JsonSchema>>);
+    schema(schema?: JsonSchema): JsonSchema;
+    examples(examples?: any): this;
+    type(type: any): this;
 }

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

@@ -39,6 +39,12 @@ export declare class JsonMethodStore extends JsonEntityStore {
      * @param descriptor
      */
     static get(target: Type<any>, propertyKey: string | symbol, descriptor?: PropertyDescriptor): JsonMethodStore;
+    /**
+     * TODO must be located on JsonOperation level directly
+     * @param status
+     * @param contentType
+     * @param includes
+     */
     getResponseOptions(status: number, { contentType, includes }?: {
         contentType?: string;
         includes?: string[];
@@ -73,10 +79,11 @@ export declare class JsonMethodStore extends JsonEntityStore {
 /**
  * EndpointMetadata contains metadata about a controller and his method.
  * Each annotation (@Get, @Body...) attached to a method are stored into endpoint.
- * EndpointMetadata convert this metadata to an array which contain arguments to call an Express method.
+ * EndpointMetadata converts this metadata to an array which contain arguments to call an Express method.
  *
  * Example :
- *```typescript
+ *
+ *```ts
  * @Controller("/my-path")
  * provide MyClass {
  *

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

@@ -43,6 +43,7 @@ export declare class JsonOperation extends JsonMap<JsonOperationOptions> {
     addSecurityScopes(name: string, scopes: string[]): this;
     description(description: string): this;
     deprecated(deprecated: boolean): this;
+    addAllowedGroupsParameter(allowedGroups: string[]): this;
     parameters(parameters: JsonParameter[]): this;
     addParameter(index: number, parameter: JsonParameter): void;
     consumes(consumes: string[]): this;

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

@@ -1,16 +1,11 @@
-import { Type } from "@tsed/core";
 import { OpenSpecHash, OpenSpecRef, OS3Example, OS3Parameter } from "@tsed/openspec";
 import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
-import { NestedGenerics } from "../utils/generics.js";
 import { JsonMap } from "./JsonMap.js";
 import { JsonSchema } from "./JsonSchema.js";
-export declare class JsonParameter extends JsonMap<OS3Parameter<JsonSchema>> implements NestedGenerics {
+export declare class JsonParameter extends JsonMap<OS3Parameter<JsonSchema>> {
     $kind: string;
-    nestedGenerics: Type<any>[][];
-    groups: string[];
-    groupsName: string;
-    $schema: JsonSchema;
     expression: string;
+    constructor(obj?: Partial<OS3Parameter<JsonSchema>>);
     getName(): any;
     name(name: string): this;
     examples(examples: OpenSpecHash<OS3Example | OpenSpecRef>): this;