@goatlab/fluent 0.7.21 → 0.7.22

package/dist/core/Nestjs/types/interfaces/open-api-spec.interface.d.ts

@@ -0,0 +1,235 @@
+export interface OpenAPIObject {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+export interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+export interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface LicenseObject {
+    name: string;
+    url?: string;
+}
+export interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: Record<string, ServerVariableObject>;
+}
+export interface ServerVariableObject {
+    enum?: string[] | boolean[] | number[];
+    default: string | boolean | number;
+    description?: string;
+}
+export interface ComponentsObject {
+    schemas?: Record<string, SchemaObject | ReferenceObject>;
+    responses?: Record<string, ResponseObject | ReferenceObject>;
+    parameters?: Record<string, ParameterObject | ReferenceObject>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+    callbacks?: Record<string, CallbackObject | ReferenceObject>;
+}
+export declare type PathsObject = Record<string, PathItemObject>;
+export interface PathItemObject {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject | ReferenceObject)[];
+}
+export interface OperationObject {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses: ResponsesObject;
+    callbacks?: CallbacksObject;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+}
+export interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+export declare type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+export declare type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+export interface BaseParameterObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject | ReferenceObject;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    example?: any;
+    content?: ContentObject;
+}
+export interface ParameterObject extends BaseParameterObject {
+    name: string;
+    in: ParameterLocation;
+}
+export interface RequestBodyObject {
+    description?: string;
+    content: ContentObject;
+    required?: boolean;
+}
+export declare type ContentObject = Record<string, MediaTypeObject>;
+export interface MediaTypeObject {
+    schema?: SchemaObject | ReferenceObject;
+    examples?: ExamplesObject;
+    example?: any;
+    encoding?: EncodingObject;
+}
+export declare type EncodingObject = Record<string, EncodingPropertyObject>;
+export interface EncodingPropertyObject {
+    contentType?: string;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+export interface ResponsesObject extends Record<string, ResponseObject | ReferenceObject | undefined> {
+    default?: ResponseObject | ReferenceObject;
+}
+export interface ResponseObject {
+    description: string;
+    headers?: HeadersObject;
+    content?: ContentObject;
+    links?: LinksObject;
+}
+export declare type CallbacksObject = Record<string, CallbackObject | ReferenceObject>;
+export declare type CallbackObject = Record<string, PathItemObject>;
+export declare type HeadersObject = Record<string, HeaderObject | ReferenceObject>;
+export interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+export declare type LinksObject = Record<string, LinkObject | ReferenceObject>;
+export interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject;
+    requestBody?: any | string;
+    description?: string;
+    server?: ServerObject;
+}
+export declare type LinkParametersObject = Record<string, any>;
+export declare type HeaderObject = BaseParameterObject;
+export interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+}
+export declare type ExamplesObject = Record<string, ExampleObject | ReferenceObject>;
+export interface ReferenceObject {
+    $ref: string;
+}
+export interface SchemaObject {
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    examples?: any[] | Record<string, any>;
+    deprecated?: boolean;
+    type?: string;
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: Record<string, SchemaObject | ReferenceObject>;
+    additionalProperties?: SchemaObject | ReferenceObject | boolean;
+    patternProperties?: SchemaObject | ReferenceObject | any;
+    description?: string;
+    format?: string;
+    default?: any;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+}
+export declare type SchemasObject = Record<string, SchemaObject>;
+export interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: Record<string, string>;
+}
+export interface XmlObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+export declare type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+export interface SecuritySchemeObject {
+    type: SecuritySchemeType;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuthFlowsObject;
+    openIdConnectUrl?: string;
+}
+export interface OAuthFlowsObject {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+}
+export interface OAuthFlowObject {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: ScopesObject;
+}
+export declare type ScopesObject = Record<string, any>;
+export declare type SecurityRequirementObject = Record<string, string[]>;

package/dist/core/Nestjs/types/interfaces/open-api-spec.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/interfaces/resolve-type-fn.interface.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLTypeResolver } from 'graphql';
+export declare type ResolveTypeFn<TSource = any, TContext = any> = (...args: Parameters<GraphQLTypeResolver<TSource, TContext>>) => any;

package/dist/core/Nestjs/types/interfaces/resolve-type-fn.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/interfaces/return-type-func.interface.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLScalarType } from 'graphql';
+import { Type } from '../common';
+export declare type GqlTypeReference = Type<any> | GraphQLScalarType | Function | object | symbol;
+export declare type ReturnTypeFuncValue = GqlTypeReference | [GqlTypeReference];
+export declare type ReturnTypeFunc = (returns?: void) => ReturnTypeFuncValue;

package/dist/core/Nestjs/types/interfaces/return-type-func.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/interfaces/schema-object-metadata.interface.d.ts

@@ -0,0 +1,9 @@
+import { SchemaObject } from './open-api-spec.interface';
+import { Type } from '../common';
+export interface SchemaObjectMetadata extends Omit<SchemaObject, 'type' | 'required'> {
+    type?: Type<unknown> | Function | [Function] | string | Record<string, any>;
+    isArray?: boolean;
+    required?: boolean;
+    name?: string;
+    enumName?: string;
+}

package/dist/core/Nestjs/types/interfaces/schema-object-metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/interfaces/type-options.interface.d.ts

@@ -0,0 +1,5 @@
+import { BaseTypeOptions } from './base-type-options.interface';
+export interface TypeOptions extends BaseTypeOptions {
+    isArray?: boolean;
+    arrayDepth?: number;
+}

package/dist/core/Nestjs/types/interfaces/type-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/lazy-metadata.storage.d.ts

@@ -0,0 +1,15 @@
+import { Type } from './common';
+export declare class LazyMetadataStorageHost {
+    private readonly lazyMetadataByTarget;
+    store(func: Function): void;
+    store(target: Type<unknown>, func: Function): void;
+    store(target: Type<unknown>, func: Function, options?: {
+        isField: boolean;
+    }): void;
+    load(types?: Function[], options?: {
+        skipFieldLazyMetadata?: boolean;
+    }): void;
+    private concatPrototypes;
+    private updateStorage;
+}
+export declare const LazyMetadataStorage: LazyMetadataStorageHost;

package/dist/core/Nestjs/types/lazy-metadata.storage.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyMetadataStorage = exports.LazyMetadataStorageHost = void 0;
+const common_1 = require("./common");
+const NO_TARGET_METADATA = Symbol('NO_TARGET_METADATA');
+const FIELD_LAZY_METADATA = Symbol('FIELD_LAZY_METADATA');
+class LazyMetadataStorageHost {
+    constructor() {
+        this.lazyMetadataByTarget = new Map();
+    }
+    store(targetOrFn, func, options) {
+        if (func && options?.isField) {
+            this.updateStorage(FIELD_LAZY_METADATA, func);
+            this.updateStorage(targetOrFn, func);
+        }
+        else if (func) {
+            this.updateStorage(targetOrFn, func);
+        }
+        else {
+            this.updateStorage(NO_TARGET_METADATA, targetOrFn);
+        }
+    }
+    load(types = [], options = {
+        skipFieldLazyMetadata: false
+    }) {
+        types = this.concatPrototypes(types);
+        let loadersToExecute = (0, common_1.flatten)(types
+            .map(target => this.lazyMetadataByTarget.get(target))
+            .filter(metadata => metadata));
+        loadersToExecute = loadersToExecute?.concat(...(this.lazyMetadataByTarget.get(NO_TARGET_METADATA) || []));
+        if (!options.skipFieldLazyMetadata) {
+            loadersToExecute = loadersToExecute?.concat(...(this.lazyMetadataByTarget.get(FIELD_LAZY_METADATA) || []));
+        }
+        loadersToExecute?.forEach(func => func());
+    }
+    concatPrototypes(types) {
+        const typesWithPrototypes = types
+            .filter(type => type && type.prototype)
+            .map(type => {
+            const parentTypes = [];
+            let parent = type;
+            while (!(0, common_1.isUndefined)(parent.prototype)) {
+                parent = Object.getPrototypeOf(parent);
+                if (parent === Function.prototype) {
+                    break;
+                }
+                parentTypes.push(parent);
+            }
+            parentTypes.push(type);
+            return parentTypes;
+        });
+        return (0, common_1.flatten)(typesWithPrototypes);
+    }
+    updateStorage(key, func) {
+        const existingArray = this.lazyMetadataByTarget.get(key);
+        if (existingArray) {
+            existingArray.push(func);
+        }
+        else {
+            this.lazyMetadataByTarget.set(key, [func]);
+        }
+    }
+}
+exports.LazyMetadataStorageHost = LazyMetadataStorageHost;
+const globalRef = global;
+exports.LazyMetadataStorage = globalRef.GqlLazyMetadataStorageHost ||
+    (globalRef.GqlLazyMetadataStorageHost = new LazyMetadataStorageHost());

package/dist/core/Nestjs/types/metadata/class.metadata.d.ts

@@ -0,0 +1,11 @@
+import { DirectiveMetadata } from './directive.metadata';
+import { PropertyMetadata } from './property.metadata';
+export interface ClassMetadata {
+    target: Function;
+    name: string;
+    description?: string;
+    isAbstract?: boolean;
+    directives?: DirectiveMetadata[];
+    extensions?: Record<string, unknown>;
+    properties?: PropertyMetadata[];
+}

package/dist/core/Nestjs/types/metadata/class.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/directive.metadata.d.ts

@@ -0,0 +1,8 @@
+export interface DirectiveMetadata {
+    sdl: string;
+    target: Function;
+}
+export declare type ClassDirectiveMetadata = DirectiveMetadata;
+export interface PropertyDirectiveMetadata extends DirectiveMetadata {
+    fieldName: string;
+}

package/dist/core/Nestjs/types/metadata/directive.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/enum.metadata.d.ts

@@ -0,0 +1,11 @@
+export interface EnumMetadataValuesMapOptions {
+    deprecationReason?: string;
+    description?: string;
+}
+export declare type EnumMetadataValuesMap<T extends object> = Partial<Record<keyof T, EnumMetadataValuesMapOptions>>;
+export interface EnumMetadata<T extends object = any> {
+    ref: T;
+    name: string;
+    description?: string;
+    valuesMap?: EnumMetadataValuesMap<T>;
+}

package/dist/core/Nestjs/types/metadata/enum.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/extensions.metadata.d.ts

@@ -0,0 +1,8 @@
+export interface ExtensionsMetadata {
+    target: Function;
+    value: Record<string, unknown>;
+}
+export declare type ClassExtensionsMetadata = ExtensionsMetadata;
+export interface PropertyExtensionsMetadata extends ExtensionsMetadata {
+    fieldName: string;
+}

package/dist/core/Nestjs/types/metadata/extensions.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/index.d.ts

@@ -0,0 +1,8 @@
+export * from './class.metadata';
+export * from './directive.metadata';
+export * from './enum.metadata';
+export * from './extensions.metadata';
+export * from './param.metadata';
+export * from './property.metadata';
+export * from './resolver.metadata';
+export * from './union.metadata';

package/dist/core/Nestjs/types/metadata/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./class.metadata"), exports);
+tslib_1.__exportStar(require("./directive.metadata"), exports);
+tslib_1.__exportStar(require("./enum.metadata"), exports);
+tslib_1.__exportStar(require("./extensions.metadata"), exports);
+tslib_1.__exportStar(require("./param.metadata"), exports);
+tslib_1.__exportStar(require("./property.metadata"), exports);
+tslib_1.__exportStar(require("./resolver.metadata"), exports);
+tslib_1.__exportStar(require("./union.metadata"), exports);

package/dist/core/Nestjs/types/metadata/interface.metadata.d.ts

@@ -0,0 +1,6 @@
+import { ResolveTypeFn } from '../interfaces/resolve-type-fn.interface';
+import { ClassMetadata } from './class.metadata';
+export interface InterfaceMetadata extends ClassMetadata {
+    resolveType?: ResolveTypeFn;
+    interfaces?: Function | Function[] | (() => Function | Function[]);
+}

package/dist/core/Nestjs/types/metadata/interface.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/object-type.metadata.d.ts

@@ -0,0 +1,4 @@
+import { ClassMetadata } from './class.metadata';
+export interface ObjectTypeMetadata extends ClassMetadata {
+    interfaces?: Function | Function[] | (() => Function | Function[]);
+}

package/dist/core/Nestjs/types/metadata/object-type.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/param.metadata.d.ts

@@ -0,0 +1,18 @@
+import { GqlTypeReference } from '../interfaces/return-type-func.interface';
+import { TypeOptions } from '../interfaces/type-options.interface';
+export interface BaseArgMetadata {
+    target: Function;
+    methodName: string;
+    typeFn: (type?: any) => GqlTypeReference;
+    options: TypeOptions;
+    index: number;
+}
+export interface ArgParamMetadata extends BaseArgMetadata {
+    kind: 'arg';
+    name: string;
+    description?: string;
+}
+export interface ArgsParamMetadata extends BaseArgMetadata {
+    kind: 'args';
+}
+export declare type MethodArgsMetadata = ArgParamMetadata | ArgsParamMetadata;

package/dist/core/Nestjs/types/metadata/param.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/property.metadata.d.ts

@@ -0,0 +1,20 @@
+import { GqlTypeReference } from '../interfaces/return-type-func.interface';
+import { FieldMiddleware } from '../interfaces/field-middleware.interface';
+import { TypeOptions } from '../interfaces/type-options.interface';
+import { DirectiveMetadata } from './directive.metadata';
+import { MethodArgsMetadata } from './param.metadata';
+import { Complexity } from '../interfaces/complexity.interface';
+export interface PropertyMetadata {
+    schemaName: string;
+    name: string;
+    typeFn: () => GqlTypeReference;
+    target: Function;
+    options: TypeOptions;
+    description?: string;
+    deprecationReason?: string;
+    methodArgs?: MethodArgsMetadata[];
+    directives?: DirectiveMetadata[];
+    extensions?: Record<string, unknown>;
+    complexity?: Complexity;
+    middleware?: FieldMiddleware[];
+}

package/dist/core/Nestjs/types/metadata/property.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/resolver.metadata.d.ts

@@ -0,0 +1,34 @@
+import { GqlTypeReference } from '../interfaces/return-type-func.interface';
+import { TypeOptions } from '../interfaces/type-options.interface';
+import { Type } from '../common';
+import { DirectiveMetadata } from './directive.metadata';
+import { MethodArgsMetadata } from './param.metadata';
+import { Complexity } from '../interfaces/complexity.interface';
+export interface ResolverClassMetadata {
+    target: Function;
+    typeFn: (of?: void) => Type<unknown> | Function;
+    isAbstract?: boolean;
+    parent?: ResolverClassMetadata;
+}
+export interface BaseResolverMetadata {
+    target: Function;
+    methodName: string;
+    schemaName: string;
+    description?: string;
+    deprecationReason?: string;
+    methodArgs?: MethodArgsMetadata[];
+    classMetadata?: ResolverClassMetadata;
+    directives?: DirectiveMetadata[];
+    extensions?: Record<string, unknown>;
+    complexity?: Complexity;
+}
+export interface ResolverTypeMetadata extends BaseResolverMetadata {
+    typeFn: (type?: void) => GqlTypeReference;
+    returnTypeOptions: TypeOptions;
+}
+export interface FieldResolverMetadata extends BaseResolverMetadata {
+    kind: 'internal' | 'external';
+    typeOptions?: TypeOptions;
+    typeFn?: (type?: void) => GqlTypeReference;
+    objectTypeFn?: (of?: void) => Type<unknown> | Function;
+}

package/dist/core/Nestjs/types/metadata/resolver.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/metadata/union.metadata.d.ts

@@ -0,0 +1,9 @@
+import { Type } from '../common';
+import { ResolveTypeFn } from '../interfaces/resolve-type-fn.interface';
+export interface UnionMetadata<T extends Type<unknown>[] = Type<unknown>[]> {
+    name: string;
+    typesFn: () => T;
+    id?: symbol;
+    description?: string;
+    resolveType?: ResolveTypeFn;
+}

package/dist/core/Nestjs/types/metadata/union.metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/object-type.decorator.d.ts

@@ -0,0 +1,8 @@
+export interface ObjectTypeOptions {
+    description?: string;
+    isAbstract?: boolean;
+    implements?: Function | Function[] | (() => Function | Function[]);
+}
+export declare function ObjectType(): ClassDecorator;
+export declare function ObjectType(options: ObjectTypeOptions): ClassDecorator;
+export declare function ObjectType(name: string, options?: ObjectTypeOptions): ClassDecorator;

package/dist/core/Nestjs/types/object-type.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectType = void 0;
+const lazy_metadata_storage_1 = require("./lazy-metadata.storage");
+const type_metadata_storage_1 = require("./type-metadata.storage");
+const add_class_type_metadata_util_1 = require("./interfaces/add-class-type-metadata.util");
+const common_1 = require("./common");
+function ObjectType(nameOrOptions, objectTypeOptions) {
+    const [name, options = {}] = (0, common_1.isString)(nameOrOptions)
+        ? [nameOrOptions, objectTypeOptions]
+        : [undefined, nameOrOptions];
+    return target => {
+        const addObjectTypeMetadata = () => type_metadata_storage_1.TypeMetadataStorage.addObjectTypeMetadata({
+            name: name || target.name,
+            target,
+            description: options.description,
+            interfaces: options.implements,
+            isAbstract: options.isAbstract
+        });
+        addObjectTypeMetadata();
+        lazy_metadata_storage_1.LazyMetadataStorage.store(addObjectTypeMetadata);
+        (0, add_class_type_metadata_util_1.addClassTypeMetadata)(target, common_1.ClassType.OBJECT);
+    };
+}
+exports.ObjectType = ObjectType;

package/dist/core/Nestjs/types/omit-type.d.ts

@@ -0,0 +1,2 @@
+import { Type } from './common';
+export declare function OmitType<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Omit<T, typeof keys[number]>>;

package/dist/core/Nestjs/types/omit-type.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitType = void 0;
+const api_property_decorator_1 = require("./decorators/api-property.decorator");
+const mapped_types_utils_1 = require("./utils/mapped-types.utils");
+const model_properties_accessor_1 = require("./utils/model-properties-accessor");
+const apply_is_optional_decorator_1 = require("./decorators/apply-is-optional.decorator");
+const omit = (obj, props) => {
+    obj = { ...obj };
+    props.forEach(prop => delete obj[prop]);
+    return obj;
+};
+const modelPropertiesAccessor = new model_properties_accessor_1.ModelPropertiesAccessor();
+function OmitType(classRef, keys) {
+    const fields = modelPropertiesAccessor
+        .getModelProperties(classRef.prototype)
+        .filter(item => !keys.includes(item));
+    const isInheritedPredicate = (propertyKey) => !keys.includes(propertyKey);
+    class OmitTypeClass {
+        constructor() {
+            (0, apply_is_optional_decorator_1.inheritPropertyInitializers)(this, classRef, isInheritedPredicate);
+        }
+    }
+    (0, apply_is_optional_decorator_1.inheritValidationMetadata)(classRef, OmitTypeClass, isInheritedPredicate);
+    (0, apply_is_optional_decorator_1.inheritTransformationMetadata)(classRef, OmitTypeClass, isInheritedPredicate);
+    (0, mapped_types_utils_1.clonePluginMetadataFactory)(OmitTypeClass, classRef.prototype, (metadata) => omit(metadata, keys));
+    fields.forEach(propertyKey => {
+        const metadata = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES, classRef.prototype, propertyKey);
+        const decoratorFactory = (0, api_property_decorator_1.ApiProperty)(metadata);
+        decoratorFactory(OmitTypeClass.prototype, propertyKey);
+    });
+    return OmitTypeClass;
+}
+exports.OmitType = OmitType;