@goatlab/fluent 0.7.38 → 0.7.40

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

@@ -0,0 +1,239 @@
+/**
+ * inspired by https://github.com/metadevpro/openapi3-ts
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/3.0.0-rc0/versions/3.0.md
+ */
+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 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 type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+export 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 type ContentObject = Record<string, MediaTypeObject>;
+export interface MediaTypeObject {
+    schema?: SchemaObject | ReferenceObject;
+    examples?: ExamplesObject;
+    example?: any;
+    encoding?: EncodingObject;
+}
+export 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 type CallbacksObject = Record<string, CallbackObject | ReferenceObject>;
+export type CallbackObject = Record<string, PathItemObject>;
+export type HeadersObject = Record<string, HeaderObject | ReferenceObject>;
+export interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+export type LinksObject = Record<string, LinkObject | ReferenceObject>;
+export interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject;
+    requestBody?: any | string;
+    description?: string;
+    server?: ServerObject;
+}
+export type LinkParametersObject = Record<string, any>;
+export type HeaderObject = BaseParameterObject;
+export interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+}
+export 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 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 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 type ScopesObject = Record<string, any>;
+export type SecurityRequirementObject = Record<string, string[]>;

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

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * inspired by https://github.com/metadevpro/openapi3-ts
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/3.0.0-rc0/versions/3.0.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=open-api-spec.interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"open-api-spec.interface.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/interfaces/open-api-spec.interface.ts"],"names":[],"mappings":";AAAA;;;GAGG"}

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

@@ -0,0 +1,2 @@
+import { GraphQLTypeResolver } from 'graphql';
+export 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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=resolve-type-fn.interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-type-fn.interface.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/interfaces/resolve-type-fn.interface.ts"],"names":[],"mappings":""}

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 type GqlTypeReference = Type<any> | GraphQLScalarType | Function | object | symbol;
+export type ReturnTypeFuncValue = GqlTypeReference | [GqlTypeReference];
+export type ReturnTypeFunc = (returns?: void) => ReturnTypeFuncValue;

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=return-type-func.interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"return-type-func.interface.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/interfaces/return-type-func.interface.ts"],"names":[],"mappings":""}

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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema-object-metadata.interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-object-metadata.interface.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/interfaces/schema-object-metadata.interface.ts"],"names":[],"mappings":""}

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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=type-options.interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-options.interface.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/interfaces/type-options.interface.ts"],"names":[],"mappings":""}

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,68 @@
+"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());
+//# sourceMappingURL=lazy-metadata.storage.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-metadata.storage.js","sourceRoot":"","sources":["../../../../src/core/Nestjs/types/lazy-metadata.storage.ts"],"names":[],"mappings":"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"}

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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=class.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"class.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/class.metadata.ts"],"names":[],"mappings":""}

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=directive.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directive.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/directive.metadata.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,11 @@
+export interface EnumMetadataValuesMapOptions {
+    deprecationReason?: string;
+    description?: string;
+}
+export 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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=enum.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enum.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/enum.metadata.ts"],"names":[],"mappings":""}

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=extensions.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/extensions.metadata.ts"],"names":[],"mappings":""}

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,12 @@
+"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);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/index.ts"],"names":[],"mappings":";;;AAAA,2DAAgC;AAChC,+DAAoC;AACpC,0DAA+B;AAC/B,gEAAqC;AACrC,2DAAgC;AAChC,8DAAmC;AACnC,8DAAmC;AACnC,2DAAgC"}

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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interface.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/interface.metadata.ts"],"names":[],"mappings":""}

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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=object-type.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object-type.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/object-type.metadata.ts"],"names":[],"mappings":""}

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 type MethodArgsMetadata = ArgParamMetadata | ArgsParamMetadata;

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=param.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"param.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/param.metadata.ts"],"names":[],"mappings":""}

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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=property.metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"property.metadata.js","sourceRoot":"","sources":["../../../../../src/core/Nestjs/types/metadata/property.metadata.ts"],"names":[],"mappings":""}

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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=resolver.metadata.js.map