🎯 MapView v2.0 - Global Deployment Ready

✨ MAJOR FEATURES:
• Auto-zoom intelligence với smart bounds fitting
• Enhanced 3D GPS markers với pulsing effects
• Professional route display với 6-layer rendering
• Status-based parking icons với availability indicators
• Production-ready build optimizations

🗺️ AUTO-ZOOM FEATURES:
• Smart bounds fitting cho GPS + selected parking
• Adaptive padding (50px) cho visual balance
• Max zoom control (level 16) để tránh quá gần
• Dynamic centering khi không có selection

🎨 ENHANCED VISUALS:
• 3D GPS marker với multi-layer pulse effects
• Advanced parking icons với status colors
• Selection highlighting với animation
• Dimming system cho non-selected items

🛣️ ROUTE SYSTEM:
• OpenRouteService API integration
• Multi-layer route rendering (glow, shadow, main, animated)
• Real-time distance & duration calculation
• Visual route info trong popup

📱 PRODUCTION READY:
• SSR safe với dynamic imports
• Build errors resolved
• Global deployment via Vercel
• Optimized performance

🌍 DEPLOYMENT:
• Vercel: https://whatever-ctk2auuxr-phong12hexdockworks-projects.vercel.app
• Bundle size: 22.8 kB optimized
• Global CDN distribution
• HTTPS enabled

💾 VERSION CONTROL:
• MapView-v2.0.tsx backup created
• MAPVIEW_VERSIONS.md documentation
• Full version history tracking

backend/node_modules/@nestjs/swagger/dist/explorers/api-consumes.explorer.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiConsumesMetadata: (metatype: Type<unknown>) => {
+    consumes: any;
+};
+export declare const exploreApiConsumesMetadata: (instance: object, prototype: Type<unknown>, method: object) => string[] | undefined;

backend/node_modules/@nestjs/swagger/dist/explorers/api-consumes.explorer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiConsumesMetadata = exports.exploreGlobalApiConsumesMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiConsumesMetadata = (metatype) => {
+    const consumes = Reflect.getMetadata(constants_1.DECORATORS.API_CONSUMES, metatype);
+    return consumes ? { consumes } : undefined;
+};
+exports.exploreGlobalApiConsumesMetadata = exploreGlobalApiConsumesMetadata;
+const exploreApiConsumesMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_CONSUMES, method);
+exports.exploreApiConsumesMetadata = exploreApiConsumesMetadata;

backend/node_modules/@nestjs/swagger/dist/explorers/api-exclude-controller.explorer.d.ts

@@ -0,0 +1,2 @@
+import { Type } from '@nestjs/common';
+export declare const exploreApiExcludeControllerMetadata: (metatype: Type<unknown>) => boolean;

backend/node_modules/@nestjs/swagger/dist/explorers/api-exclude-controller.explorer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiExcludeControllerMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreApiExcludeControllerMetadata = (metatype) => {
+    var _a;
+    return ((_a = Reflect.getMetadata(constants_1.DECORATORS.API_EXCLUDE_CONTROLLER, metatype)) === null || _a === void 0 ? void 0 : _a[0]) ===
+        true;
+};
+exports.exploreApiExcludeControllerMetadata = exploreApiExcludeControllerMetadata;

backend/node_modules/@nestjs/swagger/dist/explorers/api-exclude-endpoint.explorer.d.ts

@@ -0,0 +1,2 @@
+import { Type } from '@nestjs/common';
+export declare const exploreApiExcludeEndpointMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

backend/node_modules/@nestjs/swagger/dist/explorers/api-exclude-endpoint.explorer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiExcludeEndpointMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreApiExcludeEndpointMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_EXCLUDE_ENDPOINT, method);
+exports.exploreApiExcludeEndpointMetadata = exploreApiExcludeEndpointMetadata;

backend/node_modules/@nestjs/swagger/dist/explorers/api-extra-models.explorer.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiExtraModelsMetadata: (metatype: Type<unknown>) => Function[];
+export declare const exploreApiExtraModelsMetadata: (instance: object, prototype: Type<unknown>, method: object) => Function[];

backend/node_modules/@nestjs/swagger/dist/explorers/api-extra-models.explorer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiExtraModelsMetadata = exports.exploreGlobalApiExtraModelsMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiExtraModelsMetadata = (metatype) => {
+    const extraModels = Reflect.getMetadata(constants_1.DECORATORS.API_EXTRA_MODELS, metatype);
+    return extraModels || [];
+};
+exports.exploreGlobalApiExtraModelsMetadata = exploreGlobalApiExtraModelsMetadata;
+const exploreApiExtraModelsMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_EXTRA_MODELS, method) || [];
+exports.exploreApiExtraModelsMetadata = exploreApiExtraModelsMetadata;

backend/node_modules/@nestjs/swagger/dist/explorers/api-headers.explorer.d.ts

@@ -0,0 +1,7 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiHeaderMetadata: (metatype: Type<unknown>) => {
+    root: {
+        parameters: any;
+    };
+    depth: number;
+};

backend/node_modules/@nestjs/swagger/dist/explorers/api-headers.explorer.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreGlobalApiHeaderMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiHeaderMetadata = (metatype) => {
+    const headers = Reflect.getMetadata(constants_1.DECORATORS.API_HEADERS, metatype);
+    return headers ? { root: { parameters: headers }, depth: 1 } : undefined;
+};
+exports.exploreGlobalApiHeaderMetadata = exploreGlobalApiHeaderMetadata;

backend/node_modules/@nestjs/swagger/dist/explorers/api-operation.explorer.d.ts

@@ -0,0 +1,2 @@
+import { Type } from '@nestjs/common';
+export declare const exploreApiOperationMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

backend/node_modules/@nestjs/swagger/dist/explorers/api-operation.explorer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiOperationMetadata = void 0;
+const constants_1 = require("../constants");
+const api_operation_decorator_1 = require("../decorators/api-operation.decorator");
+const plugin_constants_1 = require("../plugin/plugin-constants");
+const exploreApiOperationMetadata = (instance, prototype, method) => {
+    applyMetadataFactory(prototype, instance);
+    return Reflect.getMetadata(constants_1.DECORATORS.API_OPERATION, method);
+};
+exports.exploreApiOperationMetadata = exploreApiOperationMetadata;
+function applyMetadataFactory(prototype, instance) {
+    const classPrototype = prototype;
+    do {
+        if (!prototype.constructor) {
+            return;
+        }
+        if (!prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]) {
+            continue;
+        }
+        const metadata = prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]();
+        const methodKeys = Object.keys(metadata).filter((key) => typeof instance[key] === 'function');
+        methodKeys.forEach((key) => {
+            const operationMeta = {};
+            const { summary, deprecated, tags } = metadata[key];
+            applyIfNotNil(operationMeta, 'summary', summary);
+            applyIfNotNil(operationMeta, 'deprecated', deprecated);
+            applyIfNotNil(operationMeta, 'tags', tags);
+            if (Object.keys(operationMeta).length === 0) {
+                return;
+            }
+            (0, api_operation_decorator_1.ApiOperation)(operationMeta, { overrideExisting: false })(classPrototype, key, Object.getOwnPropertyDescriptor(classPrototype, key));
+        });
+    } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+        prototype !== Object.prototype &&
+        prototype);
+}
+function applyIfNotNil(target, key, value) {
+    if (value !== undefined && value !== null) {
+        target[key] = value;
+    }
+}

backend/node_modules/@nestjs/swagger/dist/explorers/api-parameters.explorer.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="lodash" />
+import { Type } from '@nestjs/common';
+import { SchemaObject } from '../interfaces/open-api-spec.interface';
+import { ParamWithTypeMetadata } from '../services/parameter-metadata-accessor';
+export declare const exploreApiParametersMetadata: (schemas: Record<string, SchemaObject>, instance: object, prototype: Type<unknown>, method: Function) => {
+    parameters: (Partial<import("../interfaces/open-api-spec.interface").BaseParameterObject> | Partial<ParamWithTypeMetadata> | {
+        schema: {
+            type: string;
+            items: any;
+            nullable?: boolean;
+            discriminator?: import("../interfaces/open-api-spec.interface").DiscriminatorObject;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            xml?: import("../interfaces/open-api-spec.interface").XmlObject;
+            externalDocs?: import("../interfaces/open-api-spec.interface").ExternalDocumentationObject;
+            example?: any;
+            examples?: any[] | Record<string, any>;
+            deprecated?: boolean;
+            allOf?: (SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject)[];
+            oneOf?: (SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject)[];
+            anyOf?: (SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject)[];
+            not?: SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject;
+            properties?: Record<string, SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject>;
+            additionalProperties?: boolean | SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject;
+            patternProperties?: 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[];
+        };
+    } | {
+        schema: import("lodash").Dictionary<any>;
+        description?: string;
+        required?: boolean;
+        deprecated?: boolean;
+        allowEmptyValue?: boolean;
+        style?: import("../interfaces/open-api-spec.interface").ParameterStyle;
+        explode?: boolean;
+        allowReserved?: boolean;
+        examples?: Record<string, import("../interfaces/open-api-spec.interface").ReferenceObject | import("../interfaces/open-api-spec.interface").ExampleObject>;
+        example?: any;
+        content?: import("../interfaces/open-api-spec.interface").ContentObject;
+    } | {
+        schema: import("lodash").Dictionary<any>;
+        name?: string | number | object;
+        type?: Type<unknown>;
+        in?: import("../interfaces/open-api-spec.interface").ParameterLocation | "body" | "placeholder";
+        isArray?: boolean;
+        items?: SchemaObject;
+        required?: true;
+        enum?: unknown[];
+        enumName?: string;
+    })[];
+};

backend/node_modules/@nestjs/swagger/dist/explorers/api-parameters.explorer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiParametersMetadata = void 0;
+const lodash_1 = require("lodash");
+const constants_1 = require("../constants");
+const model_properties_accessor_1 = require("../services/model-properties-accessor");
+const parameter_metadata_accessor_1 = require("../services/parameter-metadata-accessor");
+const parameters_metadata_mapper_1 = require("../services/parameters-metadata-mapper");
+const schema_object_factory_1 = require("../services/schema-object-factory");
+const swagger_types_mapper_1 = require("../services/swagger-types-mapper");
+const global_parameters_storage_1 = require("../storages/global-parameters.storage");
+const parameterMetadataAccessor = new parameter_metadata_accessor_1.ParameterMetadataAccessor();
+const modelPropertiesAccessor = new model_properties_accessor_1.ModelPropertiesAccessor();
+const parametersMetadataMapper = new parameters_metadata_mapper_1.ParametersMetadataMapper(modelPropertiesAccessor);
+const swaggerTypesMapper = new swagger_types_mapper_1.SwaggerTypesMapper();
+const schemaObjectFactory = new schema_object_factory_1.SchemaObjectFactory(modelPropertiesAccessor, swaggerTypesMapper);
+const exploreApiParametersMetadata = (schemas, instance, prototype, method) => {
+    const explicitParameters = Reflect.getMetadata(constants_1.DECORATORS.API_PARAMETERS, method);
+    const globalParameters = global_parameters_storage_1.GlobalParametersStorage.getAll();
+    const parametersMetadata = parameterMetadataAccessor.explore(instance, prototype, method);
+    const noExplicitAndGlobalMetadata = (0, lodash_1.isNil)(explicitParameters) && (0, lodash_1.isNil)(globalParameters);
+    if (noExplicitAndGlobalMetadata && (0, lodash_1.isNil)(parametersMetadata)) {
+        return undefined;
+    }
+    const reflectedParametersAsProperties = parametersMetadataMapper.transformModelToProperties(parametersMetadata || {});
+    let properties = reflectedParametersAsProperties;
+    if (!noExplicitAndGlobalMetadata) {
+        const mergeImplicitAndExplicit = (item) => (0, lodash_1.assign)(item, (0, lodash_1.find)(explicitParameters, ['name', item.name]));
+        properties = removeBodyMetadataIfExplicitExists(properties, explicitParameters);
+        properties = (0, lodash_1.map)(properties, mergeImplicitAndExplicit);
+        properties = (0, lodash_1.unionWith)(properties, explicitParameters, globalParameters, (arrVal, othVal) => {
+            return arrVal.name === othVal.name && arrVal.in === othVal.in;
+        });
+    }
+    const paramsWithDefinitions = schemaObjectFactory.createFromModel(properties, schemas);
+    const parameters = swaggerTypesMapper.mapParamTypes(paramsWithDefinitions);
+    return parameters ? { parameters } : undefined;
+};
+exports.exploreApiParametersMetadata = exploreApiParametersMetadata;
+function removeBodyMetadataIfExplicitExists(properties, explicitParams) {
+    const isBodyReflected = (0, lodash_1.some)(properties, (p) => p.in === 'body');
+    const isBodyDefinedExplicitly = (0, lodash_1.some)(explicitParams, (p) => p.in === 'body');
+    if (isBodyReflected && isBodyDefinedExplicitly) {
+        return (0, lodash_1.omitBy)(properties, (p) => p.in === 'body');
+    }
+    return properties;
+}

backend/node_modules/@nestjs/swagger/dist/explorers/api-produces.explorer.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiProducesMetadata: (metatype: Type<unknown>) => {
+    produces: any;
+};
+export declare const exploreApiProducesMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

backend/node_modules/@nestjs/swagger/dist/explorers/api-produces.explorer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiProducesMetadata = exports.exploreGlobalApiProducesMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiProducesMetadata = (metatype) => {
+    const produces = Reflect.getMetadata(constants_1.DECORATORS.API_PRODUCES, metatype);
+    return produces ? { produces } : undefined;
+};
+exports.exploreGlobalApiProducesMetadata = exploreGlobalApiProducesMetadata;
+const exploreApiProducesMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_PRODUCES, method);
+exports.exploreApiProducesMetadata = exploreApiProducesMetadata;

backend/node_modules/@nestjs/swagger/dist/explorers/api-response.explorer.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="lodash" />
+import { Type } from '@nestjs/common';
+import { SchemaObject } from '../interfaces/open-api-spec.interface';
+export declare const exploreGlobalApiResponseMetadata: (schemas: Record<string, SchemaObject>, metatype: Type<unknown>) => {
+    responses: import("lodash").Dictionary<boolean>;
+};
+export declare const exploreApiResponseMetadata: (schemas: Record<string, SchemaObject>, instance: object, prototype: Type<unknown>, method: Function) => import("lodash").Dictionary<boolean> | {
+    [x: number]: {
+        description: string;
+    };
+};

backend/node_modules/@nestjs/swagger/dist/explorers/api-response.explorer.js

@@ -0,0 +1,94 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiResponseMetadata = exports.exploreGlobalApiResponseMetadata = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const lodash_1 = require("lodash");
+const constants_2 = require("../constants");
+const decorators_1 = require("../decorators");
+const plugin_constants_1 = require("../plugin/plugin-constants");
+const response_object_factory_1 = require("../services/response-object-factory");
+const merge_and_uniq_util_1 = require("../utils/merge-and-uniq.util");
+const responseObjectFactory = new response_object_factory_1.ResponseObjectFactory();
+const exploreGlobalApiResponseMetadata = (schemas, metatype) => {
+    const responses = Reflect.getMetadata(constants_2.DECORATORS.API_RESPONSE, metatype);
+    const produces = Reflect.getMetadata(constants_2.DECORATORS.API_PRODUCES, metatype);
+    return responses
+        ? {
+            responses: mapResponsesToSwaggerResponses(responses, schemas, produces)
+        }
+        : undefined;
+};
+exports.exploreGlobalApiResponseMetadata = exploreGlobalApiResponseMetadata;
+const exploreApiResponseMetadata = (schemas, instance, prototype, method) => {
+    applyMetadataFactory(prototype, instance);
+    const responses = Reflect.getMetadata(constants_2.DECORATORS.API_RESPONSE, method);
+    if (responses) {
+        const classProduces = Reflect.getMetadata(constants_2.DECORATORS.API_PRODUCES, prototype);
+        const methodProduces = Reflect.getMetadata(constants_2.DECORATORS.API_PRODUCES, method);
+        const produces = (0, merge_and_uniq_util_1.mergeAndUniq)((0, lodash_1.get)(classProduces, 'produces'), methodProduces);
+        return mapResponsesToSwaggerResponses(responses, schemas, produces);
+    }
+    const status = getStatusCode(method);
+    if (status) {
+        return { [status]: { description: '' } };
+    }
+    return undefined;
+};
+exports.exploreApiResponseMetadata = exploreApiResponseMetadata;
+const getStatusCode = (method) => {
+    const status = Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, method);
+    if (status) {
+        return status;
+    }
+    const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, method);
+    switch (requestMethod) {
+        case common_1.RequestMethod.POST:
+            return common_1.HttpStatus.CREATED;
+        default:
+            return common_1.HttpStatus.OK;
+    }
+};
+const omitParamType = (param) => (0, lodash_1.omit)(param, 'type');
+const mapResponsesToSwaggerResponses = (responses, schemas, produces = ['application/json']) => {
+    produces = (0, shared_utils_1.isEmpty)(produces) ? ['application/json'] : produces;
+    const openApiResponses = (0, lodash_1.mapValues)(responses, (response) => responseObjectFactory.create(response, produces, schemas));
+    return (0, lodash_1.mapValues)(openApiResponses, omitParamType);
+};
+function applyMetadataFactory(prototype, instance) {
+    const classPrototype = prototype;
+    do {
+        if (!prototype.constructor) {
+            return;
+        }
+        if (!prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]) {
+            continue;
+        }
+        const metadata = prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]();
+        const methodKeys = Object.keys(metadata).filter((key) => typeof instance[key] === 'function');
+        methodKeys.forEach((key) => {
+            const _a = metadata[key], { summary, deprecated, tags } = _a, meta = __rest(_a, ["summary", "deprecated", "tags"]);
+            if (Object.keys(meta).length === 0) {
+                return;
+            }
+            if (meta.status === undefined) {
+                meta.status = getStatusCode(instance[key]);
+            }
+            (0, decorators_1.ApiResponse)(meta, { overrideExisting: false })(classPrototype, key, Object.getOwnPropertyDescriptor(classPrototype, key));
+        });
+    } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+        prototype !== Object.prototype &&
+        prototype);
+}

backend/node_modules/@nestjs/swagger/dist/explorers/api-security.explorer.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiSecurityMetadata: (metatype: Type<unknown>) => {
+    security: any;
+};
+export declare const exploreApiSecurityMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

backend/node_modules/@nestjs/swagger/dist/explorers/api-security.explorer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiSecurityMetadata = exports.exploreGlobalApiSecurityMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiSecurityMetadata = (metatype) => {
+    const security = Reflect.getMetadata(constants_1.DECORATORS.API_SECURITY, metatype);
+    return security ? { security } : undefined;
+};
+exports.exploreGlobalApiSecurityMetadata = exploreGlobalApiSecurityMetadata;
+const exploreApiSecurityMetadata = (instance, prototype, method) => {
+    return Reflect.getMetadata(constants_1.DECORATORS.API_SECURITY, method);
+};
+exports.exploreApiSecurityMetadata = exploreApiSecurityMetadata;

backend/node_modules/@nestjs/swagger/dist/explorers/api-use-tags.explorer.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiTagsMetadata: (metatype: Type<unknown>) => {
+    tags: any;
+};
+export declare const exploreApiTagsMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

backend/node_modules/@nestjs/swagger/dist/explorers/api-use-tags.explorer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiTagsMetadata = exports.exploreGlobalApiTagsMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiTagsMetadata = (metatype) => {
+    const tags = Reflect.getMetadata(constants_1.DECORATORS.API_TAGS, metatype);
+    return tags ? { tags } : undefined;
+};
+exports.exploreGlobalApiTagsMetadata = exploreGlobalApiTagsMetadata;
+const exploreApiTagsMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_TAGS, method);
+exports.exploreApiTagsMetadata = exploreApiTagsMetadata;