🎯 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/common/cache/cache.constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+export declare const CACHE_MANAGER = "CACHE_MANAGER";
+export declare const CACHE_KEY_METADATA = "cache_module:cache_key";
+export declare const CACHE_TTL_METADATA = "cache_module:cache_ttl";
+/**
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+export declare const CACHE_MODULE_OPTIONS: string | symbol;

backend/node_modules/@nestjs/common/cache/cache.constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_MODULE_OPTIONS = exports.CACHE_TTL_METADATA = exports.CACHE_KEY_METADATA = exports.CACHE_MANAGER = void 0;
+const cache_module_definition_1 = require("./cache.module-definition");
+/**
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+exports.CACHE_MANAGER = 'CACHE_MANAGER';
+exports.CACHE_KEY_METADATA = 'cache_module:cache_key';
+exports.CACHE_TTL_METADATA = 'cache_module:cache_ttl';
+/**
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+exports.CACHE_MODULE_OPTIONS = cache_module_definition_1.MODULE_OPTIONS_TOKEN;

backend/node_modules/@nestjs/common/cache/cache.module-definition.d.ts

@@ -0,0 +1,2 @@
+import { CacheModuleOptions } from './interfaces/cache-module.interface';
+export declare const ConfigurableModuleClass: import("../module-utils").ConfigurableModuleCls<CacheModuleOptions, "register", "createCacheOptions", {}>, MODULE_OPTIONS_TOKEN: string | symbol;

backend/node_modules/@nestjs/common/cache/cache.module-definition.js

@@ -0,0 +1,10 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
+const module_utils_1 = require("../module-utils");
+_a = new module_utils_1.ConfigurableModuleBuilder({
+    moduleName: 'Cache',
+})
+    .setFactoryMethodName('createCacheOptions')
+    .build(), exports.ConfigurableModuleClass = _a.ConfigurableModuleClass, exports.MODULE_OPTIONS_TOKEN = _a.MODULE_OPTIONS_TOKEN;

backend/node_modules/@nestjs/common/cache/cache.module.d.ts

@@ -0,0 +1,29 @@
+import { DynamicModule } from '../interfaces';
+import { ConfigurableModuleClass } from './cache.module-definition';
+import { CacheModuleAsyncOptions, CacheModuleOptions } from './interfaces/cache-module.interface';
+/**
+ * Module that provides Nest cache-manager.
+ *
+ * @see [Caching](https://docs.nestjs.com/techniques/caching)
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+export declare class CacheModule extends ConfigurableModuleClass {
+    /**
+     * Configure the cache manager statically.
+     *
+     * @param options options to configure the cache manager
+     *
+     * @see [Customize caching](https://docs.nestjs.com/techniques/caching#customize-caching)
+     */
+    static register<StoreConfig extends Record<any, any> = Record<string, any>>(options?: CacheModuleOptions<StoreConfig>): DynamicModule;
+    /**
+     * Configure the cache manager dynamically.
+     *
+     * @param options method for dynamically supplying cache manager configuration
+     * options
+     *
+     * @see [Async configuration](https://docs.nestjs.com/techniques/caching#async-configuration)
+     */
+    static registerAsync<StoreConfig extends Record<any, any> = Record<string, any>>(options: CacheModuleAsyncOptions<StoreConfig>): DynamicModule;
+}

backend/node_modules/@nestjs/common/cache/cache.module.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheModule = void 0;
+const tslib_1 = require("tslib");
+const decorators_1 = require("../decorators");
+const cache_constants_1 = require("./cache.constants");
+const cache_module_definition_1 = require("./cache.module-definition");
+const cache_providers_1 = require("./cache.providers");
+/**
+ * Module that provides Nest cache-manager.
+ *
+ * @see [Caching](https://docs.nestjs.com/techniques/caching)
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+let CacheModule = class CacheModule extends cache_module_definition_1.ConfigurableModuleClass {
+    /**
+     * Configure the cache manager statically.
+     *
+     * @param options options to configure the cache manager
+     *
+     * @see [Customize caching](https://docs.nestjs.com/techniques/caching#customize-caching)
+     */
+    static register(options = {}) {
+        return Object.assign({ global: options.isGlobal }, super.register(options));
+    }
+    /**
+     * Configure the cache manager dynamically.
+     *
+     * @param options method for dynamically supplying cache manager configuration
+     * options
+     *
+     * @see [Async configuration](https://docs.nestjs.com/techniques/caching#async-configuration)
+     */
+    static registerAsync(options) {
+        const moduleDefinition = super.registerAsync(options);
+        return Object.assign(Object.assign({ global: options.isGlobal }, moduleDefinition), { providers: options.extraProviders
+                ? moduleDefinition.providers.concat(options.extraProviders)
+                : moduleDefinition.providers });
+    }
+};
+CacheModule = tslib_1.__decorate([
+    (0, decorators_1.Module)({
+        providers: [(0, cache_providers_1.createCacheManager)()],
+        exports: [cache_constants_1.CACHE_MANAGER],
+    })
+], CacheModule);
+exports.CacheModule = CacheModule;

backend/node_modules/@nestjs/common/cache/cache.providers.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from '../interfaces';
+/**
+ * Creates a CacheManager Provider.
+ *
+ * @publicApi
+ */
+export declare function createCacheManager(): Provider;

backend/node_modules/@nestjs/common/cache/cache.providers.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCacheManager = void 0;
+const load_package_util_1 = require("../utils/load-package.util");
+const cache_constants_1 = require("./cache.constants");
+const cache_module_definition_1 = require("./cache.module-definition");
+const default_options_1 = require("./default-options");
+/**
+ * Creates a CacheManager Provider.
+ *
+ * @publicApi
+ */
+function createCacheManager() {
+    return {
+        provide: cache_constants_1.CACHE_MANAGER,
+        useFactory: async (options) => {
+            const cacheManager = (0, load_package_util_1.loadPackage)('cache-manager', 'CacheModule', () => require('cache-manager'));
+            const cacheManagerIsv5OrGreater = 'memoryStore' in cacheManager;
+            const cachingFactory = async (store, options) => {
+                if (!cacheManagerIsv5OrGreater) {
+                    return cacheManager.caching(Object.assign(Object.assign({}, default_options_1.defaultCacheOptions), Object.assign(Object.assign({}, options), { store })));
+                }
+                let cache = 'memory';
+                default_options_1.defaultCacheOptions.ttl *= 1000;
+                if (typeof store === 'object') {
+                    if ('create' in store) {
+                        cache = store.create;
+                    }
+                    else {
+                        cache = store;
+                    }
+                }
+                else if (typeof store === 'function') {
+                    cache = store;
+                }
+                return cacheManager.caching(cache, Object.assign(Object.assign({}, default_options_1.defaultCacheOptions), options));
+            };
+            return Array.isArray(options)
+                ? cacheManager.multiCaching(await Promise.all(options.map(option => cachingFactory(option.store, option))))
+                : cachingFactory(options.store, options);
+        },
+        inject: [cache_module_definition_1.MODULE_OPTIONS_TOKEN],
+    };
+}
+exports.createCacheManager = createCacheManager;

backend/node_modules/@nestjs/common/cache/decorators/cache-key.decorator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decorator that sets the caching key used to store/retrieve cached items for
+ * Web sockets or Microservice based apps.
+ *
+ * For example:
+ * `@CacheKey('events')`
+ *
+ * @param key string naming the field to be used as a cache key
+ *
+ * @see [Caching](https://docs.nestjs.com/techniques/caching)
+ *
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+export declare const CacheKey: (key: string) => import("../../decorators").CustomDecorator<string>;

backend/node_modules/@nestjs/common/cache/decorators/cache-key.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheKey = void 0;
+const decorators_1 = require("../../decorators");
+const cache_constants_1 = require("../cache.constants");
+/**
+ * Decorator that sets the caching key used to store/retrieve cached items for
+ * Web sockets or Microservice based apps.
+ *
+ * For example:
+ * `@CacheKey('events')`
+ *
+ * @param key string naming the field to be used as a cache key
+ *
+ * @see [Caching](https://docs.nestjs.com/techniques/caching)
+ *
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+const CacheKey = (key) => (0, decorators_1.SetMetadata)(cache_constants_1.CACHE_KEY_METADATA, key);
+exports.CacheKey = CacheKey;

backend/node_modules/@nestjs/common/cache/decorators/cache-ttl.decorator.d.ts

@@ -0,0 +1,16 @@
+import { ExecutionContext } from '../../interfaces/features/execution-context.interface';
+/**
+ * Decorator that sets the cache ttl setting the duration for cache expiration.
+ *
+ * For example: `@CacheTTL(5)`
+ *
+ * @param ttl number set the cache expiration time
+ *
+ * @see [Caching](https://docs.nestjs.com/techniques/caching)
+ *
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+type CacheTTLFactory = (ctx: ExecutionContext) => Promise<number> | number;
+export declare const CacheTTL: (ttl: number | CacheTTLFactory) => import("../../decorators").CustomDecorator<string>;
+export {};

backend/node_modules/@nestjs/common/cache/decorators/cache-ttl.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheTTL = void 0;
+const decorators_1 = require("../../decorators");
+const cache_constants_1 = require("../cache.constants");
+const CacheTTL = (ttl) => (0, decorators_1.SetMetadata)(cache_constants_1.CACHE_TTL_METADATA, ttl);
+exports.CacheTTL = CacheTTL;

backend/node_modules/@nestjs/common/cache/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cache-key.decorator';
+export * from './cache-ttl.decorator';

backend/node_modules/@nestjs/common/cache/decorators/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./cache-key.decorator"), exports);
+tslib_1.__exportStar(require("./cache-ttl.decorator"), exports);

backend/node_modules/@nestjs/common/cache/default-options.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultCacheOptions: {
+    ttl: number;
+    max: number;
+    store: string;
+};

backend/node_modules/@nestjs/common/cache/default-options.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCacheOptions = void 0;
+exports.defaultCacheOptions = {
+    ttl: 5,
+    max: 100,
+    store: 'memory',
+};

backend/node_modules/@nestjs/common/cache/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cache.constants';
+export * from './cache.module';
+export * from './decorators';
+export * from './interceptors';
+export * from './interfaces';

backend/node_modules/@nestjs/common/cache/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./cache.constants"), exports);
+tslib_1.__exportStar(require("./cache.module"), exports);
+tslib_1.__exportStar(require("./decorators"), exports);
+tslib_1.__exportStar(require("./interceptors"), exports);
+tslib_1.__exportStar(require("./interfaces"), exports);

backend/node_modules/@nestjs/common/cache/interceptors/cache.interceptor.d.ts

@@ -0,0 +1,23 @@
+import { Observable } from 'rxjs';
+import { CallHandler, ExecutionContext, HttpServer, NestInterceptor } from '../../interfaces';
+/** @deprecated Import from the "@nestjs/core" instead. */
+export interface HttpAdapterHost<T extends HttpServer = any> {
+    httpAdapter: T;
+}
+/**
+ * @see [Caching](https://docs.nestjs.com/techniques/caching)
+ *
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+export declare class CacheInterceptor implements NestInterceptor {
+    protected readonly cacheManager: any;
+    protected readonly reflector: any;
+    protected readonly httpAdapterHost: HttpAdapterHost;
+    protected allowedMethods: string[];
+    private cacheManagerIsv5OrGreater;
+    constructor(cacheManager: any, reflector: any);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
+    protected trackBy(context: ExecutionContext): string | undefined;
+    protected isRequestCacheable(context: ExecutionContext): boolean;
+}

backend/node_modules/@nestjs/common/cache/interceptors/cache.interceptor.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheInterceptor = void 0;
+const tslib_1 = require("tslib");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const decorators_1 = require("../../decorators");
+const file_stream_1 = require("../../file-stream");
+const logger_service_1 = require("../../services/logger.service");
+const load_package_util_1 = require("../../utils/load-package.util");
+const shared_utils_1 = require("../../utils/shared.utils");
+const cache_constants_1 = require("../cache.constants");
+/** @deprecated */
+const HTTP_ADAPTER_HOST = 'HttpAdapterHost';
+/** @deprecated */
+const REFLECTOR = 'Reflector';
+/**
+ * @see [Caching](https://docs.nestjs.com/techniques/caching)
+ *
+ * @deprecated `CacheModule` (from the `@nestjs/common` package) is deprecated and will be removed in the next major release. Please, use the `@nestjs/cache-manager` package instead
+ * @publicApi
+ */
+let CacheInterceptor = class CacheInterceptor {
+    constructor(cacheManager, reflector) {
+        this.cacheManager = cacheManager;
+        this.reflector = reflector;
+        this.allowedMethods = ['GET'];
+        // We need to check if the cache-manager package is v5 or greater
+        // because the set method signature changed in v5
+        const cacheManagerPackage = (0, load_package_util_1.loadPackage)('cache-manager', 'CacheModule', () => require('cache-manager'));
+        this.cacheManagerIsv5OrGreater = 'memoryStore' in cacheManagerPackage;
+        logger_service_1.Logger.warn('DEPRECATED! "CacheModule" (from the "@nestjs/common" package) is deprecated and will be removed in the next major release. Please, use the "@nestjs/cache-manager" package instead.');
+    }
+    async intercept(context, next) {
+        var _a;
+        const key = this.trackBy(context);
+        const ttlValueOrFactory = (_a = this.reflector.get(cache_constants_1.CACHE_TTL_METADATA, context.getHandler())) !== null && _a !== void 0 ? _a : null;
+        if (!key) {
+            return next.handle();
+        }
+        try {
+            const value = await this.cacheManager.get(key);
+            if (!(0, shared_utils_1.isNil)(value)) {
+                return (0, rxjs_1.of)(value);
+            }
+            const ttl = (0, shared_utils_1.isFunction)(ttlValueOrFactory)
+                ? await ttlValueOrFactory(context)
+                : ttlValueOrFactory;
+            return next.handle().pipe((0, operators_1.tap)(async (response) => {
+                if (response instanceof file_stream_1.StreamableFile) {
+                    return;
+                }
+                const args = [key, response];
+                if (!(0, shared_utils_1.isNil)(ttl)) {
+                    args.push(this.cacheManagerIsv5OrGreater ? ttl : { ttl });
+                }
+                try {
+                    await this.cacheManager.set(...args);
+                }
+                catch (err) {
+                    logger_service_1.Logger.error(`An error has occurred when inserting "key: ${key}", "value: ${response}"`, 'CacheInterceptor');
+                }
+            }));
+        }
+        catch (_b) {
+            return next.handle();
+        }
+    }
+    trackBy(context) {
+        const httpAdapter = this.httpAdapterHost.httpAdapter;
+        const isHttpApp = httpAdapter && !!httpAdapter.getRequestMethod;
+        const cacheMetadata = this.reflector.get(cache_constants_1.CACHE_KEY_METADATA, context.getHandler());
+        if (!isHttpApp || cacheMetadata) {
+            return cacheMetadata;
+        }
+        const request = context.getArgByIndex(0);
+        if (!this.isRequestCacheable(context)) {
+            return undefined;
+        }
+        return httpAdapter.getRequestUrl(request);
+    }
+    isRequestCacheable(context) {
+        const req = context.switchToHttp().getRequest();
+        return this.allowedMethods.includes(req.method);
+    }
+};
+tslib_1.__decorate([
+    (0, decorators_1.Optional)(),
+    (0, decorators_1.Inject)(HTTP_ADAPTER_HOST),
+    tslib_1.__metadata("design:type", Object)
+], CacheInterceptor.prototype, "httpAdapterHost", void 0);
+CacheInterceptor = tslib_1.__decorate([
+    (0, decorators_1.Injectable)(),
+    tslib_1.__param(0, (0, decorators_1.Inject)(cache_constants_1.CACHE_MANAGER)),
+    tslib_1.__param(1, (0, decorators_1.Inject)(REFLECTOR)),
+    tslib_1.__metadata("design:paramtypes", [Object, Object])
+], CacheInterceptor);
+exports.CacheInterceptor = CacheInterceptor;

backend/node_modules/@nestjs/common/cache/interceptors/index.d.ts

@@ -0,0 +1 @@
+export * from './cache.interceptor';

backend/node_modules/@nestjs/common/cache/interceptors/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./cache.interceptor"), exports);

backend/node_modules/@nestjs/common/cache/interfaces/cache-manager.interface.d.ts

@@ -0,0 +1,76 @@
+export interface LiteralObject {
+    [key: string]: any;
+}
+/**
+ * Interface defining a cache store. Implement this interface to create a custom
+ * cache store.
+ *
+ * @publicApi
+ */
+export interface CacheStore {
+    /**
+     * Create a key/value pair in the cache.
+     *
+     * @param key cache key
+     * @param value cache value
+     */
+    set<T>(key: string, value: T, options?: CacheStoreSetOptions<T> | number): Promise<void> | void;
+    /**
+     * Retrieve a key/value pair from the cache.
+     *
+     * @param key cache key
+     */
+    get<T>(key: string): Promise<T | undefined> | T | undefined;
+    /**
+     * Destroy a key/value pair from the cache.
+     *
+     * @param key cache key
+     */
+    del?(key: string): void | Promise<void>;
+}
+export interface CacheStoreSetOptions<T> {
+    /**
+     * Time to live - amount of time in seconds that a response is cached before it
+     * is deleted. Defaults based on your cache manager settings.
+     */
+    ttl?: ((value: T) => number) | number;
+}
+/**
+ * Interface defining a factory to create a cache store.
+ *
+ * @publicApi
+ */
+export type CacheStoreFactory = {
+    /**
+     * Return a configured cache store.
+     *
+     * @param args Cache manager options received from `CacheModule.register()`
+     * or `CacheModule.registerAsync()`
+     */
+    create(args: LiteralObject): CacheStore;
+} | ((args: LiteralObject) => CacheStore | Promise<CacheStore>);
+/**
+ * Interface defining Cache Manager configuration options.
+ *
+ * @publicApi
+ */
+export interface CacheManagerOptions {
+    /**
+     * Cache storage manager.  Default is `'memory'` (in-memory store).  See
+     * [Different stores](https://docs.nestjs.com/techniques/caching#different-stores)
+     * for more info.
+     */
+    store?: string | CacheStoreFactory | CacheStore;
+    /**
+     * Time to live - amount of time that a response is cached before it
+     * is deleted. Subsequent request will call through the route handler and refresh
+     * the cache.  Defaults to 5 seconds. In `cache-manager@^4` this value is in seconds.
+     * In `cache-manager@^5` this value is in milliseconds.
+     */
+    ttl?: number;
+    /**
+     * Maximum number of responses to store in the cache.  Defaults to 100.
+     */
+    max?: number;
+    isCacheableValue?: (value: any) => boolean;
+}

backend/node_modules/@nestjs/common/cache/interfaces/cache-manager.interface.js

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

backend/node_modules/@nestjs/common/cache/interfaces/cache-module.interface.d.ts

@@ -0,0 +1,56 @@
+import { Provider, Type } from '../../interfaces';
+import { ConfigurableModuleAsyncOptions } from '../../module-utils';
+import { CacheManagerOptions } from './cache-manager.interface';
+export type CacheModuleOptions<StoreConfig extends Record<any, any> = Record<string, any>> = CacheManagerOptions & StoreConfig & {
+    /**
+     * If "true', register `CacheModule` as a global module.
+     */
+    isGlobal?: boolean;
+};
+/**
+ * Interface describing a `CacheOptionsFactory`.  Providers supplying configuration
+ * options for the Cache module must implement this interface.
+ *
+ * @see [Async configuration](https://docs.nestjs.com/techniques/caching#async-configuration)
+ *
+ * @publicApi
+ */
+export interface CacheOptionsFactory<StoreConfig extends Record<any, any> = Record<string, any>> {
+    createCacheOptions(): Promise<CacheModuleOptions<StoreConfig>> | CacheModuleOptions<StoreConfig>;
+}
+/**
+ * Options for dynamically configuring the Cache module.
+ *
+ * @see [Async configuration](https://docs.nestjs.com/techniques/caching#async-configuration)
+ *
+ * @publicApi
+ */
+export interface CacheModuleAsyncOptions<StoreConfig extends Record<any, any> = Record<string, any>> extends ConfigurableModuleAsyncOptions<CacheModuleOptions<StoreConfig>, keyof CacheOptionsFactory> {
+    /**
+     * Injection token resolving to an existing provider. The provider must implement
+     * the `CacheOptionsFactory` interface.
+     */
+    useExisting?: Type<CacheOptionsFactory<StoreConfig>>;
+    /**
+     * Injection token resolving to a class that will be instantiated as a provider.
+     * The class must implement the `CacheOptionsFactory` interface.
+     */
+    useClass?: Type<CacheOptionsFactory<StoreConfig>>;
+    /**
+     * Function returning options (or a Promise resolving to options) to configure the
+     * cache module.
+     */
+    useFactory?: (...args: any[]) => Promise<CacheModuleOptions<StoreConfig>> | CacheModuleOptions<StoreConfig>;
+    /**
+     * Dependencies that a Factory may inject.
+     */
+    inject?: any[];
+    /**
+     * Extra providers to be registered within a scope of this module.
+     */
+    extraProviders?: Provider[];
+    /**
+     * If "true', register `CacheModule` as a global module.
+     */
+    isGlobal?: boolean;
+}

backend/node_modules/@nestjs/common/cache/interfaces/cache-module.interface.js

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

backend/node_modules/@nestjs/common/cache/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cache-manager.interface';
+export * from './cache-module.interface';

backend/node_modules/@nestjs/common/cache/interfaces/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./cache-manager.interface"), exports);
+tslib_1.__exportStar(require("./cache-module.interface"), exports);