@tsed/schema 8.0.0-alpha.1 → 8.0.0-alpha.11

package/lib/types-esm/decorators/operations/operation.d.ts

@@ -1,60 +0,0 @@
-import { OperationVerbs } from "../../constants/OperationVerbs.js";
-export interface RouteChainedDecorators {
-    <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
-    /**
-     * @param string
-     * @constructor
-     */
-    Path(string: string): this;
-    /**
-     * Set the operation method
-     * @param method
-     */
-    Method(method: OperationVerbs | string): this;
-    /**
-     * Set the operation id
-     * @param id
-     */
-    Id(id: string): this;
-    /**
-     * Set the operation id
-     * @param name
-     */
-    Name(name: string): this;
-    /**
-     *
-     * @param description
-     */
-    Description(description: string): this;
-    /**
-     * Summary
-     * @constructor
-     * @param Summary
-     */
-    Summary(Summary: string): this;
-    Use(...args: any[]): this;
-    UseAfter(...args: any[]): this;
-    UseBefore(...args: any[]): this;
-}
-/**
- * Describe a new route with a method and path.
- *
- * ```typescript
- * @Controller('/')
- * export class Ctrl {
- *
- *    @Route('GET', '/')
- *    get() { }
- * }
- *
- * ```
- *
- * @returns {Function}
- * @param method
- * @param path
- * @param args
- * @decorator
- * @operation
- */
-export declare function Operation(method: string, path: string, ...args: any[]): RouteChainedDecorators;
-export declare function Operation(...args: any[]): RouteChainedDecorators;

package/lib/types-esm/decorators/operations/operationId.d.ts

@@ -1,10 +0,0 @@
-/**
- * Set a swagger operationId explicitly.
- *
- * @param operationId
- * @decorator
- * @swagger
- * @schema
- * @operation
- */
-export declare function OperationId(operationId: string): (...args: any[]) => any;

package/lib/types-esm/decorators/operations/operationPath.d.ts

@@ -1,21 +0,0 @@
-import { OperationVerbs } from "../../constants/OperationVerbs.js";
-/**
- * Declare new Operation with his path and http method.
- *
- * ::: warning
- * Don't use decorator with Ts.ED application.
- *
- * Use theses decorators instead:
- *
- * <ApiList query="status.includes('decorator') && status.includes('httpMethod')" />
- *
- * :::
- *
- * @param method
- * @param path
- * @decorator
- * @swagger
- * @schema
- * @operation
- */
-export declare function OperationPath(method: OperationVerbs | string, path?: string | RegExp): (...args: any[]) => any;

package/lib/types-esm/decorators/operations/partial.d.ts

@@ -1,10 +0,0 @@
-/**
- * Apply Partial group strategy on the input model
- *
- * @decorator
- * @validation
- * @swagger
- * @schema
- * @input
- */
-export declare function Partial(): ParameterDecorator;

package/lib/types-esm/decorators/operations/path.d.ts

@@ -1,15 +0,0 @@
-/**
- * Set class path to expose all endpoints
- *
- * ::: warning
- * Don't use this decorator to change the path if you develop your application with Ts.ED.
- * :::
- *
- * @param path
- * @decorator
- * @swagger
- * @schema
- * @classDecorator
- * @operation
- */
-export declare function Path(path: string): (...args: any[]) => any;

package/lib/types-esm/decorators/operations/produces.d.ts

@@ -1,26 +0,0 @@
-/**
- * Add produces metadata on the decorated element.
- *
- * ## Examples
- * ### On method
- *
- * ```typescript
- * class Model {
- *    @Produces("text/html")
- *    id: string;
- * }
- * ```
- *
- * ::: warning
- * For openspec v3 prefer `@Returns().ContentType()` usage (see @@Returns@@).
- * :::
- *
- * @param produces
- * @decorator
- * @swagger
- * @methodDecorator
- * @classDecorator
- * @operation
- * @response
- */
-export declare function Produces(...produces: string[]): (...args: any[]) => any;

package/lib/types-esm/decorators/operations/publish.d.ts

@@ -1 +0,0 @@
-export declare function Publish(event: string): import("./operation.js").RouteChainedDecorators;

package/lib/types-esm/decorators/operations/redirect.d.ts

@@ -1,52 +0,0 @@
-import { JsonHeader } from "../../interfaces/JsonOpenSpec.js";
-/**
- * Redirects to the URL derived from the specified path, with specified status, a positive integer that corresponds to an HTTP status code . If not specified, status defaults to “302 “Found”.
- *
- * ```typescript
- *  @Redirect('/foo/bar')
- *  @Redirect(301, 'http://example.com').Type(Model)
- *  private myMethod() {}
- * ```
- * Redirects can be a fully-qualified URL for redirecting to a different site:
- *
- * ```typescript
- *  @Redirect('http://google.com');
- *  private myMethod() {}
- * ```
- *
- * Redirects can be relative to the root of the host name. For example, if the application is on http://example.com/admin/post/new, the following would redirect to the URL http://example.com/admin:
- *
- * ```typescript
- *  @Redirect('/admin');
- * ```
- * Redirects can be relative to the current URL. For example, from http://example.com/blog/admin/ (notice the trailing slash), the following would redirect to the URL http://example.com/blog/admin/post/new.
- *
- * ```typescript
- *  @Redirect('post/new');
- * ```
- *
- * Redirecting to post/new from http://example.com/blog/admin (no trailing slash), will redirect to http://example.com/blog/post/new.
- *
- * If you found the above behavior confusing, think of path segments as directories (with trailing slashes) and files, it will start to make sense.
- *
- * Path-relative redirects are also possible. If you were on http://example.com/admin/post/new, the following would redirect to http//example.com/admin/post:
- *
- * ```typescript
- *  @Redirect('..');
- * ``
- *
- * A back redirection redirects the request back to the referer, defaulting to / when the referer is missing.
- *
- * ```typescript
- *  @Redirect('back');
- * ```
- *
- * @param url
- * @param meta
- * @decorator
- * @operation
- * @response
- * @headers
- */
-export declare function Redirect(url: string, meta?: JsonHeader): Function;
-export declare function Redirect(status: number, url: string, meta?: JsonHeader): Function;

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

@@ -1,267 +0,0 @@
-import { Type } from "@tsed/core";
-import { OS3Example } from "@tsed/openspec";
-import { JsonSchema, JsonSchemaObject } from "../../domain/JsonSchema.js";
-import { JsonHeader, JsonHeaders } from "../../interfaces/JsonOpenSpec.js";
-import { GenericValue } from "../../utils/generics.js";
-export interface ReturnsChainedDecorators {
-    <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
-    (target: Function): void;
-    /**
-     * Set a Content-Type for the current response
-     * @param value
-     * @constructor
-     */
-    ContentType(value: string): this;
-    /**
-     * Add a description
-     * @param description
-     */
-    Description(description: string): this;
-    /**
-     * Add examples
-     * @param examples
-     */
-    Examples(examples: Record<string, OS3Example>): this;
-    Examples(examples: Record<string, any>): this;
-    Examples(examples: any): this;
-    /**
-     * Change the model type
-     * @param type
-     */
-    Type(type: Type<any> | any): this;
-    /**
-     * Change the status
-     * @param status
-     * @constructor
-     */
-    Status(status: string | number): this;
-    /**
-     * Add the nested types
-     * @param types
-     */
-    Of(...types: GenericValue[]): this;
-    /**
-     * For the integer type
-     */
-    OfInteger(): this;
-    /**
-     * Add the nested types
-     * @param types
-     */
-    OneOf(...types: GenericValue[]): this;
-    /**
-     * Add the nested types
-     * @param types
-     */
-    AllOf(...types: GenericValue[]): this;
-    /**
-     * Add the nested types
-     * @param types
-     */
-    AnyOf(...types: GenericValue[]): this;
-    /**
-     * Declare a nested generic models
-     * @param generics
-     */
-    Nested(...generics: GenericValue[]): this;
-    /**
-     * Add header.
-     * @param key
-     * @param value
-     */
-    Header(key: string, value?: number | string | (JsonHeader & {
-        value?: string | number | boolean;
-    })): this;
-    /**
-     * Add headers
-     */
-    Headers(headers: JsonHeaders): this;
-    /**
-     * Add location hea
-     */
-    Location(location: string, meta?: JsonHeader): this;
-    /**
-     * Assign partial schema
-     * @param schema
-     */
-    Schema(schema: Partial<JsonSchemaObject> | JsonSchema): this;
-    /**
-     * Add an inline title for the return model.
-     * @param title
-     */
-    Title(title: string): this;
-    /**
-     * Use group to filter model
-     * @param groups
-     */
-    Groups(...groups: string[]): this;
-    Groups(groupName: string, groups: string[]): this;
-    /**
-     * Add a list of allowed groups to filter dynamically fields. Listed groups can be used by the consumer to change
-     * the mapped response.
-     * @param allowedGroups
-     */
-    AllowedGroups(...allowedGroups: string[]): this;
-    /**
-     * Apply the application/octet-stream and binary format on Open API documentation
-     */
-    Binary(): this;
-    [key: string]: any;
-}
-/**
- * Add responses documentation for a specific status code.
- *
- * ## Usage
- *
- * Ts.ED v5/v6 API introducing the chaining decorator concept. Now a decorator like Returns can be used with another decorators like Description.
- *
- * ::: warning
- * v5 has a basic support of the chaining decorator to facilitate the migration to v6!
- * :::
- *
- * ```typescript
- * import {Returns} from "@tsed/schema";
- *
- * @Controller("/")
- * class MyController {
- *   @Returns(404, String).Description("Not Found")
- *   @Returns(200, Model).Description("Success")
- *   async myMethod(): Promise<Model> {}
- * }
- * ```
- *
- * ::: tip
- * TypeScript and your IDE will discover automatically the chained decorators. But for more details you can look on @@ReturnsChainedDecorators@@ interface, to know
- * what chained decorators are available under Returns decorator.
- * :::
- *
- * This example will produce this documentation in swagger:
- *
- * ```json
- * {
- *   "responses": {
- *     "404": {
- *       "description": "Description",
- *       "schema": {"type": "string"}
- *     },
- *     "2OO": {
- *       "description": "Description",
- *       "schema": {"$ref": "..."}
- *     }
- *   }
- * }
- * ```
- *
- * ## Declaring an Array
- *
- * Use chained decorators to declare an array with model as following:
- *
- * ```typescript
- * import {Returns} from "@tsed/schema";
- *
- * @Controller("/models")
- * class ModelCtrl {
- *   @Get("/")
- *   @Returns(200, Array).Of(Model).Description("Success")
- *   async myMethod(): Promise<Model>  {
- *   }
- * }
- * ```
- *
- * Deprecated version:
- *
- * ```typescript
- * import {ReturnsArray} from "@tsed/common";
- * import {Returns} from "@tsed/schema";
- *
- * @Controller("/")
- * class MyController {
- *   @ReturnsArray(200, Model) // deprecated
- *   async myMethod(): Promise<Model> {}
- * }
- * ```
- *
- * ### 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
- * 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.
- *
- * Starting with the pagination model, by using @@Generics@@ and @@CollectionOf@@:
- *
- * ```typescript
- * @Generics("T")
- * class Pagination<T> {
- *  @CollectionOf("T")
- *  data: T[];
- *
- *  @Property()
- *  totalCount: number;
- * }
- * ```
- *
- * Now, we need a model to be used with the generic Pagination model:
- *
- * ```typescript
- * class Product {
- *  @Property()
- *  id: string;
- *
- *  @Property()
- *  title: string;
- * }
- * ```
- *
- * Finally, we can use our models on a method as following:
- *
- * ```typescript
- * class Controller {
- *   @OperationPath("POST", "/")
- *   @Returns(200, Pagination).Of(Product).Description("description")
- *   async method(): Promise<Pagination<Product> | null> {
- *     return null;
- *   }
- * }
- * ```
- *
- * ### Declaring a 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>>`:
- *
- * ```typescript
- * import {Generics, Property, Returns} from "@tsed/schema";
- * import {Post} from "@tsed/common";
- *
- * class Controller {
- *   @Post("/")
- *   @Returns(200, Pagination).Of(Submission).Nested(Product).Description("description")
- *   async method(): Promise<Pagination<Submission<Product>> | null> {
- *     return null;
- *   }
- * }
- * ```
- *
- * And here is the Submission model:
- *
- * ```typescript
- * import {Generics, Property} from "@tsed/schema";
- *
- * @Generics("T")
- * class Submission<T> {
- *   @Property()
- *   _id: string;
- *   @Property("T")
- *   data: T;
- * }
- * ```
- *
- * @param status
- * @param model
- * @decorator
- * @swagger
- * @schema
- * @response
- * @operation
- */
-export declare function Returns(status?: string | number, model?: Type<any> | Type<any>[]): ReturnsChainedDecorators;

package/lib/types-esm/decorators/operations/route.d.ts

@@ -1,133 +0,0 @@
-import { Operation } from "./operation.js";
-/**
- * @deprecated Use Operation instead of Route
- */
-export declare const Route: typeof Operation;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function All(path?: string | RegExp | unknown, ...args: unknown[]): import("./operation.js").RouteChainedDecorators;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function Get(path?: string | RegExp | unknown, ...args: unknown[]): import("./operation.js").RouteChainedDecorators;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function Post(path?: string | RegExp | unknown, ...args: unknown[]): import("./operation.js").RouteChainedDecorators;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function Put(path?: string | RegExp | unknown, ...args: unknown[]): import("./operation.js").RouteChainedDecorators;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function Delete(path?: string | RegExp | unknown, ...args: unknown[]): import("./operation.js").RouteChainedDecorators;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function Head(path?: string | RegExp | unknown, ...args: unknown[]): import("./operation.js").RouteChainedDecorators;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function Patch(path?: string | RegExp | any, ...args: any[]): import("./operation.js").RouteChainedDecorators;
-/**
- * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
- *
- * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
- * For example, if you placed the following route at the top of all other route definitions, it would require that
- * all routes from that point on would require authentication, and automatically load a user.
- * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
- * to continue matching subsequent routes.
- * @param path
- * @param args
- * @returns {Function}
- * @decorator
- * @operation
- * @httpMethod
- */
-export declare function Options(path?: string | RegExp | unknown, ...args: unknown[]): import("./operation.js").RouteChainedDecorators;

package/lib/types-esm/decorators/operations/security.d.ts

@@ -1,56 +0,0 @@
-import { OpenSpecSecurity } from "@tsed/openspec";
-/**
- * Add security metadata on the decorated method.
- *
- * ## Examples
- * ### On method
- *
- * ```typescript
- * @Controller("/")
- * class ModelCtrl {
- *    @Security("write:calendars")
- *    async method() {}
- * }
- * ```
- *
- * @param name
- * @param scopes
- * @decorator
- * @swagger
- * @schema
- * @classDecorator
- * @operation
- */
-export declare function Security(name: string, ...scopes: string[]): Function;
-/**
- * Add security metadata on the decorated method.
- *
- * You can use it to add multiple authentication types.
- * See <https://swagger.io/docs/specification/authentication/#multiple>.
- *
- * ## Examples
- * ### On method
- *
- * ```typescript
- * @Controller("/")
- * class ModelCtrl {
- *    @Security([{ "A": ["scope-1"] }, { "B": [], "C": ["scope-2", "scope-3"]}])
- *    async method() {}
- * }
- * ```
- * this will add the following security metadata
- * ```yaml
- * security: # A OR (B AND C)
- *   - A: ["scope-1"]
- *   - B: []
- *     C: ["scope-2", "scope-3"]
- * ```
- *
- * @param security
- * @decorator
- * @swagger
- * @schema
- * @classDecorator
- * @operation
- */
-export declare function Security(security: OpenSpecSecurity): Function;