@tsed/schema 7.0.0-alpha.1 → 7.0.0-beta.10

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

@@ -0,0 +1,136 @@
+import { DecoratorTypes, Store, Type } from "@tsed/core";
+import type { JsonSchema } from "./JsonSchema";
+import type { JsonMethodStore } from "./JsonMethodStore";
+import type { JsonClassStore } from "./JsonClassStore";
+import type { JsonPropertyStore } from "./JsonPropertyStore";
+import type { JsonParameterStore } from "./JsonParameterStore";
+/**
+ * @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: number;
+    /**
+     * 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;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isCollection(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isArray(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isPrimitive(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isDate(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isObject(): boolean;
+    /**
+     *
+     */
+    get isClass(): boolean;
+    /**
+     * Return the JsonSchema
+     */
+    get schema(): JsonSchema;
+    get nestedGenerics(): Type<any>[][];
+    set nestedGenerics(nestedGenerics: Type<any>[][]);
+    /**
+     *
+     * @returns {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;
+    /**
+     *
+     * @param target
+     */
+    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;
+    get<T = any>(key: string, defaultValue?: any): T;
+    set(key: string, value?: any): Store;
+    protected abstract build(): void;
+    protected buildType(type: any): void;
+    static get(target: Type<any>, propertyKey: string | symbol, descriptor?: any): JsonEntityStore;
+}

package/lib/{domain → types/domain}/JsonMap.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaOptions } from "../interfaces";
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
 export declare class JsonMap<T> extends Map<string, any> {
     [key: string]: any;
     constructor(obj?: Partial<T>);

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

@@ -0,0 +1,89 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore, JsonEntityStoreOptions } from "./JsonEntityStore";
+import { JsonOperation } from "./JsonOperation";
+import type { JsonParameterStore } from "./JsonParameterStore";
+import type { JsonClassStore } from "./JsonClassStore";
+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").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?: 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 declare type EndpointMetadata = JsonMethodStore;
+export declare const EndpointMetadata: typeof JsonMethodStore;

package/lib/{domain → types/domain}/JsonOperation.d.ts

@@ -1,5 +1,6 @@
 import { OpenSpecSecurity, OpenSpecTag, OS3Operation } from "@tsed/openspec";
-import { JsonHeader, JsonSchemaOptions } from "../interfaces";
+import { JsonHeader } from "../interfaces/JsonOpenSpec";
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
 import { JsonMap } from "./JsonMap";
 import { JsonParameter } from "./JsonParameter";
 import { JsonResponse } from "./JsonResponse";
@@ -7,6 +8,7 @@ import { JsonSchema } from "./JsonSchema";
 export interface JsonMethodPath {
     path: string | RegExp;
     method: string;
+    isFinal?: boolean;
     [key: string]: any;
 }
 export interface JsonOperationOptions extends OS3Operation<JsonSchema, JsonParameter, JsonMap<JsonResponse>> {

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

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

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

@@ -0,0 +1,26 @@
+import { Type } from "@tsed/core";
+import { JsonMethodStore } from "./JsonMethodStore";
+import { JsonMethodPath, JsonOperation } from "./JsonOperation";
+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(): string;
+    get path(): string | RegExp | undefined;
+    get fullPath(): string;
+    get method(): string;
+    get isFinal(): boolean;
+    get name(): string;
+    get className(): string;
+    get methodClassName(): string;
+    get parameters(): import("./JsonParameterStore").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/{domain → types/domain}/JsonParameter.d.ts

@@ -1,6 +1,6 @@
 import { Type } from "@tsed/core";
-import { OS3Parameter } from "@tsed/openspec";
-import { JsonSchemaOptions } from "../interfaces";
+import { OpenSpecHash, OpenSpecRef, OS3Example, OS3Parameter } from "@tsed/openspec";
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
 import { NestedGenerics } from "../utils/generics";
 import { JsonMap } from "./JsonMap";
 import { JsonSchema } from "./JsonSchema";
@@ -8,13 +8,16 @@ export declare class JsonParameter extends JsonMap<OS3Parameter<JsonSchema>> imp
     nestedGenerics: Type<any>[][];
     groups: 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;
     private build;
+    private getFileSchema;
     private refToParameters;
 }

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

@@ -0,0 +1,52 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore, JsonEntityStoreOptions } from "./JsonEntityStore";
+import type { JsonMethodStore } from "./JsonMethodStore";
+import { JsonParameter } from "./JsonParameter";
+import { JsonSchema } from "./JsonSchema";
+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 declare type ParamMetadata = JsonParameterStore;
+export declare const ParamMetadata: typeof JsonParameterStore;

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

@@ -0,0 +1,30 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore } from "./JsonEntityStore";
+import type { JsonClassStore } from "./JsonClassStore";
+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[];
+    /**
+     * 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 declare type PropertyMetadata = JsonPropertyStore;
+export declare const PropertyMetadata: typeof JsonPropertyStore;

package/lib/{domain → types/domain}/JsonResponse.d.ts

@@ -1,5 +1,6 @@
 import { OS3MediaType, OS3Response } from "@tsed/openspec";
-import { JsonHeader, JsonSchemaOptions } from "../interfaces";
+import { JsonHeader } from "../interfaces/JsonOpenSpec";
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
 import { JsonMap } from "./JsonMap";
 import { JsonSchema } from "./JsonSchema";
 export declare type JsonResponseOptions = OS3Response<JsonSchema, string | JsonHeader>;

package/lib/{domain → types/domain}/JsonSchema.d.ts

@@ -1,6 +1,6 @@
 import { Hooks, Type, ValueOf } from "@tsed/core";
-import { JSONSchema6, JSONSchema6Definition, JSONSchema6Type, JSONSchema6TypeName, JSONSchema6Version } from "json-schema";
-import { JsonSchemaOptions } from "../interfaces";
+import type { JSONSchema6, JSONSchema6Definition, JSONSchema6Type, JSONSchema6TypeName, JSONSchema6Version } from "json-schema";
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
 import { IgnoreCallback } from "../interfaces/IgnoreCallback";
 import { NestedGenerics } from "../utils/generics";
 import { AliasMap, AliasType } from "./JsonAliasMap";
@@ -14,29 +14,19 @@ export interface JsonSchemaObject extends JSONSchema6, Record<string, any> {
 }
 export declare type AnyJsonSchema = Partial<JsonSchemaObject> | JsonSchema | JsonLazyRef | any;
 export declare class JsonSchema extends Map<string, any> implements NestedGenerics {
+    #private;
     readonly isJsonSchema = true;
     readonly $hooks: Hooks;
     readonly $required: Set<string>;
     readonly $allow: any[];
     $selfRequired: boolean;
     $forwardGroups: boolean;
-    protected _nullable: boolean;
-    protected _genericLabels: string[];
-    protected _nestedGenerics: Type<any>[][];
-    protected _alias: AliasMap;
-    protected _itemSchema: JsonSchema;
-    protected _target: Type<any>;
-    protected _isGeneric: boolean;
-    protected _isCollection: boolean;
-    protected _ref: boolean;
     constructor(obj?: JsonSchema | Partial<JsonSchemaObject>);
     get alias(): AliasMap;
     get nestedGenerics(): any[];
     set nestedGenerics(value: any[]);
     get genericLabels(): string[];
     set genericLabels(value: string[]);
-    get nullable(): boolean;
-    set nullable(value: boolean);
     get isClass(): boolean;
     /**
      * Current schema is a collection
@@ -53,7 +43,11 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
     get genericType(): string;
     get class(): any;
     get canRef(): boolean;
+    get isNullable(): boolean;
+    get isReadOnly(): any;
+    get isWriteOnly(): any;
     static from(obj?: Partial<JsonSchemaObject>): JsonSchema;
+    nullable(value: boolean): void;
     itemSchema(obj?: AnyJsonSchema): JsonSchema;
     getAliasOf(property: AliasType): AliasType | undefined;
     addAlias(property: AliasType, alias: AliasType): this;
@@ -224,7 +218,7 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
      *
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23
      */
-    enum(enumValues: JSONSchema6Type[]): this;
+    enum(...enumValues: any[]): this;
     /**
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
      */

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

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

package/lib/types/index.d.ts

@@ -0,0 +1,150 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+export * from "./components/anyMapper";
+export * from "./components/classMapper";
+export * from "./components/genericsMapper";
+export * from "./components/inheritedClassMapper";
+export * from "./components/itemMapper";
+export * from "./components/lazyRefMapper";
+export * from "./components/mapMapper";
+export * from "./components/objectMapper";
+export * from "./components/ofMapper";
+export * from "./components/propertiesMapper";
+export * from "./components/schemaMapper";
+export * from "./constants/httpMethods";
+export * from "./constants/httpStatusMessages";
+export * from "./decorators/class/children";
+export * from "./decorators/collections/collectionContains";
+export * from "./decorators/collections/collectionOf";
+export * from "./decorators/collections/maxItems";
+export * from "./decorators/collections/maxProperties";
+export * from "./decorators/collections/minItems";
+export * from "./decorators/collections/minProperties";
+export * from "./decorators/collections/uniqueItems";
+export * from "./decorators/common/additionalProperties";
+export * from "./decorators/common/allOf";
+export * from "./decorators/common/allow";
+export * from "./decorators/common/any";
+export * from "./decorators/common/anyOf";
+export * from "./decorators/common/const";
+export * from "./decorators/common/customKey";
+export * from "./decorators/common/default";
+export * from "./decorators/common/description";
+export * from "./decorators/common/enum";
+export * from "./decorators/common/example";
+export * from "./decorators/common/examples";
+export * from "./decorators/common/exclusiveMaximum";
+export * from "./decorators/common/exclusiveMinimum";
+export * from "./decorators/common/format";
+export * from "./decorators/common/forwardGroups";
+export * from "./decorators/common/groups";
+export * from "./decorators/common/hidden";
+export * from "./decorators/common/ignore";
+export * from "./decorators/common/integer";
+export * from "./decorators/common/jsonEntityFn";
+export * from "./decorators/common/maxLength";
+export * from "./decorators/common/maximum";
+export * from "./decorators/common/minLength";
+export * from "./decorators/common/minimum";
+export * from "./decorators/common/multipleOf";
+export * from "./decorators/common/name";
+export * from "./decorators/common/nullable";
+export * from "./decorators/common/oneOf";
+export * from "./decorators/common/optional";
+export * from "./decorators/common/pattern";
+export * from "./decorators/common/property";
+export * from "./decorators/common/readOnly";
+export * from "./decorators/common/recordOf";
+export * from "./decorators/common/required";
+export * from "./decorators/common/requiredGroups";
+export * from "./decorators/common/schema";
+export * from "./decorators/common/title";
+export * from "./decorators/common/writeOnly";
+export * from "./decorators/config/jsonEntityComponent";
+export * from "./decorators/generics/genericOf";
+export * from "./decorators/generics/generics";
+export * from "./decorators/operations/acceptMime";
+export * from "./decorators/operations/consumes";
+export * from "./decorators/operations/contentType";
+export * from "./decorators/operations/deprecated";
+export * from "./decorators/operations/header";
+export * from "./decorators/operations/in";
+export * from "./decorators/operations/inFile";
+export * from "./decorators/operations/location";
+export * from "./decorators/operations/operationId";
+export * from "./decorators/operations/operationPath";
+export * from "./decorators/operations/partial";
+export * from "./decorators/operations/path";
+export * from "./decorators/operations/produces";
+export * from "./decorators/operations/redirect";
+export * from "./decorators/operations/returns";
+export * from "./decorators/operations/route";
+export * from "./decorators/operations/security";
+export * from "./decorators/operations/status";
+export * from "./decorators/operations/summary";
+export * from "./decorators/operations/tags";
+export * from "./decorators/operations/view";
+export * from "./domain/DecoratorContext";
+export * from "./domain/JsonAliasMap";
+export * from "./domain/JsonClassStore";
+export * from "./domain/JsonEntityStore";
+export * from "./domain/JsonFormatTypes";
+export * from "./domain/JsonLazyRef";
+export * from "./domain/JsonMap";
+export * from "./domain/JsonMethodStore";
+export * from "./domain/JsonOperation";
+export * from "./domain/JsonOperationPathsMap";
+export * from "./domain/JsonOperationRoute";
+export * from "./domain/JsonParameter";
+export * from "./domain/JsonParameterStore";
+export * from "./domain/JsonParameterTypes";
+export * from "./domain/JsonPropertyStore";
+export * from "./domain/JsonRequestBody";
+export * from "./domain/JsonResponse";
+export * from "./domain/JsonSchema";
+export * from "./domain/SpecTypes";
+export * from "./hooks/alterIgnore";
+export * from "./hooks/alterOneOf";
+export * from "./hooks/alterRequiredGroups";
+export * from "./interfaces/IgnoreCallback";
+export * from "./interfaces/JsonHookContext";
+export * from "./interfaces/JsonOpenSpec";
+export * from "./interfaces/JsonSchemaOptions";
+export * from "./registries/JsonSchemaMapperContainer";
+export * from "./utils/buildPath";
+export * from "./utils/concatParameters";
+export * from "./utils/concatPath";
+export * from "./utils/defineStatusModel";
+export * from "./utils/from";
+export * from "./utils/generateSpec";
+export * from "./utils/generics";
+export * from "./utils/getComputedType";
+export * from "./utils/getInheritedStores";
+export * from "./utils/getJsonEntityStore";
+export * from "./utils/getJsonPathParameters";
+export * from "./utils/getJsonSchema";
+export * from "./utils/getJsonType";
+export * from "./utils/getOperationsRoutes";
+export * from "./utils/getOperationsStores";
+export * from "./utils/getPropertiesStores";
+export * from "./utils/getRequiredProperties";
+export * from "./utils/getSpec";
+export * from "./utils/getSpecType";
+export * from "./utils/isSuccessStatus";
+export * from "./utils/mapHeaders";
+export * from "./utils/mapNullableType";
+export * from "./utils/mapOpenSpec";
+export * from "./utils/mapOpenSpec2";
+export * from "./utils/mapOpenSpec3";
+export * from "./utils/mapOpenSpecInfo";
+export * from "./utils/mapRouteOptions";
+export * from "./utils/matchGroups";
+export * from "./utils/mergeOperation";
+export * from "./utils/mergeSpec";
+export * from "./utils/operationIdFormatter";
+export * from "./utils/ref";
+export * from "./utils/serializeEnumValues";
+export * from "./utils/toJsonMapCollection";
+export * from "./utils/toJsonRegex";
+export * from "./utils/transformToOS2";

package/lib/{registries → types/registries}/JsonSchemaMapperContainer.d.ts

@@ -2,7 +2,7 @@
  * @ignore
  */
 export interface JsonSchemaMapper {
-    (schema: any, options: any): any;
+    (schema: any, options: any, parent?: any): any;
 }
 /**
  * @ignore
@@ -15,4 +15,5 @@ export declare function getJsonSchemaMapper(type: string): JsonSchemaMapper;
 /**
  * @ignore
  */
-export declare function execMapper(type: string, schema: any, options: any): any;
+export declare function execMapper(type: string, schema: any, options: any, parent?: any): any;
+export declare function hasMapper(type: string): boolean;