pangea-server 1.0.1

package/dist/helpers/html-sanitize.helpers.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHtmlSanitized = exports.removeHtmlTags = exports.sanitizeHtml = void 0;
+const jsdom_1 = require("jsdom");
+const dompurify_1 = __importDefault(require("dompurify"));
+// resources
+const resources_1 = require("../resources");
+// helpers
+const error_helpers_1 = require("./error.helpers");
+const { window } = new jsdom_1.JSDOM();
+const domPurify = (0, dompurify_1.default)(window);
+function sanitizeHtml(html) {
+    return domPurify.sanitize(html);
+}
+exports.sanitizeHtml = sanitizeHtml;
+function removeHtmlTags(html) {
+    return domPurify.sanitize(html, { ALLOWED_TAGS: [] });
+}
+exports.removeHtmlTags = removeHtmlTags;
+function getHtmlSanitized(html, maxLength = 'extraLong') {
+    const htmlLength = html ? removeHtmlTags(html).length : 0;
+    const finalMaxLength = typeof maxLength === 'number' ? maxLength : resources_1.STRING_LENGTHS[maxLength];
+    if (htmlLength > finalMaxLength)
+        error_helpers_1.AppError.Throw({ statusCodeName: 'BAD_REQUEST', errorCode: 'INVALID_INPUT_DATA' });
+    return html ? sanitizeHtml(html) : null;
+}
+exports.getHtmlSanitized = getHtmlSanitized;

package/dist/helpers/index.d.ts

@@ -0,0 +1,11 @@
+export * from './controllers.helpers';
+export * from './env.helpers';
+export * from './error.helpers';
+export * from './file.helpers';
+export * from './hashing.helpers';
+export * from './html-sanitize.helpers';
+export * from './job.helpers';
+export * from './mailer.helpers';
+export * from './multer.helpers';
+export * from './print.helpers';
+export * from './random.helpers';

package/dist/helpers/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./controllers.helpers"), exports);
+__exportStar(require("./env.helpers"), exports);
+__exportStar(require("./error.helpers"), exports);
+__exportStar(require("./file.helpers"), exports);
+__exportStar(require("./hashing.helpers"), exports);
+__exportStar(require("./html-sanitize.helpers"), exports);
+__exportStar(require("./job.helpers"), exports);
+__exportStar(require("./mailer.helpers"), exports);
+__exportStar(require("./multer.helpers"), exports);
+__exportStar(require("./print.helpers"), exports);
+__exportStar(require("./random.helpers"), exports);

package/dist/helpers/job.helpers.d.ts

@@ -0,0 +1,8 @@
+type RunFn = (tx: Tx) => Promise<void>;
+export declare abstract class Job {
+    static Run(runFn: RunFn): () => Promise<void>;
+}
+export interface JobCtor {
+    Init(): void;
+}
+export {};

package/dist/helpers/job.helpers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+const database_1 = require("../database");
+class Job {
+    static Run(runFn) {
+        return async () => {
+            const tx = await (0, database_1.getDbClient)().transaction();
+            try {
+                await runFn(tx);
+                await tx.commit();
+            }
+            catch (err) {
+                await tx.rollback();
+                throw err;
+            }
+        };
+    }
+}
+exports.Job = Job;

package/dist/helpers/mailer.helpers.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+type MailerConfig = {
+    smtpProvider: string;
+    port: number;
+    auth: {
+        user: string;
+        pass: string;
+    };
+};
+type SendMailOptions = {
+    from?: string;
+    to: string | string[];
+    subject: string;
+    text?: string;
+    html?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    attachments?: {
+        filename?: string;
+        content?: string | Buffer;
+        path?: string;
+    }[];
+};
+type SendMailConfig = {
+    throwError?: boolean;
+};
+export declare class Mailer {
+    private __transporter;
+    private __user;
+    constructor(config: MailerConfig);
+    sendMail(options: SendMailOptions, config?: SendMailConfig): Promise<any>;
+}
+export {};

package/dist/helpers/mailer.helpers.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mailer = void 0;
+const nodemailer_1 = __importDefault(require("nodemailer"));
+class Mailer {
+    constructor(config) {
+        this.__transporter = nodemailer_1.default.createTransport({
+            host: `smtp.${config.smtpProvider}.com`,
+            port: config.port,
+            secure: config.port === 465,
+            auth: config.auth,
+        });
+        this.__user = config.auth.user;
+    }
+    async sendMail(options, config) {
+        try {
+            const mailOptions = {
+                ...options,
+                from: options.from || this.__user,
+            };
+            const res = await this.__transporter.sendMail(mailOptions);
+            return res;
+        }
+        catch (err) {
+            console.log('Error sending mail');
+            if (config?.throwError)
+                throw err;
+        }
+    }
+}
+exports.Mailer = Mailer;

package/dist/helpers/multer.helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const uploadSingleImage: (req: Req, res: Res, next: Next) => void;
+export declare const uploadMultipleImages: (req: Req, res: Res, next: Next) => void;

package/dist/helpers/multer.helpers.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMultipleImages = exports.uploadSingleImage = void 0;
+const multer_1 = __importDefault(require("multer"));
+// helpers
+const helpers_1 = require("../helpers");
+const storage = multer_1.default.memoryStorage();
+const invalidInputDataError = new helpers_1.AppError({ statusCodeName: 'BAD_REQUEST', errorCode: 'INVALID_INPUT_DATA' });
+exports.uploadSingleImage = createUploadImage('single');
+exports.uploadMultipleImages = createUploadImage('multiple');
+// internal functions
+function createUploadImage(type) {
+    const map = {
+        single: {
+            method: 'single',
+            field: 'image',
+            check: (req) => req.file,
+        },
+        multiple: {
+            method: 'array',
+            field: 'images',
+            check: (req) => req.files,
+        },
+    };
+    const config = map[type];
+    return (req, res, next) => {
+        const upload = (0, multer_1.default)({ storage, fileFilter: getFileFilter('image') })[config.method](config.field);
+        upload(req, res, (err) => {
+            if (err) {
+                next(err);
+                return;
+            }
+            if (!config.check(req)) {
+                next(invalidInputDataError);
+                return;
+            }
+            next();
+        });
+    };
+}
+function getFileFilter(fileType) {
+    return function fileFilter(_req, file, next) {
+        if (!file.mimetype.startsWith(`${fileType}/`)) {
+            next(invalidInputDataError);
+            return;
+        }
+        next(null, true);
+    };
+}

package/dist/helpers/print.helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function printInfo(label: string | undefined, msg: string): void;
+export declare function printSuccess(label: string | undefined, msg: string): void;
+export declare function printWarning(label: string | undefined, warning: string | Error): void;
+type PrintDangerConfig = {
+    printError?: boolean;
+};
+export declare function printDanger(label: string | undefined, danger: string | Error, config?: PrintDangerConfig): void;
+export {};

package/dist/helpers/print.helpers.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printDanger = exports.printWarning = exports.printSuccess = exports.printInfo = void 0;
+function printInfo(label, msg) {
+    const finalLabel = label || 'info';
+    console.log(`\x1b[34m[${finalLabel}]\x1b[0m`, msg);
+}
+exports.printInfo = printInfo;
+function printSuccess(label, msg) {
+    const finalLabel = label || 'success';
+    console.log(`\x1b[32m[${finalLabel}]\x1b[0m`, msg);
+}
+exports.printSuccess = printSuccess;
+function printWarning(label, warning) {
+    const finalLabel = label || 'warning';
+    const msg = warning instanceof Error ? `${warning.name}: ${warning.message}` : warning;
+    console.warn(`\x1b[33m[${finalLabel}]\x1b[0m`, msg);
+}
+exports.printWarning = printWarning;
+function printDanger(label, danger, config) {
+    const { printError } = config || {};
+    const finalLabel = label || 'danger';
+    const isError = danger instanceof Error;
+    const msg = isError ? `${danger.name}: ${danger.message}` : danger;
+    console.error(`\x1b[31m[${finalLabel}]\x1b[0m`, msg);
+    if (isError && printError)
+        console.error(danger);
+}
+exports.printDanger = printDanger;

package/dist/helpers/random.helpers.d.ts

@@ -0,0 +1,4 @@
+import { type RandomStringLength } from '../resources';
+export declare function getRandomString(length?: RandomStringLength | number): string;
+export declare function getRandomNumber(length?: RandomStringLength | number): string;
+export declare function generateBarcode(): string;

package/dist/helpers/random.helpers.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBarcode = exports.getRandomNumber = exports.getRandomString = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+// resources
+const resources_1 = require("../resources");
+function getRandomString(length) {
+    const buffer = crypto_1.default.randomBytes(getSize(length));
+    return buffer.toString('hex');
+}
+exports.getRandomString = getRandomString;
+function getRandomNumber(length) {
+    const buffer = crypto_1.default.randomBytes(getSize(length));
+    return [...buffer].map((b) => b % 10).join('');
+}
+exports.getRandomNumber = getRandomNumber;
+function generateBarcode() {
+    return getRandomNumber(12);
+}
+exports.generateBarcode = generateBarcode;
+// internal functions
+function getSize(length = 'short') {
+    return typeof length === 'number' ? length : resources_1.RANDOM_STRING_LENGTHS[length];
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { startServer } from './main';
+export * from './authentication';
+export * from './database';
+export * from './helpers';
+export * from './resources';
+export * from './router';
+export * from './types';
+export * from './validator';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = void 0;
+var main_1 = require("./main");
+Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return main_1.startServer; } });
+__exportStar(require("./authentication"), exports);
+__exportStar(require("./database"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./resources"), exports);
+__exportStar(require("./router"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./validator"), exports);

package/dist/main.d.ts

@@ -0,0 +1,13 @@
+import 'express-async-errors';
+import type { SetRoutes } from './router/router.types';
+import type { ConnectDatabase, DisconnectDatabase } from './database';
+import type { JobCtor } from './helpers';
+type StartServerConfig = {
+    setRoutes: SetRoutes;
+    connectDatabase: ConnectDatabase;
+    disconnectDatabase: DisconnectDatabase;
+    jobs?: JobCtor[];
+    afterDatabaseConnected?: () => void;
+};
+export declare function startServer(config: StartServerConfig): Promise<void>;
+export {};

package/dist/main.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = void 0;
+const express_1 = __importDefault(require("express"));
+require("express-async-errors");
+// middlewares
+const morgan_1 = __importDefault(require("morgan"));
+const cors_1 = __importDefault(require("cors"));
+const helmet_1 = __importDefault(require("helmet"));
+const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+const compression_1 = __importDefault(require("compression"));
+const delay_request_middleware_1 = require("./middlewares/delay-request.middleware");
+const handle_error_middleware_1 = require("./middlewares/handle-error.middleware");
+// helpers
+const helpers_1 = require("./helpers");
+async function startServer(config) {
+    const { setRoutes, connectDatabase, disconnectDatabase, jobs = [], afterDatabaseConnected } = config;
+    // app
+    const app = createApp(setRoutes);
+    // start the server
+    const PORT = (0, helpers_1.getEnvInt)('PORT', false) || 4000;
+    const server = app.listen(PORT, () => (0, helpers_1.printSuccess)('server', `server listening on port ${PORT}`));
+    // on stopping the server
+    process.on('SIGINT', handleSigint(server, disconnectDatabase));
+    // database
+    await connectDatabase();
+    afterDatabaseConnected?.();
+    jobs.forEach((job) => job.Init());
+}
+exports.startServer = startServer;
+// internal functions
+function createApp(setRoutes) {
+    // app
+    const app = (0, express_1.default)();
+    // middlewares
+    app.use((0, morgan_1.default)('dev'));
+    app.use((0, cors_1.default)());
+    app.use((0, helmet_1.default)());
+    app.use((0, express_rate_limit_1.default)({ windowMs: 10 * 1000, limit: 50 })); // 10 seg.
+    app.use((0, compression_1.default)());
+    app.use(express_1.default.json({ limit: '5mb' }));
+    app.use((0, delay_request_middleware_1.delayRequest)());
+    // routes
+    app.get('/', (_req, res) => res.send('App running...'));
+    setRoutes(app);
+    // handle error
+    app.use(handle_error_middleware_1.handleError);
+    // return
+    return app;
+}
+function handleSigint(server, disconnectDatabase) {
+    return async function () {
+        await disconnectDatabase();
+        try {
+            server.close();
+        }
+        catch (err) {
+            (0, helpers_1.printDanger)('server', err);
+        }
+        process.exit();
+    };
+}

package/dist/middlewares/delay-request.middleware.d.ts

@@ -0,0 +1 @@
+export declare function delayRequest(delayInSeconds?: number): (_req: Req, _res: Res, next: Next) => void;

package/dist/middlewares/delay-request.middleware.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delayRequest = void 0;
+// helpers
+const helpers_1 = require("../helpers");
+function delayRequest(delayInSeconds = 1) {
+    return function (_req, _res, next) {
+        if ((0, helpers_1.getEnvStr)('ENVIRONMENT') === 'development') {
+            const delay = 1000 * delayInSeconds;
+            setTimeout(next, delay);
+            return;
+        }
+        next();
+    };
+}
+exports.delayRequest = delayRequest;

package/dist/middlewares/handle-error.middleware.d.ts

@@ -0,0 +1 @@
+export declare function handleError(err: Error, _req: Req, res: Res, next: Next): void;

package/dist/middlewares/handle-error.middleware.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = void 0;
+const http_status_codes_1 = require("http-status-codes");
+// helpers
+const helpers_1 = require("../helpers");
+function handleError(err, _req, res, next) {
+    (0, helpers_1.printDanger)(undefined, err, { printError: true });
+    const statusCode = err instanceof helpers_1.AppError ? err.statusCode : http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    res.status(statusCode).json({ error: err });
+    next();
+}
+exports.handleError = handleError;

package/dist/resources/color.resources.d.ts

@@ -0,0 +1,18 @@
+export declare const COLORS: {
+    readonly coralPink: "#FF6B6B";
+    readonly warmOrange: "#FF8855";
+    readonly mandarinOrange: "#FFB76A";
+    readonly cornYellow: "#FFD54D";
+    readonly oliveGreen: "#7A7F42";
+    readonly pistachioGreen: "#A6C566";
+    readonly aquaMarine: "#5FD4BB";
+    readonly polarMint: "#80C9B4";
+    readonly arcticBlue: "#7FAFDD";
+    readonly ceruleanBlue: "#007BA2";
+    readonly cobaltBlue: "#005493";
+    readonly smokyGray: "#5F6D6E";
+    readonly ashGray: "#A1B1B5";
+    readonly softMauve: "#B495C8";
+    readonly orchidPurple: "#C66CC6";
+};
+export type Colors = keyof typeof COLORS;

package/dist/resources/color.resources.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLORS = void 0;
+exports.COLORS = {
+    coralPink: '#FF6B6B',
+    warmOrange: '#FF8855',
+    mandarinOrange: '#FFB76A',
+    cornYellow: '#FFD54D',
+    oliveGreen: '#7A7F42',
+    pistachioGreen: '#A6C566',
+    aquaMarine: '#5FD4BB',
+    polarMint: '#80C9B4',
+    arcticBlue: '#7FAFDD',
+    ceruleanBlue: '#007BA2',
+    cobaltBlue: '#005493',
+    smokyGray: '#5F6D6E',
+    ashGray: '#A1B1B5',
+    softMauve: '#B495C8',
+    orchidPurple: '#C66CC6',
+};

package/dist/resources/index.d.ts

@@ -0,0 +1,2 @@
+export * from './color.resources';
+export * from './string.resources';

package/dist/resources/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./color.resources"), exports);
+__exportStar(require("./string.resources"), exports);

package/dist/resources/refs.d.ts

@@ -0,0 +1,32 @@
+export declare const refs: {
+    readonly stringLengths: {
+        readonly extraShort: 50;
+        readonly short: 100;
+        readonly medium: 250;
+        readonly long: 500;
+        readonly extraLong: 1000;
+        readonly ultraLong: 1500;
+        readonly hyperLong: 2000;
+    };
+    readonly randomStringLengths: {
+        readonly short: 32;
+        readonly long: 64;
+    };
+    readonly colors: {
+        readonly coralPink: "#FF6B6B";
+        readonly warmOrange: "#FF8855";
+        readonly mandarinOrange: "#FFB76A";
+        readonly cornYellow: "#FFD54D";
+        readonly oliveGreen: "#7A7F42";
+        readonly pistachioGreen: "#A6C566";
+        readonly aquaMarine: "#5FD4BB";
+        readonly polarMint: "#80C9B4";
+        readonly arcticBlue: "#7FAFDD";
+        readonly ceruleanBlue: "#007BA2";
+        readonly cobaltBlue: "#005493";
+        readonly smokyGray: "#5F6D6E";
+        readonly ashGray: "#A1B1B5";
+        readonly softMauve: "#B495C8";
+        readonly orchidPurple: "#C66CC6";
+    };
+};

package/dist/resources/refs.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refs = void 0;
+exports.refs = {
+    stringLengths: {
+        extraShort: 50,
+        short: 100,
+        medium: 250,
+        long: 500,
+        extraLong: 1000,
+        ultraLong: 1500,
+        hyperLong: 2000,
+    },
+    randomStringLengths: {
+        short: 32,
+        long: 64,
+    },
+    colors: {
+        coralPink: '#FF6B6B',
+        warmOrange: '#FF8855',
+        mandarinOrange: '#FFB76A',
+        cornYellow: '#FFD54D',
+        oliveGreen: '#7A7F42',
+        pistachioGreen: '#A6C566',
+        aquaMarine: '#5FD4BB',
+        polarMint: '#80C9B4',
+        arcticBlue: '#7FAFDD',
+        ceruleanBlue: '#007BA2',
+        cobaltBlue: '#005493',
+        smokyGray: '#5F6D6E',
+        ashGray: '#A1B1B5',
+        softMauve: '#B495C8',
+        orchidPurple: '#C66CC6',
+    },
+};

package/dist/resources/string.resources.d.ts

@@ -0,0 +1,15 @@
+export declare const STRING_LENGTHS: {
+    readonly extraShort: 50;
+    readonly short: 100;
+    readonly medium: 250;
+    readonly long: 500;
+    readonly extraLong: 1000;
+    readonly ultraLong: 1500;
+    readonly hyperLong: 2000;
+};
+export type StringLength = keyof typeof STRING_LENGTHS;
+export declare const RANDOM_STRING_LENGTHS: {
+    readonly short: 32;
+    readonly long: 64;
+};
+export type RandomStringLength = keyof typeof RANDOM_STRING_LENGTHS;

package/dist/resources/string.resources.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANDOM_STRING_LENGTHS = exports.STRING_LENGTHS = void 0;
+exports.STRING_LENGTHS = {
+    extraShort: 50,
+    short: 100,
+    medium: 250,
+    long: 500,
+    extraLong: 1000,
+    ultraLong: 1500,
+    hyperLong: 2000,
+};
+exports.RANDOM_STRING_LENGTHS = {
+    short: 32,
+    long: 64,
+};

package/dist/router/app-router.class.d.ts

@@ -0,0 +1,18 @@
+import { Router } from 'express';
+import { BaseAuth } from '../authentication';
+import type { AuthMap, AuthUsers } from '../authentication/authentication.types';
+import type { RouteValidator as Validator, RouteValidate as Validate } from '../validator/validator.types';
+import type { SetRouteArgs, AuthConfig } from './router.types';
+type ApiMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export declare function getAppRouter<AM extends AuthMap, AU extends AuthUsers<AM>, BA extends BaseAuth<AM>>(authConfig: AuthConfig<AM, AU, BA>): {
+    new (app: App, basePath: string): {
+        router: Router;
+        setRoute<V extends Validator>(method: ApiMethod, path: string, validate: Validate<V>, ...args: SetRouteArgs<V, AM, BA>): void;
+        get<V_1 extends Validator>(path: string, validate: Validate<V_1>, ...args: SetRouteArgs<V_1, AM, BA>): void;
+        post<V_2 extends Validator>(path: string, validate: Validate<V_2>, ...args: SetRouteArgs<V_2, AM, BA>): void;
+        put<V_3 extends Validator>(path: string, validate: Validate<V_3>, ...args: SetRouteArgs<V_3, AM, BA>): void;
+        patch<V_4 extends Validator>(path: string, validate: Validate<V_4>, ...args: SetRouteArgs<V_4, AM, BA>): void;
+        delete<V_5 extends Validator>(path: string, validate: Validate<V_5>, ...args: SetRouteArgs<V_5, AM, BA>): void;
+    };
+};
+export {};