itlab-internal-services 2.2.2 → 2.4.0

package/dist/modules/search/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchService = exports.SearchModule = exports.SearchableDocument = void 0;
+var search_models_1 = require("./search.models");
+Object.defineProperty(exports, "SearchableDocument", { enumerable: true, get: function () { return search_models_1.SearchableDocument; } });
+var search_module_1 = require("./search.module");
+Object.defineProperty(exports, "SearchModule", { enumerable: true, get: function () { return search_module_1.SearchModule; } });
+var search_service_1 = require("./search.service");
+Object.defineProperty(exports, "SearchService", { enumerable: true, get: function () { return search_service_1.SearchService; } });

package/dist/modules/search/search.models.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a searchable document.
+ *
+ * @class SearchableDocument
+ * @property {string} label - The label of the searchable document.
+ * @property {string} url - The url of the searchable document.
+ * @property {number} timestamp - The timestamp of the searchable document.
+ * @property {object} data - The data of the searchable document.
+ */
+export declare class SearchableDocument {
+    /** The label of the searchable document. */
+    label: string;
+    /** The url of the searchable document. */
+    url: string;
+    /** The timestamp of the searchable document. */
+    timestamp: number;
+    /** The data of the searchable document. */
+    data: object;
+}

package/dist/modules/{services/search-service/search-service.definitions.js → search/search.models.js}

@@ -11,6 +11,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchableDocument = void 0;
 const swagger_1 = require("@nestjs/swagger");
+/**
+ * Represents a searchable document.
+ *
+ * @class SearchableDocument
+ * @property {string} label - The label of the searchable document.
+ * @property {string} url - The url of the searchable document.
+ * @property {number} timestamp - The timestamp of the searchable document.
+ * @property {object} data - The data of the searchable document.
+ */
 class SearchableDocument {
 }
 __decorate([

package/dist/modules/search/search.module.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule } from '@nestjs/common';
+import { Targets } from '../../pipes';
+/**
+ * Search module
+ * @class SearchModule
+ */
+export declare class SearchModule {
+    /**
+     * Creates a global SearchModule
+     * @returns {DynamicModule} SearchModule
+     */
+    static forRoot(target: Targets): DynamicModule;
+    /**
+     * Creates a local SearchModule
+     * @returns {DynamicModule} SearchModule
+     */
+    static register(target: Targets): DynamicModule;
+}

package/dist/modules/search/search.module.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SearchModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchModule = void 0;
+const common_1 = require("@nestjs/common");
+const search_service_1 = require("./search.service");
+/**
+ * Search module
+ * @class SearchModule
+ */
+let SearchModule = SearchModule_1 = class SearchModule {
+    /**
+     * Creates a global SearchModule
+     * @returns {DynamicModule} SearchModule
+     */
+    static forRoot(target) {
+        return {
+            global: true,
+            module: SearchModule_1,
+            providers: [search_service_1.SearchService, { provide: 'SEARCH_TARGET', useValue: target }],
+            exports: [search_service_1.SearchService],
+        };
+    }
+    /**
+     * Creates a local SearchModule
+     * @returns {DynamicModule} SearchModule
+     */
+    static register(target) {
+        return {
+            global: true,
+            module: SearchModule_1,
+            providers: [search_service_1.SearchService, { provide: 'SEARCH_TARGET', useValue: target }],
+            exports: [search_service_1.SearchService],
+        };
+    }
+};
+SearchModule = SearchModule_1 = __decorate([
+    (0, common_1.Module)({})
+], SearchModule);
+exports.SearchModule = SearchModule;

package/dist/modules/search/search.service.d.ts

@@ -0,0 +1,35 @@
+import { ConfigService } from '@nestjs/config';
+import { Targets } from '../../pipes';
+import { SearchableDocument } from './search.models';
+/**
+ * Search service
+ * @class SearchService
+ */
+export declare class SearchService {
+    private readonly configService;
+    private readonly target;
+    /** The Logger instance */
+    private logger;
+    /**
+     * Constructor
+     * @param configService - the config service
+     */
+    constructor(configService: ConfigService, target: Targets);
+    /** The axios instance */
+    private axios;
+    /**
+     * Index/Update a document in elasticsearch
+     *
+     * @param {string} targetId - the ID of the target
+     * @param {SearchableDocument} document - the document to be indexed/updated
+     * @return {void}
+     */
+    index(targetId: string, document: SearchableDocument): void;
+    /**
+     * Remove a document from elasticsearch
+     *
+     * @param {string} targetId - the ID of the target to be removed
+     * @return {void}
+     */
+    remove(targetId: string): void;
+}

package/dist/modules/{services/search-service → search}/search.service.js

@@ -8,39 +8,68 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var SearchService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchService = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
-const env_1 = require("../../../env");
-const services_module_utils_1 = require("../services.module-utils");
+const axios_1 = require("../../axios");
+const env_1 = require("../../env");
+const pipes_1 = require("../../pipes");
+/**
+ * Search service
+ * @class SearchService
+ */
 let SearchService = SearchService_1 = class SearchService {
-    constructor(configService) {
+    /**
+     * Constructor
+     * @param configService - the config service
+     */
+    constructor(configService, target) {
         this.configService = configService;
+        this.target = target;
+        /** The Logger instance */
         this.logger = new common_1.Logger(SearchService_1.name);
-        this.axios = (0, services_module_utils_1.createAxios)({
+        /** The axios instance */
+        this.axios = (0, axios_1.createAxios)({
             baseUrl: 'https://services.svi-itlab.com/search/internal/',
             k8sToken: this.configService.getOrThrow(env_1.ENV_K8S_TOKEN),
         });
     }
-    index(targetId, document, target) {
-        this.logger.log(`Indexing ${target} (${targetId})`);
+    /**
+     * Index/Update a document in elasticsearch
+     *
+     * @param {string} targetId - the ID of the target
+     * @param {SearchableDocument} document - the document to be indexed/updated
+     * @return {void}
+     */
+    index(targetId, document) {
+        this.logger.log(`Indexing ${this.target} (${targetId})`);
         this.axios
-            .post(`${target}/${targetId}`, document)
-            .then(() => this.logger.log(`Sucessfully indexed ${target} (${targetId})`))
-            .catch(({ response }) => this.logger.error(`Couldn't index ${target} (${targetId})`, response.data));
+            .post(`${this.target}/${targetId}`, document)
+            .then(() => this.logger.log(`Sucessfully indexed ${this.target} (${targetId})`))
+            .catch(({ response }) => this.logger.error(`Couldn't index ${this.target} (${targetId})`, response.data));
     }
-    remove(targetId, target) {
-        this.logger.log(`Removing ${target} (${targetId})`);
+    /**
+     * Remove a document from elasticsearch
+     *
+     * @param {string} targetId - the ID of the target to be removed
+     * @return {void}
+     */
+    remove(targetId) {
+        this.logger.log(`Removing ${this.target} (${targetId})`);
         this.axios
-            .delete(`${target}/${targetId}`)
-            .then(() => this.logger.log(`Sucessfully removed ${target} (${targetId})`))
-            .catch(({ response }) => this.logger.error(`Couldn't remove ${target} (${targetId})`, response.data));
+            .delete(`${this.target}/${targetId}`)
+            .then(() => this.logger.log(`Sucessfully removed ${this.target} (${targetId})`))
+            .catch(({ response }) => this.logger.error(`Couldn't remove ${this.target} (${targetId})`, response.data));
     }
 };
 SearchService = SearchService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [config_1.ConfigService])
+    __param(1, (0, common_1.Inject)('SEARCH_TARGET')),
+    __metadata("design:paramtypes", [config_1.ConfigService, String])
 ], SearchService);
 exports.SearchService = SearchService;

package/dist/pipes/hid.pipe.d.ts

@@ -1,9 +1,39 @@
 import { HttpException } from '@nestjs/common';
 import { ValidationOptions } from 'class-validator';
+/**
+ * Custom exception for invalid HID.
+ */
 export declare class InvalidHidException extends HttpException {
+    /**
+     * Constructor for InvalidHidException.
+     * @param param - The parameter causing the exception.
+     */
     constructor(param: string);
 }
+/**
+ * Used to parse a valid HID from the request parameters
+ * @param param - The parameter to use for the HID
+ * @returns The extracted HID
+ */
 export declare const Hid: (param: string) => ParameterDecorator;
+/**
+ * Creates an ApiHid decorator with the given parameter
+ *
+ * @param {string} param - the parameter for the API HID
+ * @return A decorator that creates an API HID with the given parameter
+ */
 export declare const ApiHid: (param: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+/**
+ * Check if the given value is a valid hub ID.
+ *
+ * @param {unknown} value - the value to be checked
+ * @return {boolean} true if the value is a valid hub ID, false otherwise
+ */
 export declare function isHubID(value: unknown): boolean;
+/**
+ * A decorator that validates whether the value is a valid HubID.
+ *
+ * @param {ValidationOptions} validationOptions - optional validation options
+ * @return {PropertyDecorator} a decorator function
+ */
 export declare function IsHubID(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/pipes/hid.pipe.js

@@ -5,27 +5,59 @@ const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const itlab_functions_1 = require("itlab-functions");
+/** Description for invalid HIDs */
 const description = 'Invalid parameter';
+/** Status code for invalid HIDs */
 const status = common_1.HttpStatus.BAD_REQUEST;
+/**
+ * ParseHidPipe class to transform input value to string
+ */
 class ParseHidPipe {
+    /**
+     * Constructor for ParseHidPipe
+     * @param param - The parameter for the pipe
+     */
     constructor(param) {
         this.param = param;
     }
+    /**
+     * Transform method to transform the input value to string if it is a valid HID
+     * @param value - The input value to be transformed
+     * @returns The transformed string value
+     * @throws InvalidHidException if the input value is invalid
+     */
     transform(value) {
-        const isString = typeof value === 'string' || value instanceof String;
-        if (isString && (0, itlab_functions_1.isID)(value.toString()))
-            return value.toString();
+        if (isHubID(value))
+            return String(value);
         throw new InvalidHidException(this.param);
     }
 }
+/**
+ * Custom exception for invalid HID.
+ */
 class InvalidHidException extends common_1.HttpException {
+    /**
+     * Constructor for InvalidHidException.
+     * @param param - The parameter causing the exception.
+     */
     constructor(param) {
         super(`${description} '${param}'`, status);
     }
 }
 exports.InvalidHidException = InvalidHidException;
+/**
+ * Used to parse a valid HID from the request parameters
+ * @param param - The parameter to use for the HID
+ * @returns The extracted HID
+ */
 const Hid = (param) => (0, common_1.Param)(param, new ParseHidPipe(param));
 exports.Hid = Hid;
+/**
+ * Creates an ApiHid decorator with the given parameter
+ *
+ * @param {string} param - the parameter for the API HID
+ * @return A decorator that creates an API HID with the given parameter
+ */
 const ApiHid = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)({
     name: param,
     example: 'hallo-welt',
@@ -35,15 +67,27 @@ const ApiHid = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)(
     },
 }), (0, swagger_1.ApiResponse)({ description, status }));
 exports.ApiHid = ApiHid;
+/**
+ * Check if the given value is a valid hub ID.
+ *
+ * @param {unknown} value - the value to be checked
+ * @return {boolean} true if the value is a valid hub ID, false otherwise
+ */
 function isHubID(value) {
-    return typeof value === 'string' && (0, itlab_functions_1.isID)(value);
+    return (0, class_validator_1.isString)(value) && (0, itlab_functions_1.isID)(String(value));
 }
 exports.isHubID = isHubID;
+/**
+ * A decorator that validates whether the value is a valid HubID.
+ *
+ * @param {ValidationOptions} validationOptions - optional validation options
+ * @return {PropertyDecorator} a decorator function
+ */
 function IsHubID(validationOptions) {
     return (0, class_validator_1.ValidateBy)({
         name: 'isHubID',
         validator: {
-            validate: (value, args) => isHubID(value),
+            validate: (value) => isHubID(value),
             defaultMessage: (0, class_validator_1.buildMessage)((eachPrefix) => eachPrefix + '$property ist keine gültige HubID', validationOptions),
         },
     }, validationOptions);

package/dist/pipes/id.pipe.d.ts

@@ -1,6 +1,26 @@
 import { HttpException } from '@nestjs/common';
+/**
+ * Custom exception for invalid ID
+ * @class InvalidIdException
+ * @extends {HttpException}
+ */
 export declare class InvalidIdException extends HttpException {
+    /**
+     * Constructor for InvalidIdException
+     * @param param - The invalid ID parameter
+     */
     constructor(param: string);
 }
+/**
+ * Used to parse a valid ID from the request parameters
+ * @param param - The parameter to use for the ID
+ * @returns The extracted ID
+ */
 export declare const Id: (param: string) => ParameterDecorator;
+/**
+ * Creates an ApiId decorator with the given parameter
+ *
+ * @param {string} param - the parameter for the API ID
+ * @return A decorator that creates an API ID with the given parameter
+ */
 export declare const ApiId: (param: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/pipes/id.pipe.js

@@ -3,27 +3,63 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiId = exports.Id = exports.InvalidIdException = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+/** Description for invalid IDs */
 const description = 'Invalid parameter';
+/** Status code for invalid IDs */
 const status = common_1.HttpStatus.BAD_REQUEST;
+/**
+ * ParseIdPipe class for transforming input value to string
+ * @class ParseIdPipe
+ * @implements {PipeTransform<unknown, string>}
+ */
 class ParseIdPipe {
+    /**
+     * Constructor for ParseIdPipe
+     * @param param - the parameter for the pipe
+     */
     constructor(param) {
         this.param = param;
     }
+    /**
+     * Transform function to transform input value to string if it is a valid Mongo ID
+     * @param value - the input value to be transformed
+     * @returns the transformed value as a string
+     * @throws InvalidIdException if the input value is not a valid Mongo ID
+     */
     transform(value) {
-        const isString = typeof value === 'string' || value instanceof String;
-        const isMongoId = /^(0x|0h)?[0-9A-F]+$/i.test(value) && value.length === 24;
-        if (isString && isMongoId)
-            return value.toString();
+        if ((0, class_validator_1.isMongoId)(value))
+            return String(value);
         throw new InvalidIdException(this.param);
     }
 }
+/**
+ * Custom exception for invalid ID
+ * @class InvalidIdException
+ * @extends {HttpException}
+ */
 class InvalidIdException extends common_1.HttpException {
+    /**
+     * Constructor for InvalidIdException
+     * @param param - The invalid ID parameter
+     */
     constructor(param) {
         super(`${description} '${param}'`, status);
     }
 }
 exports.InvalidIdException = InvalidIdException;
+/**
+ * Used to parse a valid ID from the request parameters
+ * @param param - The parameter to use for the ID
+ * @returns The extracted ID
+ */
 const Id = (param) => (0, common_1.Param)(param, new ParseIdPipe(param));
 exports.Id = Id;
+/**
+ * Creates an ApiId decorator with the given parameter
+ *
+ * @param {string} param - the parameter for the API ID
+ * @return A decorator that creates an API ID with the given parameter
+ */
 const ApiId = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)({ name: param, example: ''.padEnd(24, '0') }), (0, swagger_1.ApiResponse)({ description, status }));
 exports.ApiId = ApiId;

package/dist/pipes/target.pipe.d.ts

@@ -1,4 +1,7 @@
 import { HttpException } from '@nestjs/common';
+/**
+ * Enum representing various targets in the application
+ */
 export declare enum Targets {
     NEWSROOM = "news",
     EVENTS = "event",
@@ -14,8 +17,28 @@ export declare enum Targets {
     HUB_USER = "hub-user",
     HUB_FILE = "hub-file"
 }
+/**
+ * Custom exception for invalid targets
+ * @class InvalidTargetException
+ * @extends {HttpException}
+ */
 export declare class InvalidTargetException extends HttpException {
+    /**
+     * Constructor for InvalidTargetException
+     * @param param - The parameter causing the exception
+     */
     constructor(param: string);
 }
+/**
+ * Used to parse a valid target from the request parameters
+ * @param param - The parameter to use for the target
+ * @returns The extracted target
+ */
 export declare const Target: (param: string) => ParameterDecorator;
+/**
+ * Creates an ApiTarget decorator with the given parameter
+ *
+ * @param {string} param - the parameter for the API target
+ * @return A decorator that creates an API target with the given parameter
+ */
 export declare const ApiTarget: (param: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/pipes/target.pipe.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiTarget = exports.Target = exports.InvalidTargetException = exports.Targets = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
+/**
+ * Enum representing various targets in the application
+ */
 var Targets;
 (function (Targets) {
     Targets["NEWSROOM"] = "news";
@@ -19,30 +22,69 @@ var Targets;
     Targets["HUB_USER"] = "hub-user";
     Targets["HUB_FILE"] = "hub-file";
 })(Targets = exports.Targets || (exports.Targets = {}));
-function generateExamples() {
-    const map = {};
-    Object.entries(Targets).forEach(([value, key]) => (map[key] = { value }));
-    return map;
-}
+/** Description for invalid targets */
 const description = 'Invalid parameter';
+/** Status code for invalid targets */
 const status = common_1.HttpStatus.BAD_REQUEST;
+/**
+ * This class represents a custom pipe to transform Targets to string.
+ * @class ParseTargetPipe
+ * @implements {PipeTransform<Targets, string>}
+ */
 class ParseTargetPipe {
+    /**
+     * Creates an instance of ParseTargetPipe.
+     * @param param - The parameter for the pipe.
+     */
     constructor(param) {
         this.param = param;
     }
+    /**
+     * Transforms the given value to a string.
+     * @param {Targets} value - The value to be transformed.
+     * @returns {string} The transformed string.
+     * @throws InvalidTargetException if the value is not a valid target.
+     */
     transform(value) {
         if (Object.values(Targets).includes(value))
             return value;
         throw new InvalidTargetException(this.param);
     }
 }
+/**
+ * Custom exception for invalid targets
+ * @class InvalidTargetException
+ * @extends {HttpException}
+ */
 class InvalidTargetException extends common_1.HttpException {
+    /**
+     * Constructor for InvalidTargetException
+     * @param param - The parameter causing the exception
+     */
     constructor(param) {
         super(`${description} '${param}'`, status);
     }
 }
 exports.InvalidTargetException = InvalidTargetException;
+/**
+ * Used to parse a valid target from the request parameters
+ * @param param - The parameter to use for the target
+ * @returns The extracted target
+ */
 const Target = (param) => (0, common_1.Param)(param, new ParseTargetPipe(param));
 exports.Target = Target;
-const ApiTarget = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)({ name: param, example: Targets.NEWSROOM, examples: generateExamples() }), (0, swagger_1.ApiResponse)({ description, status }));
+/**
+ * Creates an ApiTarget decorator with the given parameter
+ *
+ * @param {string} param - the parameter for the API target
+ * @return A decorator that creates an API target with the given parameter
+ */
+const ApiTarget = (param) => (0, common_1.applyDecorators)((0, swagger_1.ApiParam)({
+    name: param,
+    example: Targets.NEWSROOM,
+    examples: Object.entries(Targets).reduce((map, [value, key]) => {
+        map[key] = { value };
+        return map;
+    }, {}),
+}), (0, swagger_1.ApiResponse)({ description, status }));
 exports.ApiTarget = ApiTarget;

package/dist/schema.transformer.d.ts

@@ -0,0 +1,2 @@
+import { ToObjectOptions } from 'mongoose';
+export declare function SchemaTransformer<T, R = T>(transformer: (doc: T) => R): ToObjectOptions;

package/dist/schema.transformer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaTransformer = void 0;
+function SchemaTransformer(transformer) {
+    return {
+        virtuals: true,
+        transform: (_, ret) => transformer(ret),
+    };
+}
+exports.SchemaTransformer = SchemaTransformer;

package/dist/swagger.config.d.ts

@@ -1,13 +1,47 @@
 import { INestApplication } from '@nestjs/common';
 import { DocumentBuilder, OpenAPIObject } from '@nestjs/swagger';
-export interface SwaggerOptions {
+/**
+ * Class representing Swagger options.
+ *
+ * @class SwaggerOptions
+ *
+ * @property {string} title - Title of the Swagger documentation.
+ * @property {string} description - Description of the Swagger documentation.
+ * @property {boolean} jwt - Whether JWT authentication is enabled.
+ * @property {boolean} k8s - Whether Kubernetes integration is enabled.
+ */
+export declare class SwaggerOptions {
+    /** Title of the Swagger documentation. */
     title: string;
+    /** Description of the Swagger documentation. */
     description: string;
+    /** Whether JWT authentication is enabled. */
     jwt?: boolean;
+    /** Whether Kubernetes integration is enabled. */
     k8s?: boolean;
 }
+/** Type representing the Swagger configuration. */
 declare type SwaggerConfig = Omit<OpenAPIObject, 'paths'>;
+/**
+ * Retrieves the Swagger configuration.
+ *
+ * @param {SwaggerOptions} options - optional options for Swagger
+ * @return {SwaggerConfig} the Swagger configuration
+ */
 export declare function getSwaggerConfig(options?: SwaggerOptions): SwaggerConfig;
-export declare function getSwaggerDocument(options?: SwaggerOptions): DocumentBuilder;
+/**
+ * Returns a Swagger document builder with the specified options.
+ *
+ * @param {SwaggerOptions} options - optional Swagger options
+ * @return {DocumentBuilder} the constructed Swagger document builder
+ */
+export declare function getSwaggerDocument(options: SwaggerOptions): DocumentBuilder;
+/**
+ * Initializes and configures Swagger for the given Nest application.
+ *
+ * @param {INestApplication} app - The Nest application instance
+ * @param {SwaggerOptions} [options] - Optional Swagger configuration options
+ * @return {void}
+ */
 export declare function useSwagger(app: INestApplication, options?: SwaggerOptions): void;
 export {};