@tsed/schema 7.79.4 → 7.80.0

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

@@ -0,0 +1,23 @@
+/**
+ * Use a view and sends the rendered HTML string to the client. Optional parameter:
+ *
+ * * viewOptions, an object whose properties define local variables for the view.
+ *
+ * The view argument is a string that is the file path of the view file to render.
+ * This can be an absolute path, or a path relative to the views setting.
+ * If the path does not contain a file extension, then the view engine setting determines the file extension.
+ * If the path does contain a file extension, then Express will load the module for the specified template engine (via require())
+ * and render it using the loaded module’s __express function.
+ *
+ * For more information, see [Using template engines with Express](http://expressjs.com/guide/using-template-engines.html).
+ *
+ * > NOTE: The view argument performs file system operations like reading a file from disk and evaluating Node.js modules,
+ * and as so for security reasons should not contain input from the end-user.
+ *
+ * @param path Relative path to the view file.
+ * @param options Additional options
+ * @decorator
+ * @operation
+ * @response
+ */
+export declare function View(path: string, options?: Object): MethodDecorator;

package/lib/types-esm/domain/DecoratorContext.d.ts

@@ -0,0 +1,28 @@
+import { DecoratorParameters, DecoratorTypes } from "@tsed/core";
+import { JsonEntityStore } from "./JsonEntityStore.js";
+/**
+ * @ignore
+ */
+export interface DecoratorActionHandler {
+    (ctx: Map<string, any>): void;
+}
+/**
+ * @ignore
+ */
+export declare abstract class DecoratorContext<T = any> extends Map<string, any> {
+    readonly methods: string[];
+    protected decoratorType: DecoratorTypes;
+    protected entity: JsonEntityStore;
+    protected actions: DecoratorActionHandler[];
+    constructor(opts?: any);
+    addAction(cb: DecoratorActionHandler): this;
+    build(): T;
+    toObject(): any;
+    getMergedKey(key: string, defaultValue: any): any;
+    protected bind(args: DecoratorParameters, decorator: any): void;
+    protected onInit(args: DecoratorParameters, decorator: any): void;
+    protected onMapKey(key: string, value: any): void;
+    protected runActions(): this;
+    protected beforeInit(): void;
+    protected afterInit(): void;
+}

package/lib/types-esm/domain/JsonAliasMap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @ignore
+ */
+export type AliasType = string | number | symbol;
+/**
+ * @ignore
+ */
+export type AliasMap = Map<AliasType, AliasType>;
+/**
+ * @ignore
+ */
+export declare function mapAliasedProperties(value: any, alias: AliasMap): any;

package/lib/types-esm/domain/JsonClassStore.d.ts

@@ -0,0 +1,12 @@
+import type { JsonMethodStore } from "./JsonMethodStore.js";
+import type { JsonPropertyStore } from "./JsonPropertyStore.js";
+import { JsonEntityStore } from "./JsonEntityStore.js";
+export declare class JsonClassStore extends JsonEntityStore {
+    /**
+     * List of children JsonEntityStore (properties or methods or params)
+     */
+    readonly children: Map<string | number, JsonMethodStore | JsonPropertyStore>;
+    get path(): string;
+    set path(path: string);
+    protected build(): void;
+}

package/lib/types-esm/domain/JsonDiscriminator.d.ts

@@ -0,0 +1,18 @@
+import { Type } from "@tsed/core";
+export declare class Discriminator {
+    propertyName: string;
+    base: Type<any>;
+    values: Map<string, Type>;
+    types: Map<Type, string[]>;
+    constructor({ base, propertyName, types, values }?: Partial<{
+        base: Type<any>;
+        propertyName: string;
+        values: Map<string, Type<any>>;
+        types: Map<Type, string[]>;
+    }>);
+    add(type: Type<string>, values: string[]): this;
+    getType(discriminatorValue: string): Type<any>;
+    getValues(type: Type): string[] | undefined;
+    getDefaultValue(type: Type<any>): string | undefined;
+    children(): Type<any>[];
+}

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

@@ -0,0 +1,110 @@
+import { DecoratorTypes, Store, Type } from "@tsed/core";
+import type { JsonClassStore } from "./JsonClassStore.js";
+import type { JsonMethodStore } from "./JsonMethodStore.js";
+import type { JsonParameterStore } from "./JsonParameterStore.js";
+import type { JsonPropertyStore } from "./JsonPropertyStore.js";
+import type { JsonSchema } from "./JsonSchema.js";
+/**
+ * @ignore
+ */
+export declare const JsonEntitiesContainer: Map<DecoratorTypes, Type<JsonEntityStore>>;
+export interface JsonEntityStoreOptions {
+    decoratorType: DecoratorTypes;
+    target: Type<any>;
+    propertyKey?: string | symbol;
+    index?: number;
+    descriptor?: any;
+    type?: Type<any>;
+    collectionType?: Type<any>;
+    beforeMiddlewares?: Function[];
+    middlewares?: Function[];
+    afterMiddlewares?: Function[];
+    [key: string]: any;
+}
+export declare abstract class JsonEntityStore implements JsonEntityStoreOptions {
+    /**
+     * Original property key decorated by the decorator
+     */
+    readonly propertyKey: string | symbol;
+    /**
+     * Alias of the property
+     */
+    readonly propertyName: string;
+    /**
+     * Parameter index
+     */
+    readonly index: number;
+    /**
+     * Method's descriptor
+     */
+    readonly descriptor: PropertyDescriptor;
+    /**
+     * Decorator type used to declare the JsonSchemaStore.
+     */
+    readonly decoratorType: DecoratorTypes;
+    /**
+     * Type of the collection (Array, Map, Set, etc...)
+     */
+    collectionType: Type<any>;
+    token: Type<any>;
+    readonly store: Store;
+    readonly isStore = true;
+    readonly parent: JsonEntityStore;
+    readonly target: Type<any>;
+    /**
+     *
+     */
+    protected _type: Type<any>;
+    /**
+     * Ref to JsonSchema
+     */
+    protected _schema: JsonSchema;
+    [key: string]: any;
+    constructor(options: JsonEntityStoreOptions);
+    /**
+     * Return the class name of the entity.
+     * @returns {string}
+     */
+    get targetName(): string;
+    get isCollection(): boolean;
+    get isArray(): boolean;
+    get discriminatorAncestor(): JsonEntityStore | undefined;
+    get isPrimitive(): boolean;
+    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 itemSchema(): JsonSchema;
+    get parentSchema(): JsonSchema;
+    get isDiscriminatorChild(): boolean;
+    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;
+    static from<T extends JsonMethodStore = JsonMethodStore>(target: Type<any> | any, propertyKey: string | symbol, descriptor: PropertyDescriptor): T;
+    static from<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): T;
+    static fromMethod<T extends JsonMethodStore = JsonMethodStore>(target: any, propertyKey: string | symbol): T;
+    static get(target: Type<any>, propertyKey: string | symbol, descriptor?: any): JsonEntityStore;
+    isGetterOnly(): boolean | undefined;
+    get<T = any>(key: string, defaultValue?: any): T;
+    set(key: string, value?: any): Store;
+    toString(): string;
+    protected abstract build(): void;
+    protected buildType(type: any): void;
+    getBestType(): any;
+}

package/lib/types-esm/domain/JsonFormatTypes.d.ts

@@ -0,0 +1,17 @@
+export declare enum JsonFormatTypes {
+    DATE_TIME = "date-time",
+    DATE = "date",
+    TIME = "time",
+    EMAIL = "email",
+    HOSTNAME = "hostname",
+    IPV4 = "ipv4",
+    IPV6 = "ipv6",
+    URI = "uri",
+    URL = "url",
+    URI_REF = "uri-reference",
+    URI_TEMPLATE = "uri-template",
+    JSON_POINTER = "json-pointer",
+    RELATIVE_JSON_POINTER = "relative-json-pointer",
+    UUID = "uuid",
+    REGEX = "regex"
+}

package/lib/types-esm/domain/JsonLazyRef.d.ts

@@ -0,0 +1,9 @@
+import { Type } from "@tsed/core";
+export declare class JsonLazyRef {
+    readonly getType: () => Type<any>;
+    readonly isLazyRef = true;
+    constructor(getType: () => Type<any>);
+    get target(): Type<any>;
+    get schema(): import("./JsonSchema.js").JsonSchema;
+    get name(): string;
+}

package/lib/types-esm/domain/JsonMap.d.ts

@@ -0,0 +1,9 @@
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
+export declare class JsonMap<T> extends Map<string, any> {
+    [key: string]: any;
+    $kind: string;
+    readonly $isJsonDocument = true;
+    constructor(obj?: Partial<T>);
+    assign(obj?: Partial<T> & any): this;
+    toJSON(options?: JsonSchemaOptions): any;
+}

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

@@ -0,0 +1,11 @@
+import { OS3MediaType } from "@tsed/openspec";
+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;
+}

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

@@ -0,0 +1,92 @@
+import { Type } from "@tsed/core";
+import type { JsonClassStore } from "./JsonClassStore.js";
+import { JsonEntityStore, JsonEntityStoreOptions } from "./JsonEntityStore.js";
+import { JsonOperation } from "./JsonOperation.js";
+import type { JsonParameterStore } from "./JsonParameterStore.js";
+export interface JsonViewOptions {
+    path: string;
+    options: any;
+}
+export interface JsonRedirectOptions {
+    status: number | undefined;
+    url: string;
+}
+export declare class JsonMethodStore extends JsonEntityStore {
+    readonly parent: JsonClassStore;
+    middlewares: any[];
+    beforeMiddlewares: any[];
+    afterMiddlewares: any[];
+    /**
+     * Ref to JsonOperation when the decorated object is a method.
+     */
+    readonly operation: JsonOperation;
+    /**
+     * List of children JsonEntityStore (properties or methods or params)
+     */
+    readonly children: Map<string | number, JsonParameterStore>;
+    constructor(options: JsonEntityStoreOptions);
+    get params(): JsonParameterStore[];
+    get view(): JsonViewOptions;
+    set view(view: JsonViewOptions);
+    get acceptMimes(): string[];
+    set acceptMimes(mimes: string[]);
+    get parameters(): JsonParameterStore[];
+    get operationPaths(): Map<string, import("./JsonOperation.js").JsonMethodPath>;
+    /**
+     * Get an endpoint.
+     * @param target
+     * @param propertyKey
+     * @param descriptor
+     */
+    static get(target: Type<any>, propertyKey: string | symbol, descriptor?: PropertyDescriptor): JsonMethodStore;
+    getResponseOptions(status: number, { contentType, includes }?: {
+        contentType?: string;
+        includes?: string[];
+    }): undefined | any;
+    /**
+     * Append middlewares to the beforeMiddlewares list.
+     * @param args
+     * @returns {EndpointMetadata}
+     */
+    before(args: Function[]): this;
+    /**
+     * Append middlewares to the afterMiddlewares list.
+     * @param args
+     * @returns {EndpointMetadata}
+     */
+    after(args: Function[]): this;
+    /**
+     * Store all arguments collected via Annotation.
+     * @param args
+     */
+    use(args: Function[]): this;
+    /**
+     * Find the value at the controller level. Let this value be extended or overridden by the endpoint itself.
+     *
+     * @param key
+     * @returns {any}
+     */
+    get<T = any>(key: any): T;
+    getParamTypes(): Record<string, boolean>;
+    protected build(): void;
+}
+/**
+ * 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.
+ *
+ * Example :
+ *```typescript
+ * @Controller("/my-path")
+ * provide MyClass {
+ *
+ *     @Get("/")
+ *     @Authenticated()
+ *     public myMethod(){}
+ * }
+ *```
+ *
+ * @alias JsonMethodStore
+ */
+export type EndpointMetadata = JsonMethodStore;
+export declare const EndpointMetadata: typeof JsonMethodStore;

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

@@ -0,0 +1,51 @@
+import { OpenSpecSecurity, OpenSpecTag, OS3Operation } from "@tsed/openspec";
+import { JsonHeader } from "../interfaces/JsonOpenSpec.js";
+import { JsonMap } from "./JsonMap.js";
+import { JsonParameter } from "./JsonParameter.js";
+import { JsonResponse } from "./JsonResponse.js";
+import { JsonSchema } from "./JsonSchema.js";
+export interface JsonMethodPath {
+    path: string | RegExp;
+    method: string;
+    [key: string]: any;
+}
+export interface JsonOperationOptions extends OS3Operation<JsonSchema, JsonParameter, JsonMap<JsonResponse>> {
+    consumes: string[];
+    produces: string[];
+}
+export declare class JsonOperation extends JsonMap<JsonOperationOptions> {
+    #private;
+    $kind: string;
+    readonly operationPaths: Map<string, JsonMethodPath>;
+    constructor(obj?: Partial<JsonOperationOptions>);
+    get response(): JsonResponse | undefined;
+    get status(): number;
+    tags(tags: OpenSpecTag[]): this;
+    addTags(tags: OpenSpecTag[]): this;
+    summary(summary: string): this;
+    operationId(operationId: string): this;
+    responses(responses: JsonMap<any>): this;
+    defaultStatus(status: number): this;
+    getStatus(): number;
+    setRedirection(status?: number): this;
+    isRedirection(status?: number): boolean | 0;
+    addResponse(statusCode: string | number, response: JsonResponse): this;
+    getResponses(): JsonMap<JsonResponse>;
+    getResponseOf(status: number | string): JsonResponse;
+    ensureResponseOf(status: number | string): JsonResponse;
+    getHeadersOf(status: number): Record<string, JsonHeader & {
+        example: string;
+    }>;
+    getContentTypeOf(status: number): any;
+    security(security: OpenSpecSecurity): this;
+    addSecurityScopes(name: string, scopes: string[]): this;
+    description(description: string): this;
+    deprecated(deprecated: boolean): this;
+    parameters(parameters: JsonParameter[]): this;
+    addParameter(index: number, parameter: JsonParameter): void;
+    consumes(consumes: string[]): this;
+    produces(produces: string[]): this;
+    addProduce(produce: string): void;
+    addOperationPath(method: string, path: string | RegExp, options?: any): this;
+    getAllowedOperationPath(allowedVerbs?: string[]): JsonMethodPath[];
+}

package/lib/types-esm/domain/JsonOperationPathsMap.d.ts

@@ -0,0 +1,7 @@
+import { JsonMethodPath } from "./JsonOperation.js";
+export declare class JsonOperationPathsMap extends Map<string, JsonMethodPath> {
+    $kind: string;
+    readonly $isJsonDocument = true;
+    setOperationPath(operationPath: JsonMethodPath): void;
+    protected getKey: (method: string, path: any) => string;
+}

package/lib/types-esm/domain/JsonOperationRoute.d.ts

@@ -0,0 +1,25 @@
+import { Type } from "@tsed/core";
+import { JsonMethodStore } from "./JsonMethodStore.js";
+import { JsonMethodPath, JsonOperation } from "./JsonOperation.js";
+export declare class JsonOperationRoute<Entity extends JsonMethodStore = JsonMethodStore> {
+    readonly token: Type<any>;
+    readonly endpoint: Entity;
+    readonly operationPath?: JsonMethodPath;
+    readonly basePath?: string;
+    readonly paramsTypes: Record<string, boolean>;
+    constructor(options: Partial<JsonOperationRoute>);
+    get url(): any;
+    get path(): string | RegExp | undefined;
+    get fullPath(): any;
+    get method(): string;
+    get name(): string;
+    get className(): string;
+    get methodClassName(): string;
+    get parameters(): import("./JsonParameterStore.js").JsonParameterStore[];
+    get propertyKey(): string;
+    get propertyName(): string;
+    get store(): import("@tsed/core").Store;
+    get operation(): JsonOperation;
+    get operationId(): any;
+    has(key: string): boolean;
+}

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

@@ -0,0 +1,22 @@
+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 {
+    $kind: string;
+    nestedGenerics: Type<any>[][];
+    groups: string[];
+    groupsName: string;
+    $schema: JsonSchema;
+    expression: string;
+    getName(): any;
+    name(name: string): this;
+    examples(examples: OpenSpecHash<OS3Example | OpenSpecRef>): this;
+    description(description: string): this;
+    in(inType: string, expression?: string | any): this;
+    required(required: boolean): this;
+    schema(schema: JsonSchema): this;
+    toJSON(options?: JsonSchemaOptions): any;
+}

package/lib/types-esm/domain/JsonParameterStore.d.ts

@@ -0,0 +1,52 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore, JsonEntityStoreOptions } from "./JsonEntityStore.js";
+import type { JsonMethodStore } from "./JsonMethodStore.js";
+import { JsonParameter } from "./JsonParameter.js";
+import { JsonSchema } from "./JsonSchema.js";
+export interface JsonParameterStoreOptions extends JsonEntityStoreOptions {
+    dataPath?: string;
+    paramType?: string;
+    expression?: string;
+}
+export interface PipeMethods<T = any, R = any> {
+    transform(value: T, metadata: JsonParameterStore): R;
+}
+export declare class JsonParameterStore extends JsonEntityStore {
+    paramType: string;
+    expression: string;
+    dataPath: string;
+    /**
+     * Define pipes can be called by the framework to transform input parameter
+     */
+    pipes: Type<PipeMethods>[];
+    /**
+     * Ref to JsonParameter when the decorated object is a parameter.
+     */
+    readonly parameter: JsonParameter;
+    readonly parent: JsonMethodStore;
+    constructor(options: JsonParameterStoreOptions);
+    get nestedGenerics(): Type<any>[][];
+    set nestedGenerics(nestedGenerics: Type<any>[][]);
+    /**
+     * Return the required state.
+     * @returns {boolean}
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    get allowedRequiredValues(): any[];
+    static getParams<T extends JsonParameterStore = JsonParameterStore>(target: Type<any>, propertyKey: string | symbol): T[];
+    static get(target: Type<any>, propertyKey: string | symbol, index: number): JsonParameterStore;
+    /**
+     * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
+     * @param value
+     * @returns {boolean}
+     */
+    isRequired(value: any): boolean;
+    protected getSchema(type: any): JsonSchema;
+    protected build(): void;
+}
+/**
+ * @alias JsonParameterStore
+ */
+export type ParamMetadata = JsonParameterStore;
+export declare const ParamMetadata: typeof JsonParameterStore;

package/lib/types-esm/domain/JsonParameterTypes.d.ts

@@ -0,0 +1,16 @@
+export declare enum JsonParameterTypes {
+    BODY = "body",
+    PATH = "path",
+    QUERY = "query",
+    HEADER = "header",
+    COOKIES = "cookie",
+    FILES = "files"
+}
+/**
+ * @ignore
+ */
+export declare function formatParameterType(type: any): any;
+/**
+ * @ignore
+ */
+export declare function isParameterType(type: string): boolean;

package/lib/types-esm/domain/JsonPropertyStore.d.ts

@@ -0,0 +1,32 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore } from "./JsonEntityStore.js";
+import type { JsonClassStore } from "./JsonClassStore.js";
+export declare class JsonPropertyStore extends JsonEntityStore {
+    readonly parent: JsonClassStore;
+    /**
+     * Return the required state.
+     * @returns {boolean}
+     */
+    get required(): boolean;
+    /**
+     * Change the state of the required data.
+     * @param value
+     */
+    set required(value: boolean);
+    get allowedRequiredValues(): any[];
+    discriminatorKey(): this;
+    isDiscriminatorKey(): boolean;
+    /**
+     * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
+     * @param value
+     * @returns {boolean}
+     */
+    isRequired(value: any): boolean;
+    protected build(): void;
+    static get(target: Type<any>, propertyKey: string | symbol): JsonPropertyStore;
+}
+/**
+ * @alias JsonPropertyStore
+ */
+export type PropertyMetadata = JsonPropertyStore;
+export declare const PropertyMetadata: typeof JsonPropertyStore;

package/lib/types-esm/domain/JsonRequestBody.d.ts

@@ -0,0 +1,12 @@
+import { OpenSpecHash, OS3MediaType, OS3RequestBody } from "@tsed/openspec";
+import { JsonMap } from "./JsonMap.js";
+import { JsonSchema } from "./JsonSchema.js";
+export type JsonRequestBodyOptions = OS3RequestBody<JsonSchema>;
+export declare class JsonRequestBody extends JsonMap<JsonRequestBodyOptions> {
+    $kind: string;
+    constructor(obj?: Partial<JsonRequestBodyOptions>);
+    description(description: string): this;
+    content(content: OpenSpecHash<OS3MediaType<JsonSchema>>): this;
+    addContent(mediaType: string, schema: JsonSchema, examples?: any): this;
+    required(required: boolean): this;
+}

package/lib/types-esm/domain/JsonResponse.d.ts

@@ -0,0 +1,18 @@
+import { OS3MediaType, OS3Response } from "@tsed/openspec";
+import { JsonHeader } from "../interfaces/JsonOpenSpec.js";
+import { JsonMap } from "./JsonMap.js";
+import { JsonMedia } from "./JsonMedia.js";
+import { JsonSchema } from "./JsonSchema.js";
+export type JsonResponseOptions = OS3Response<JsonSchema, string | JsonHeader>;
+export declare class JsonResponse extends JsonMap<JsonResponseOptions> {
+    $kind: string;
+    status: number;
+    constructor(obj?: Partial<JsonResponseOptions>);
+    description(description: string): this;
+    headers(headers: Record<string, string | JsonHeader>): this;
+    content(content: Record<string, OS3MediaType<JsonSchema>>): this;
+    getContent(): JsonMap<JsonMedia>;
+    getMedia(mediaType: string, create?: boolean): JsonMedia;
+    addMedia(mediaType: string): this;
+    isBinary(): boolean;
+}