nyte 1.0.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 itsmuzin
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,59 @@
+<div align="center">
+  <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://i.imgur.com/zUTrtM5.png">
+      <img alt="Nyte.js logo" src="https://i.imgur.com/zUTrtM5.png" height="128">
+    </picture>
+  <h1>Nyte.js</h1>
+
+[![NPM](https://img.shields.io/npm/v/nyte.svg?style=for-the-badge&labelColor=000000)](https://www.npmjs.com/package/nyte)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg?style=for-the-badge&labelColor=000000)](../../LICENSE)
+
+</div>
+
+> A modern full-stack web framework for Node.js, focused on simplicity, developer experience, and speed.
+
+---
+
+## ✨ Features
+
+- **🚀 Blazing Fast** - Built on esbuild for lightning-fast builds and hot reload
+- **📁 File-based Routing** - Automatic routing for pages (`src/web/routes`) and APIs (`src/backend/routes`)
+- **⚛️ React 19** - Latest React with client-side hydration and streaming SSR
+- **📘 TypeScript First** - Fully typed out of the box
+- **🎨 Asset Imports** - Import images, markdown, SVG, JSON, fonts, audio, video directly
+- **🔌 WebSockets** - Native WebSocket support in backend routes
+- **🎯 Dynamic Routes** - Support for dynamic parameters in frontend and backend
+- **🛡️ Middleware** - Per-folder and per-route middleware support
+- **🔄 Hot Reload** - Native hot reload via internal WebSocket in dev mode
+- **🎭 Layouts** - Global layouts and custom 404 pages
+- **📝 Dynamic Metadata** - Per-page metadata generation
+- **📦 Smart Bundling** - Single bundle or code splitting
+- **🔒 Built-in SSL** - HTTPS out-of-the-box in Native mode
+- **🔐 Authentication** - JWT authentication built-in (HWebAuth)
+- **⚙️ CLI** - Own CLI (`nyte`) for dev and production
+- **📂 Static Files** - Serve static files from `public/`
+- **🛡️ Security** - Built-in sanitization and rate limiting
+
+---
+
+## 💬 Need Help?
+
+If you have questions or need support, feel free to reach out:
+
+[![Discord](https://img.shields.io/badge/Discord-mulinfrc-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.com/users/1264710048786026588)
+[![Gmail](https://img.shields.io/badge/Gmail-D14836?style=for-the-badge&logo=gmail&logoColor=white)](mailto:murillofrazaocunha@gmail.com)
+[![Instagram](https://img.shields.io/badge/Instagram-E4405F?style=for-the-badge&logo=instagram&logoColor=white)](https://instagram.com/itsmuh_)
+[![GitHub](https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white)](https://github.com/murillo-frazao-cunha)
+
+---
+
+## 🪪 License
+
+Copyright 2025 itsmuzin
+
+This project is licensed under the [Apache License 2.0](../../LICENSE).
+
+---
+
+
+

package/dist/adapters/express.d.ts

@@ -0,0 +1,7 @@
+import type { Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import { GenericRequest, GenericResponse, FrameworkAdapter } from '../types/framework';
+export declare class ExpressAdapter implements FrameworkAdapter {
+    type: "express";
+    parseRequest(req: ExpressRequest): GenericRequest;
+    createResponse(res: ExpressResponse): GenericResponse;
+}

package/dist/adapters/express.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressAdapter = void 0;
+class ExpressAdapter {
+    constructor() {
+        this.type = 'express';
+    }
+    parseRequest(req) {
+        return {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            body: req.body,
+            query: req.query,
+            params: req.params,
+            cookies: req.cookies || {},
+            raw: req,
+        };
+    }
+    createResponse(res) {
+        return new ExpressResponseWrapper(res);
+    }
+}
+exports.ExpressAdapter = ExpressAdapter;
+class ExpressResponseWrapper {
+    constructor(res) {
+        this.res = res;
+    }
+    get raw() {
+        return this.res;
+    }
+    status(code) {
+        this.res.status(code);
+        return this;
+    }
+    header(name, value) {
+        this.res.setHeader(name, value);
+        return this;
+    }
+    cookie(name, value, options) {
+        this.res.cookie(name, value, options || {});
+        return this;
+    }
+    clearCookie(name, options) {
+        // Filter out the deprecated 'expires' option to avoid Express deprecation warning
+        const { expires, ...filteredOptions } = options || {};
+        this.res.clearCookie(name, filteredOptions);
+        return this;
+    }
+    json(data) {
+        this.res.json(data);
+    }
+    text(data) {
+        this.res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+        this.res.send(data);
+    }
+    send(data) {
+        this.res.send(data);
+    }
+    redirect(url) {
+        this.res.redirect(url);
+    }
+}

package/dist/adapters/factory.d.ts

@@ -0,0 +1,23 @@
+import { FrameworkAdapter } from '../types/framework';
+/**
+ * Factory para criar o adapter correto baseado no framework detectado
+ */
+export declare class FrameworkAdapterFactory {
+    private static adapter;
+    /**
+     * Detecta automaticamente o framework baseado na requisição/resposta
+     */
+    static detectFramework(req: any, res: any): FrameworkAdapter;
+    /**
+     * Força o uso de um framework específico
+     */
+    static setFramework(framework: 'express' | 'fastify' | 'native'): void;
+    /**
+     * Reset do adapter (útil para testes)
+     */
+    static reset(): void;
+    /**
+     * Retorna o adapter atual (se já foi detectado)
+     */
+    static getCurrentAdapter(): FrameworkAdapter | null;
+}

package/dist/adapters/factory.js

@@ -0,0 +1,121 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkAdapterFactory = void 0;
+const express_1 = require("./express");
+const fastify_1 = require("./fastify");
+const native_1 = require("./native");
+const console_1 = __importStar(require("../api/console"));
+/**
+ * Factory para criar o adapter correto baseado no framework detectado
+ */
+class FrameworkAdapterFactory {
+    /**
+     * Detecta automaticamente o framework baseado na requisição/resposta
+     */
+    static detectFramework(req, res) {
+        // Se já detectamos antes, retorna o mesmo adapter
+        if (this.adapter) {
+            return this.adapter;
+        }
+        const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgYellow}●  ${console_1.Colors.Reset}Detecting web framework...`);
+        // Detecta Express
+        if (req.app && req.route && res.locals !== undefined) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Express`);
+            this.adapter = new express_1.ExpressAdapter();
+            return this.adapter;
+        }
+        // Detecta Fastify
+        if (req.server && req.routerPath !== undefined && res.request) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Fastify`);
+            this.adapter = new fastify_1.FastifyAdapter();
+            return this.adapter;
+        }
+        // Detecta HTTP nativo do Node.js
+        if (req.method !== undefined && req.url !== undefined && req.headers !== undefined &&
+            res.statusCode !== undefined && res.setHeader !== undefined && res.end !== undefined) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Nyte.js Native (HTTP)`);
+            this.adapter = new native_1.NativeAdapter();
+            return this.adapter;
+        }
+        // Fallback mais específico para Express
+        if (res.status && res.send && res.json && res.cookie) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Express (fallback)`);
+            this.adapter = new express_1.ExpressAdapter();
+            return this.adapter;
+        }
+        // Fallback mais específico para Fastify
+        if (res.code && res.send && res.type && res.setCookie) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Fastify (fallback)`);
+            this.adapter = new fastify_1.FastifyAdapter();
+            return this.adapter;
+        }
+        msg.end(`  ${console_1.Colors.FgYellow}●  ${console_1.Colors.Reset}Unable to detect framework. Using Nyte.js Native as default.`);
+        this.adapter = new native_1.NativeAdapter();
+        return this.adapter;
+    }
+    /**
+     * Força o uso de um framework específico
+     */
+    static setFramework(framework) {
+        switch (framework) {
+            case 'express':
+                this.adapter = new express_1.ExpressAdapter();
+                break;
+            case 'fastify':
+                this.adapter = new fastify_1.FastifyAdapter();
+                break;
+            case 'native':
+                this.adapter = new native_1.NativeAdapter();
+                break;
+            default:
+                throw new Error(`Unsupported framework: ${framework}`);
+        }
+    }
+    /**
+     * Reset do adapter (útil para testes)
+     */
+    static reset() {
+        this.adapter = null;
+    }
+    /**
+     * Retorna o adapter atual (se já foi detectado)
+     */
+    static getCurrentAdapter() {
+        return this.adapter;
+    }
+}
+exports.FrameworkAdapterFactory = FrameworkAdapterFactory;
+FrameworkAdapterFactory.adapter = null;

package/dist/adapters/fastify.d.ts

@@ -0,0 +1,25 @@
+interface FastifyRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string | string[]>;
+    body?: any;
+    query?: Record<string, any>;
+    params?: Record<string, string>;
+    cookies?: Record<string, string>;
+}
+interface FastifyReply {
+    status(code: number): FastifyReply;
+    header(name: string, value: string): FastifyReply;
+    setCookie(name: string, value: string, options?: any): FastifyReply;
+    clearCookie(name: string, options?: any): FastifyReply;
+    type(contentType: string): FastifyReply;
+    send(data: any): void;
+    redirect(url: string): void;
+}
+import { GenericRequest, GenericResponse, FrameworkAdapter } from '../types/framework';
+export declare class FastifyAdapter implements FrameworkAdapter {
+    type: "fastify";
+    parseRequest(req: FastifyRequest): GenericRequest;
+    createResponse(reply: FastifyReply): GenericResponse;
+}
+export {};

package/dist/adapters/fastify.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyAdapter = void 0;
+class FastifyAdapter {
+    constructor() {
+        this.type = 'fastify';
+    }
+    parseRequest(req) {
+        return {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            body: req.body,
+            query: req.query,
+            params: req.params,
+            cookies: req.cookies || {},
+            raw: req
+        };
+    }
+    createResponse(reply) {
+        return new FastifyResponseWrapper(reply);
+    }
+}
+exports.FastifyAdapter = FastifyAdapter;
+class FastifyResponseWrapper {
+    constructor(reply) {
+        this.reply = reply;
+    }
+    get raw() {
+        return this.reply;
+    }
+    status(code) {
+        this.reply.status(code);
+        return this;
+    }
+    header(name, value) {
+        this.reply.header(name, value);
+        return this;
+    }
+    cookie(name, value, options) {
+        this.reply.setCookie(name, value, options);
+        return this;
+    }
+    clearCookie(name, options) {
+        this.reply.clearCookie(name, options);
+        return this;
+    }
+    json(data) {
+        this.reply.send(data);
+    }
+    text(data) {
+        this.reply.type('text/plain; charset=utf-8');
+        this.reply.send(data);
+    }
+    send(data) {
+        this.reply.send(data);
+    }
+    redirect(url) {
+        this.reply.redirect(url);
+    }
+}

package/dist/adapters/native.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import { GenericRequest, GenericResponse, FrameworkAdapter } from '../types/framework';
+export declare class NativeAdapter implements FrameworkAdapter {
+    type: "native";
+    parseRequest(req: IncomingMessage): GenericRequest;
+    createResponse(res: ServerResponse): GenericResponse;
+    private parseCookies;
+}

package/dist/adapters/native.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeAdapter = void 0;
+// --- Funções Auxiliares de Segurança ---
+/**
+ * Remove caracteres de quebra de linha (\r, \n) de uma string para prevenir
+ * ataques de HTTP Header Injection (CRLF Injection).
+ * @param value O valor a ser sanitizado.
+ * @returns A string sanitizada.
+ */
+function sanitizeHeaderValue(value) {
+    return String(value).replace(/[\r\n]/g, '');
+}
+/**
+ * Valida se o nome de um cookie contém apenas caracteres permitidos pela RFC 6265.
+ * Isso previne a criação de cookies com nomes inválidos ou maliciosos.
+ * @param name O nome do cookie a ser validado.
+ * @returns `true` se o nome for válido, `false` caso contrário.
+ */
+function isValidCookieName(name) {
+    // A RFC 6265 define 'token' como 1 ou mais caracteres que não são controle nem separadores.
+    // Separadores: ( ) < > @ , ; : \ " / [ ] ? = { }
+    const validCookieNameRegex = /^[a-zA-Z0-9!#$%&'*+-.^_`|~]+$/;
+    return validCookieNameRegex.test(name);
+}
+class NativeAdapter {
+    constructor() {
+        this.type = 'native';
+    }
+    parseRequest(req) {
+        // URL absoluta é obrigatória para a API WHATWG
+        const fullUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        return {
+            method: req.method || 'GET',
+            url: req.url || '/',
+            headers: req.headers,
+            body: req.body ?? null,
+            // Converte URLSearchParams para Record<string, string | string[]>
+            query: Object.fromEntries(Array.from(fullUrl.searchParams.entries()).map(([key, value]) => {
+                const all = fullUrl.searchParams.getAll(key);
+                return [key, all.length > 1 ? all : value];
+            })),
+            params: {}, // preenchido pelo roteador
+            cookies: this.parseCookies(req.headers.cookie || ''),
+            raw: req
+        };
+    }
+    createResponse(res) {
+        return new NativeResponseWrapper(res);
+    }
+    parseCookies(cookieHeader) {
+        const cookies = {};
+        if (!cookieHeader)
+            return cookies;
+        cookieHeader.split(';').forEach(cookie => {
+            const [name, ...rest] = cookie.trim().split('=');
+            if (name && rest.length > 0) {
+                try {
+                    // Tenta decodificar o valor do cookie.
+                    cookies[name] = decodeURIComponent(rest.join('='));
+                }
+                catch (e) {
+                    // Prevenção de crash: Ignora cookies com valores malformados (e.g., URI inválida).
+                    console.error(`Warning: Malformed cookie with name "${name}" was ignored.`);
+                }
+            }
+        });
+        return cookies;
+    }
+}
+exports.NativeAdapter = NativeAdapter;
+class NativeResponseWrapper {
+    constructor(res) {
+        this.res = res;
+        this.statusCode = 200;
+        this.headers = {};
+        this.cookiesToSet = []; // Array para lidar corretamente com múltiplos cookies.
+        this.finished = false;
+    }
+    get raw() {
+        return this.res;
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    header(name, value) {
+        // Medida de segurança CRÍTICA: Previne HTTP Header Injection (CRLF Injection).
+        // Sanitiza tanto o nome quanto o valor do header para remover quebras de linha.
+        const sanitizedName = sanitizeHeaderValue(name);
+        const sanitizedValue = sanitizeHeaderValue(value);
+        if (name !== sanitizedName || String(value) !== sanitizedValue) {
+            console.warn(`Warning: Potential HTTP Header Injection attempt detected and sanitized. Original header: "${name}"`);
+        }
+        this.headers[sanitizedName] = sanitizedValue;
+        return this;
+    }
+    cookie(name, value, options) {
+        // Medida de segurança: Valida o nome do cookie.
+        if (!isValidCookieName(name)) {
+            console.error(`Error: Invalid cookie name "${name}". The cookie will not be set.`);
+            return this;
+        }
+        let cookieString = `${name}=${encodeURIComponent(value)}`;
+        if (options) {
+            // Sanitiza as opções que são strings para prevenir Header Injection.
+            if (options.domain)
+                cookieString += `; Domain=${sanitizeHeaderValue(options.domain)}`;
+            if (options.path)
+                cookieString += `; Path=${sanitizeHeaderValue(options.path)}`;
+            if (options.expires)
+                cookieString += `; Expires=${options.expires.toUTCString()}`;
+            if (options.maxAge)
+                cookieString += `; Max-Age=${options.maxAge}`;
+            if (options.httpOnly)
+                cookieString += '; HttpOnly';
+            if (options.secure)
+                cookieString += '; Secure';
+            if (options.sameSite) {
+                const sameSiteValue = typeof options.sameSite === 'boolean' ? 'Strict' : options.sameSite;
+                cookieString += `; SameSite=${sanitizeHeaderValue(sameSiteValue)}`;
+            }
+        }
+        this.cookiesToSet.push(cookieString);
+        return this;
+    }
+    clearCookie(name, options) {
+        const clearOptions = { ...options, expires: new Date(0), maxAge: 0 };
+        return this.cookie(name, '', clearOptions);
+    }
+    writeHeaders() {
+        if (this.finished)
+            return;
+        this.res.statusCode = this.statusCode;
+        Object.entries(this.headers).forEach(([name, value]) => {
+            this.res.setHeader(name, value);
+        });
+        // CORREÇÃO: Envia múltiplos cookies corretamente como headers 'Set-Cookie' separados.
+        // O método antigo de juntar com vírgula estava incorreto.
+        if (this.cookiesToSet.length > 0) {
+            this.res.setHeader('Set-Cookie', this.cookiesToSet);
+        }
+    }
+    json(data) {
+        if (this.finished)
+            return;
+        this.header('Content-Type', 'application/json; charset=utf-8');
+        this.writeHeaders();
+        const jsonString = JSON.stringify(data);
+        this.res.end(jsonString);
+        this.finished = true;
+    }
+    text(data) {
+        if (this.finished)
+            return;
+        this.header('Content-Type', 'text/plain; charset=utf-8');
+        this.writeHeaders();
+        this.res.end(data);
+        this.finished = true;
+    }
+    send(data) {
+        if (this.finished)
+            return;
+        const existingContentType = this.headers['Content-Type'];
+        if (typeof data === 'string') {
+            if (!existingContentType) {
+                this.header('Content-Type', 'text/plain; charset=utf-8');
+            }
+            this.writeHeaders();
+            this.res.end(data);
+        }
+        else if (Buffer.isBuffer(data)) {
+            this.writeHeaders();
+            this.res.end(data);
+        }
+        else if (data !== null && typeof data === 'object') {
+            this.json(data); // Reutiliza o método json para consistência
+            return; // O método json já finaliza a resposta
+        }
+        else {
+            if (!existingContentType) {
+                this.header('Content-Type', 'text/plain; charset=utf-8');
+            }
+            this.writeHeaders();
+            this.res.end(String(data));
+        }
+        this.finished = true;
+    }
+    redirect(url) {
+        if (this.finished)
+            return;
+        this.status(302);
+        // A sanitização no método .header() previne que um URL manipulado
+        // cause um ataque de Open Redirect via Header Injection.
+        this.header('Location', url);
+        this.writeHeaders();
+        this.res.end();
+        this.finished = true;
+    }
+}

package/dist/api/console.d.ts

@@ -0,0 +1,81 @@
+import { Options as BoxenOptions } from 'boxen';
+/**
+ * Um "handle" para uma linha dinâmica. As instâncias desta classe
+ * são retornadas por `Console.dynamicLine()` e usadas para controlar
+ * o conteúdo da linha.
+ */
+export declare class DynamicLine {
+    private readonly _id;
+    constructor(initialContent: string);
+    /**
+     * Atualiza o conteúdo da linha no console.
+     * @param newContent O novo texto a ser exibido.
+     */
+    update(newContent: string): void;
+    /**
+     * Finaliza a linha, opcionalmente com um texto final, e a torna estática.
+     * @param finalContent O texto final a ser exibido.
+     */
+    end(finalContent: string): void;
+}
+export declare enum Colors {
+    Reset = "\u001B[0m",
+    Bright = "\u001B[1m",
+    Dim = "\u001B[2m",
+    Underscore = "\u001B[4m",
+    Blink = "\u001B[5m",
+    Reverse = "\u001B[7m",
+    Hidden = "\u001B[8m",
+    FgBlack = "\u001B[30m",
+    FgRed = "\u001B[31m",
+    FgGreen = "\u001B[32m",
+    FgYellow = "\u001B[33m",
+    FgBlue = "\u001B[34m",
+    FgMagenta = "\u001B[35m",
+    FgCyan = "\u001B[36m",
+    FgWhite = "\u001B[37m",
+    FgGray = "\u001B[90m",
+    FgAlmostWhite = "\u001B[38;2;220;220;220m",
+    BgBlack = "\u001B[40m",
+    BgRed = "\u001B[41m",
+    BgGreen = "\u001B[42m",
+    BgYellow = "\u001B[43m",
+    BgBlue = "\u001B[44m",
+    BgMagenta = "\u001B[45m",
+    BgCyan = "\u001B[46m",
+    BgWhite = "\u001B[47m",
+    BgGray = "\u001B[100m"
+}
+export declare enum Levels {
+    ERROR = "ERROR",
+    WARN = "WARN",
+    INFO = "INFO",
+    DEBUG = "DEBUG",
+    SUCCESS = "SUCCESS"
+}
+export default class Console {
+    private static activeLines;
+    private static lastRenderedLines;
+    private static redrawDynamicLines;
+    private static writeStatic;
+    private static formatLog;
+    private static registerDynamicLine;
+    private static updateDynamicLine;
+    private static endDynamicLine;
+    static error(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static info(...args: any[]): void;
+    static success(...args: any[]): void;
+    static debug(...args: any[]): void;
+    static logCustomLevel(levelName: string, without?: boolean, color?: Colors, ...args: any[]): void;
+    static logWithout(level: Levels, colors?: Colors, ...args: any[]): void;
+    static log(level: Levels, colors?: Colors | null, ...args: any[]): void;
+    static ask(question: string, defaultValue?: string): Promise<string>;
+    static confirm(message: string, defaultYes?: boolean): Promise<boolean>;
+    static table(data: Record<string, any> | Array<{
+        Field: string;
+        Value: any;
+    }>): void;
+    static box(content: string, options?: BoxenOptions): void;
+    static dynamicLine(initialContent: string): DynamicLine;
+}