itlab-internal-services 2.2.2 → 2.3.0

package/dist/env.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Environment variables
+ *
+ * @exports
+ * ENV_K8S_TOKEN
+ * ENV_JWT_SECRET
+ * ENV_MONGO_SRV
+ * ENV_MONGO_USERNAME
+ * ENV_MONGO_PASSWORD
+ * ENV_MONGO_CERT_DIR
+ * ENV_MONGO_TLS_CA_CRT
+ * ENV_MONGO_TLS_TLS_CRT
+ * ENV_MONGO_TLS_TLS_KEY
+ */
 export declare const ENV_K8S_TOKEN = "K8S_TOKEN";
 export declare const ENV_JWT_SECRET = "JWT_SECRET";
 export declare const ENV_MONGO_SRV = "MONGO_SRV";

package/dist/env.js

@@ -1,4 +1,18 @@
 "use strict";
+/**
+ * Environment variables
+ *
+ * @exports
+ * ENV_K8S_TOKEN
+ * ENV_JWT_SECRET
+ * ENV_MONGO_SRV
+ * ENV_MONGO_USERNAME
+ * ENV_MONGO_PASSWORD
+ * ENV_MONGO_CERT_DIR
+ * ENV_MONGO_TLS_CA_CRT
+ * ENV_MONGO_TLS_TLS_CRT
+ * ENV_MONGO_TLS_TLS_KEY
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENV_MONGO_TLS_TLS_KEY = exports.ENV_MONGO_TLS_TLS_CRT = exports.ENV_MONGO_TLS_CA_CRT = exports.ENV_MONGO_CERT_DIR = exports.ENV_MONGO_PASSWORD = exports.ENV_MONGO_USERNAME = exports.ENV_MONGO_SRV = exports.ENV_JWT_SECRET = exports.ENV_K8S_TOKEN = void 0;
 exports.ENV_K8S_TOKEN = 'K8S_TOKEN';

package/dist/exceptions/bad-body.exception.d.ts

@@ -1,5 +1,19 @@
 import { ErrorException } from '.';
+/**
+ * Custom exception for bad request body
+ * @class BadBodyException
+ * @extends {ErrorException}
+ */
 export declare class BadBodyException extends ErrorException {
+    /**
+     * Constructor for BadBodyException
+     * @param description - optional description for the exception
+     */
     constructor(description?: string);
 }
+/**
+ * Creates an ApiBadBody decorator with the given description
+ * @param description - optional description for the exception
+ * @returns A decorator that creates an API bad body
+ */
 export declare const ApiBadBody: (description?: string) => MethodDecorator & ClassDecorator;

package/dist/exceptions/bad-body.exception.js

@@ -4,13 +4,29 @@ exports.ApiBadBody = exports.BadBodyException = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const _1 = require(".");
+/** Status code for bad bodies */
 const status = common_1.HttpStatus.METHOD_NOT_ALLOWED;
+/** Description for bad bodies */
 const error = 'Bad Body';
+/**
+ * Custom exception for bad request body
+ * @class BadBodyException
+ * @extends {ErrorException}
+ */
 class BadBodyException extends _1.ErrorException {
+    /**
+     * Constructor for BadBodyException
+     * @param description - optional description for the exception
+     */
     constructor(description) {
         super(error, status, description);
     }
 }
 exports.BadBodyException = BadBodyException;
+/**
+ * Creates an ApiBadBody decorator with the given description
+ * @param description - optional description for the exception
+ * @returns A decorator that creates an API bad body
+ */
 const ApiBadBody = (description = error) => (0, swagger_1.ApiResponse)({ status, description });
 exports.ApiBadBody = ApiBadBody;

package/dist/exceptions/duplicate.exception.d.ts

@@ -1,5 +1,19 @@
 import { ErrorException } from '.';
+/**
+ * Represents an exception for duplicate errors.
+ * @class DuplicateException
+ * @extends {ErrorException}
+ */
 export declare class DuplicateException extends ErrorException {
+    /**
+     * Constructor for DuplicateException.
+     * @param description - Optional description for the exception.
+     */
     constructor(description?: string);
 }
+/**
+ * Creates an ApiDuplicate decorator with the given description
+ * @param description  - optional description for the exception
+ * @returns A decorator that creates an API duplicate
+ */
 export declare const ApiDuplicate: (description?: string) => MethodDecorator & ClassDecorator;

package/dist/exceptions/duplicate.exception.js

@@ -4,13 +4,29 @@ exports.ApiDuplicate = exports.DuplicateException = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const _1 = require(".");
+/** Status code for duplicates */
 const status = common_1.HttpStatus.CONFLICT;
+/** Description for duplicates */
 const error = 'Duplicate';
+/**
+ * Represents an exception for duplicate errors.
+ * @class DuplicateException
+ * @extends {ErrorException}
+ */
 class DuplicateException extends _1.ErrorException {
+    /**
+     * Constructor for DuplicateException.
+     * @param description - Optional description for the exception.
+     */
     constructor(description) {
         super(error, status, description);
     }
 }
 exports.DuplicateException = DuplicateException;
+/**
+ * Creates an ApiDuplicate decorator with the given description
+ * @param description  - optional description for the exception
+ * @returns A decorator that creates an API duplicate
+ */
 const ApiDuplicate = (description = error) => (0, swagger_1.ApiResponse)({ status, description });
 exports.ApiDuplicate = ApiDuplicate;

package/dist/exceptions/index.d.ts

@@ -1,5 +1,16 @@
 import { HttpException } from '@nestjs/common';
+/**
+ * Custom error exception class
+ * @class ErrorException
+ * @extends {HttpException}
+ */
 export declare class ErrorException extends HttpException {
+    /**
+     * Constructor for ErrorException
+     * @param error - The error message
+     * @param status - The status code
+     * @param description - The description of the error
+     */
     constructor(error: string, status: number, description?: string);
 }
 export * from './bad-body.exception';

package/dist/exceptions/index.js

@@ -16,7 +16,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorException = void 0;
 const common_1 = require("@nestjs/common");
+/**
+ * Custom error exception class
+ * @class ErrorException
+ * @extends {HttpException}
+ */
 class ErrorException extends common_1.HttpException {
+    /**
+     * Constructor for ErrorException
+     * @param error - The error message
+     * @param status - The status code
+     * @param description - The description of the error
+     */
     constructor(error, status, description) {
         super({ message: [description || error], status, error }, status);
     }

package/dist/exceptions/not-found.exception.d.ts

@@ -1,5 +1,19 @@
 import { ErrorException } from '.';
+/**
+ * Custom exception for not found errors.
+ * @class NotFoundException
+ * @extends {ErrorException}
+ */
 export declare class NotFoundException extends ErrorException {
+    /**
+     * Constructor for NotFoundException.
+     * @param description - Description of the error.
+     */
     constructor(description?: string);
 }
+/**
+ * Creates an ApiNotFound decorator with the given description
+ * @param description - Optional description for the exception
+ * @returns A decorator that creates an API not found
+ */
 export declare const ApiNotFound: (description?: string) => MethodDecorator & ClassDecorator;

package/dist/exceptions/not-found.exception.js

@@ -4,13 +4,29 @@ exports.ApiNotFound = exports.NotFoundException = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const _1 = require(".");
+/** Status code for not found */
 const status = common_1.HttpStatus.NOT_FOUND;
+/** Description for not found */
 const error = 'Not Found';
+/**
+ * Custom exception for not found errors.
+ * @class NotFoundException
+ * @extends {ErrorException}
+ */
 class NotFoundException extends _1.ErrorException {
+    /**
+     * Constructor for NotFoundException.
+     * @param description - Description of the error.
+     */
     constructor(description) {
         super(error, status, description);
     }
 }
 exports.NotFoundException = NotFoundException;
+/**
+ * Creates an ApiNotFound decorator with the given description
+ * @param description - Optional description for the exception
+ * @returns A decorator that creates an API not found
+ */
 const ApiNotFound = (description = error) => (0, swagger_1.ApiResponse)({ status, description });
 exports.ApiNotFound = ApiNotFound;

package/dist/favicon.controller.d.ts

@@ -1,5 +1,17 @@
 import { Response } from 'express';
+/**
+ * The FaviconController class
+ *
+ * @class FaviconController
+ */
 export declare class FaviconController {
+    /** The Axios instance to make requests */
     private axios;
+    /**
+     * A function to asynchronously get the favicon and pipe the data to the response.
+     *
+     * @param {type} res - The response object to pipe the data to
+     * @return {Promise<void>} Promise that resolves when the data has been piped to the response
+     */
     getFavicon(res: Response): Promise<void>;
 }

package/dist/favicon.controller.js

@@ -28,11 +28,24 @@ exports.FaviconController = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const axios_1 = __importDefault(require("axios"));
+/** The URL of the favicon image */
 const favicon = 'https://file.svi-itlab.com/650d514c58cbe60df3494bc0';
+/**
+ * The FaviconController class
+ *
+ * @class FaviconController
+ */
 let FaviconController = class FaviconController {
     constructor() {
+        /** The Axios instance to make requests */
         this.axios = axios_1.default.create();
     }
+    /**
+     * A function to asynchronously get the favicon and pipe the data to the response.
+     *
+     * @param {type} res - The response object to pipe the data to
+     * @return {Promise<void>} Promise that resolves when the data has been piped to the response
+     */
     getFavicon(res) {
         return __awaiter(this, void 0, void 0, function* () {
             const { data } = yield this.axios.get(favicon, { responseType: 'stream' });

package/dist/guards/perms.guard.d.ts

@@ -1,11 +1,39 @@
 import { CanActivate, ExecutionContext, HttpException } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
+/**
+ * Permissions guard
+ * @class PermsGuard
+ * @implements {CanActivate}
+ */
 export declare class PermsGuard implements CanActivate {
     private readonly reflector;
+    /**
+     * Constructor for the PermsGuard
+     * @param reflector - the reflector
+     */
     constructor(reflector: Reflector);
+    /**
+     * Checks if the user has the required permissions to access the resource.
+     *
+     * @param {ExecutionContext} ctx - the execution context
+     * @return {boolean} whether the user has the required permissions
+     */
     canActivate(ctx: ExecutionContext): boolean;
 }
+/**
+ * Insufficient permissions exception
+ * @class InsufficientPermissionsException
+ * @extends {HttpException}
+ */
 export declare class InsufficientPermissionsException extends HttpException {
+    /**
+     * Constructor for the InsufficientPermissionsException
+     */
     constructor();
 }
+/**
+ * Create an ApiPerms decorator with the given permissions
+ * @param perms - the permissions required
+ * @returns An ApiPerms decorator
+ */
 export declare const Perms: (...perms: string[]) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/guards/perms.guard.js

@@ -13,23 +13,48 @@ exports.Perms = exports.InsufficientPermissionsException = exports.PermsGuard =
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
 const itlab_functions_1 = require("itlab-functions");
 const jwt_guard_1 = require("../modules/authentication/jwt/jwt.guard");
+/** Metadata key for permissions */
 const META = 'itlab-internal-perms-guard';
+/** Insufficient permissions */
 const description = 'Insufficient permissions';
+/** Insufficient permissions status */
 const status = common_1.HttpStatus.FORBIDDEN;
+/**
+ * Permissions guard
+ * @class PermsGuard
+ * @implements {CanActivate}
+ */
 let PermsGuard = class PermsGuard {
+    /**
+     * Constructor for the PermsGuard
+     * @param reflector - the reflector
+     */
     constructor(reflector) {
         this.reflector = reflector;
     }
+    /**
+     * Checks if the user has the required permissions to access the resource.
+     *
+     * @param {ExecutionContext} ctx - the execution context
+     * @return {boolean} whether the user has the required permissions
+     */
     canActivate(ctx) {
+        // Retrieve the permissions required for the handler from metadata
         let perms = this.reflector.get(META, ctx.getHandler());
+        // If no permissions are required, allow access
         if (!perms || !Array.isArray(perms) || perms.length === 0)
             return true;
+        // Retrieve the user from the request
         const { user } = ctx.switchToHttp().getRequest();
-        const _ = user && user.perms && Array.isArray(user.perms) && user.perms.length > 0;
-        if (_ && (0, itlab_functions_1.hasPermission)(perms, user.perms))
+        // Check if the user is valid and has at least one permission
+        const userValid = user && (0, class_validator_1.minLength)(user.perms, 1);
+        // If the user is valid and has the required permissions, allow access
+        if (userValid && (0, itlab_functions_1.hasPermission)(perms, user.perms))
             return true;
+        // If the user does not have the required permissions, throw an exception
         throw new InsufficientPermissionsException();
     }
 };
@@ -38,7 +63,15 @@ PermsGuard = __decorate([
     __metadata("design:paramtypes", [core_1.Reflector])
 ], PermsGuard);
 exports.PermsGuard = PermsGuard;
+/**
+ * Insufficient permissions exception
+ * @class InsufficientPermissionsException
+ * @extends {HttpException}
+ */
 let InsufficientPermissionsException = class InsufficientPermissionsException extends common_1.HttpException {
+    /**
+     * Constructor for the InsufficientPermissionsException
+     */
     constructor() {
         super(description, status);
     }
@@ -48,5 +81,10 @@ InsufficientPermissionsException = __decorate([
     __metadata("design:paramtypes", [])
 ], InsufficientPermissionsException);
 exports.InsufficientPermissionsException = InsufficientPermissionsException;
+/**
+ * Create an ApiPerms decorator with the given permissions
+ * @param perms - the permissions required
+ * @returns An ApiPerms decorator
+ */
 const Perms = (...perms) => (0, common_1.applyDecorators)((0, common_1.SetMetadata)(META, perms), (0, common_1.UseGuards)(jwt_guard_1.JwtGuard, PermsGuard), (0, swagger_1.ApiBearerAuth)(), (0, swagger_1.ApiResponse)({ description: `${description} (${perms.join(', ')})`, status }));
 exports.Perms = Perms;

package/dist/guards/puplic.guard.d.ts

@@ -1,2 +1,7 @@
+/** Metadata key for public routes */
 export declare const IS_PUBLIC_META = "itlab-public-guard";
+/**
+ * Marks a route as public and allows it to be accessed without authentication
+ * @returns An override of the ApiBearerAuth decorator
+ */
 export declare const Public: () => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/guards/puplic.guard.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Public = exports.IS_PUBLIC_META = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
+/** Metadata key for public routes */
 exports.IS_PUBLIC_META = 'itlab-public-guard';
+/**
+ * Marks a route as public and allows it to be accessed without authentication
+ * @returns An override of the ApiBearerAuth decorator
+ */
 const Public = () => (0, common_1.applyDecorators)((0, common_1.SetMetadata)(exports.IS_PUBLIC_META, true), (0, swagger_1.ApiBearerAuth)(), (0, swagger_1.ApiUnauthorizedResponse)({ description: "Public endpoint, won't be thrown" }));
 exports.Public = Public;

package/dist/http.logger.d.ts

@@ -1,2 +1,8 @@
 import { INestApplication } from '@nestjs/common';
+/**
+ * Middleware for logging HTTP requests and responses.
+ *
+ * @param {INestApplication} app - the Nest application instance
+ * @return {void}
+ */
 export declare function useHttpLogger(app: INestApplication): void;

package/dist/http.logger.js

@@ -2,14 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useHttpLogger = void 0;
 const common_1 = require("@nestjs/common");
+/**
+ * Middleware for logging HTTP requests and responses.
+ *
+ * @param {INestApplication} app - the Nest application instance
+ * @return {void}
+ */
 function useHttpLogger(app) {
     app.use((req, res, next) => {
         const { method, url } = req;
+        // URLs to ignore from logging
         const ignore = ['/alive', '/favicon.ico'];
         if (url.includes('swagger') || url.startsWith('/api') || ignore.includes(url)) {
             next();
             return;
         }
+        // Log the response after it's finished
         res.on('finish', () => {
             const { statusCode, statusMessage } = res;
             const message = `${method} ${url} - ${statusCode} (${statusMessage})`;
@@ -17,7 +25,7 @@ function useHttpLogger(app) {
             if (!ignore.includes(url))
                 new common_1.Logger('HTTP')[level](message);
         });
-        next();
+        next(); // Continue to the next middleware
     });
 }
 exports.useHttpLogger = useHttpLogger;

package/dist/index.d.ts

@@ -4,7 +4,9 @@ export * from './guards';
 export * from './http.logger';
 export * from './interceptors';
 export * from './liveness.probe';
+export * from './models';
 export * from './modules';
 export * from './pipes';
 export * from './swagger.config';
+export * from './transform';
 export * from './virtuals';

package/dist/index.js

@@ -20,7 +20,9 @@ __exportStar(require("./guards"), exports);
 __exportStar(require("./http.logger"), exports);
 __exportStar(require("./interceptors"), exports);
 __exportStar(require("./liveness.probe"), exports);
+__exportStar(require("./models"), exports);
 __exportStar(require("./modules"), exports);
 __exportStar(require("./pipes"), exports);
 __exportStar(require("./swagger.config"), exports);
+__exportStar(require("./transform"), exports);
 __exportStar(require("./virtuals"), exports);

package/dist/interceptors/errors.interceptor.d.ts

@@ -1,11 +1,43 @@
 import { CallHandler, ExecutionContext, INestApplication, NestInterceptor } from '@nestjs/common';
 import { Observable } from 'rxjs';
+/**
+ * Error interceptor
+ * @class ErrorsInterceptor
+ * @implements {NestInterceptor}
+ */
 export declare class ErrorsInterceptor implements NestInterceptor {
     private readonly dictionary;
+    /**
+     * Constructor for the ErrorsInterceptor
+     * @param dictionary - The dictionary to use
+     */
     constructor(dictionary?: Record<string, string>);
-    protected REGEX: RegExp;
+    /**
+     * A function that intercepts the execution context and the call handler, and returns an Observable of any type.
+     *
+     * @param {ExecutionContext} _context - the execution context parameter
+     * @param {CallHandler} next - the call handler parameter
+     * @return {Observable<any>} an Observable of any type
+     */
     intercept(_context: ExecutionContext, next: CallHandler): Observable<any>;
+    /**
+     * Transforms the message
+     *
+     * @param {string} message - the input message to be transformed
+     * @param {string[]} parent - the parent message array
+     * @return {string} the transformed message
+     */
     protected transform(message: string, parent: string[]): string;
 }
+/**
+ * Create an UsesErrorsInterceptor decorator with the given dictionary
+ * @param dictionary - The dictionary to use
+ * @returns An UsesErrorsInterceptor decorator
+ */
 export declare const UsesErrorsInterceptor: (dictionary?: Record<string, string>) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+/**
+ * Use global errors interceptor
+ * @param app - The Nest application
+ * @param dictionary - A dictionary to use
+ */
 export declare const useGlobalErrrorsInterceptor: (app: INestApplication, dictionary?: Record<string, string>) => void;

package/dist/interceptors/errors.interceptor.js

@@ -12,25 +12,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useGlobalErrrorsInterceptor = exports.UsesErrorsInterceptor = exports.ErrorsInterceptor = void 0;
 const common_1 = require("@nestjs/common");
 const rxjs_1 = require("rxjs");
+/**
+ * Error interceptor
+ * @class ErrorsInterceptor
+ * @implements {NestInterceptor}
+ */
 let ErrorsInterceptor = class ErrorsInterceptor {
+    /**
+     * Constructor for the ErrorsInterceptor
+     * @param dictionary - The dictionary to use
+     */
     constructor(dictionary = {}) {
         this.dictionary = dictionary;
-        this.REGEX = /^\D+\.\d+\..+$/;
     }
+    /**
+     * A function that intercepts the execution context and the call handler, and returns an Observable of any type.
+     *
+     * @param {ExecutionContext} _context - the execution context parameter
+     * @param {CallHandler} next - the call handler parameter
+     * @return {Observable<any>} an Observable of any type
+     */
     intercept(_context, next) {
+        // Using pipe method to handle the observable
         return next.handle().pipe((0, rxjs_1.catchError)((err) => {
             let { message } = err.response;
+            // Checking if the message is present and converting it to an array if not
             if (!message)
                 message = [];
             if (!Array.isArray(message))
                 message = [message];
+            // Mapping over the message array and transforming the string messages if necessary
             err.response.message = message.map((m) => (typeof m === 'string' ? this.transform(m, []) : m));
+            // Removing duplicate messages
             err.response.message = [...new Set(err.response.message)];
+            // Throwing the error after processing
             throw err;
         }));
     }
+    /**
+     * Transforms the message
+     *
+     * @param {string} message - the input message to be transformed
+     * @param {string[]} parent - the parent message array
+     * @return {string} the transformed message
+     */
     transform(message, parent) {
-        if (!this.REGEX.test(message)) {
+        const REGEX = /^\D+\.\d+\..+$/;
+        if (!REGEX.test(message)) {
             const split = message.split('.');
             if (split.length > 1) {
                 const m = split.pop();
@@ -47,7 +75,7 @@ let ErrorsInterceptor = class ErrorsInterceptor {
         const prefix = this.dictionary[parent.join('.')] || parent[parent.length - 1];
         const index = _.shift();
         const error = _.join('.');
-        const delimiter = this.REGEX.test(error) ? '⟩' : '•';
+        const delimiter = REGEX.test(error) ? '⟩' : '•';
         return `${prefix} #${+index + 1} ${delimiter} ${this.transform(error, parent)}`;
     }
 };
@@ -56,8 +84,18 @@ ErrorsInterceptor = __decorate([
     __metadata("design:paramtypes", [Object])
 ], ErrorsInterceptor);
 exports.ErrorsInterceptor = ErrorsInterceptor;
+/**
+ * Create an UsesErrorsInterceptor decorator with the given dictionary
+ * @param dictionary - The dictionary to use
+ * @returns An UsesErrorsInterceptor decorator
+ */
 const UsesErrorsInterceptor = (dictionary) => (0, common_1.applyDecorators)((0, common_1.UseInterceptors)(new ErrorsInterceptor(dictionary)));
 exports.UsesErrorsInterceptor = UsesErrorsInterceptor;
+/**
+ * Use global errors interceptor
+ * @param app - The Nest application
+ * @param dictionary - A dictionary to use
+ */
 const useGlobalErrrorsInterceptor = (app, dictionary) => {
     app.useGlobalInterceptors(new ErrorsInterceptor(dictionary));
 };

package/dist/liveness.probe.d.ts

@@ -1,4 +1,15 @@
 import { Response } from 'express';
+/**
+ * The LivenessProbe controller
+ *
+ * @class LivenessProbe
+ */
 export declare class LivenessProbe {
+    /**
+     * A function that handles getting alive status.
+     *
+     * @param {@Res()} response - the response object
+     * @return {Promise<void>} a Promise that resolves to void
+     */
     getAlive(response: Response): Promise<void>;
 }

package/dist/liveness.probe.js

@@ -24,7 +24,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LivenessProbe = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
+/**
+ * The LivenessProbe controller
+ *
+ * @class LivenessProbe
+ */
 let LivenessProbe = class LivenessProbe {
+    /**
+     * A function that handles getting alive status.
+     *
+     * @param {@Res()} response - the response object
+     * @return {Promise<void>} a Promise that resolves to void
+     */
     getAlive(response) {
         return __awaiter(this, void 0, void 0, function* () {
             response.status(200).send({ ok: 1 });

package/dist/models/content.d.ts

@@ -0,0 +1,8 @@
+import { ApiPropertyOptions } from '@nestjs/swagger';
+/**
+ * Creates a ContentDecorator with the given options.
+ *
+ * @param {ApiPropertyOptions} options - the options for the Content
+ * @return PropertyDecorator
+ */
+export declare const PropertyContent: (options?: ApiPropertyOptions) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;