@visulima/pail 3.2.0 → 3.2.2

package/dist/reporter/json/json-reporter.server.d.ts

@@ -0,0 +1,50 @@
+import type { LiteralUnion } from "type-fest";
+import type { ExtendedRfc5424LogLevels, StreamAwareReporter } from "../../types.d.ts";
+import type { AbstractJsonReporterOptions } from "./abstract-json-reporter.d.ts";
+import { AbstractJsonReporter } from "./abstract-json-reporter.d.ts";
+/**
+ * Server JSON Reporter.
+ *
+ * A JSON reporter for Node.js server environments that outputs structured log data
+ * to stdout/stderr streams. Routes error-level logs to stderr and others to stdout.
+ * @template L - The log level type
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ *
+ * const logger = createPail({
+ *   reporters: [new JsonReporter()]
+ * });
+ *
+ * logger.info("Server started", { port: 3000 });
+ * logger.error("Database connection failed", error);
+ * ```
+ */
+declare class JsonReporter<L extends string = string> extends AbstractJsonReporter<L> implements StreamAwareReporter<L> {
+    #private;
+    /**
+     * Creates a new Server JSON Reporter instance.
+     * @param options Configuration options for JSON formatting
+     */
+    constructor(options?: Partial<AbstractJsonReporterOptions>);
+    /**
+     * Sets the stdout stream for the reporter.
+     * @param stdout_ The writable stream to use for stdout output
+     */
+    setStdout(stdout_: NodeJS.WriteStream): void;
+    /**
+     * Sets the stderr stream for the reporter.
+     * @param stderr_ The writable stream to use for stderr output
+     */
+    setStderr(stderr_: NodeJS.WriteStream): void;
+    /**
+     * Outputs the JSON message to the appropriate stream.
+     *
+     * Routes error and warning level messages to stderr, others to stdout.
+     * @param message The JSON-formatted log message
+     * @param logLevel The log level determining which stream to use
+     * @protected
+     */
+    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}
+export default JsonReporter;

package/dist/reporter/pretty/abstract-pretty-reporter.d.ts

@@ -0,0 +1,83 @@
+import type { LiteralUnion } from "type-fest";
+import type { DefaultLogTypes, LoggerTypesAwareReporter, LoggerTypesConfig, ReadonlyMeta } from "../../types.d.ts";
+/**
+ * Default date formatter for pretty reporters.
+ *
+ * Formats a Date object as HH:MM:SS (24-hour format).
+ * @param date The date to format
+ * @returns Formatted time string
+ * @example
+ * ```typescript
+ * dateFormatter(new Date()); // "14:30:25"
+ * ```
+ */
+export declare const dateFormatter: (date: Date) => string;
+/**
+ * Abstract Pretty Reporter.
+ *
+ * Base class for pretty-printing reporters that format log messages with colors,
+ * styles, and structured layout. Provides common functionality for styling options
+ * and logger type configuration.
+ * @template T - Custom logger type names
+ * @template L - Log level types
+ * @example
+ * ```typescript
+ * class CustomPrettyReporter extends AbstractPrettyReporter {
+ *   public log(meta: ReadonlyMeta) {
+ *     const formatted = this.formatMessage(meta);
+ *     console.log(formatted);
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class AbstractPrettyReporter<T extends string = string, L extends string = string> implements LoggerTypesAwareReporter<T, L> {
+    /** Styling options for pretty formatting */
+    protected readonly styles: PrettyStyleOptions;
+    /** Logger type configurations for styling */
+    protected loggerTypes: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>;
+    /**
+     * Creates a new AbstractPrettyReporter instance.
+     * @param options Styling options for pretty formatting
+     * @protected
+     */
+    protected constructor(options: Partial<PrettyStyleOptions>);
+    /**
+     * Sets the logger types configuration for styling.
+     * @param types Logger type configurations with colors and labels
+     */
+    setLoggerTypes(types: LoggerTypesConfig<LiteralUnion<DefaultLogTypes, T>, L>): void;
+    /**
+     * Logs a message with pretty formatting.
+     * @param meta The log metadata to format and output
+     * @abstract
+     */
+    abstract log(meta: ReadonlyMeta<L>): void;
+}
+/**
+ * Options for configuring pretty reporter styling.
+ */
+export type PrettyStyleOptions = {
+    /** Bold styling options */
+    bold: {
+        /** Whether to bold the label text */
+        label: boolean;
+    };
+    /** Function to format dates in log output */
+    dateFormatter: (date: Date) => string;
+    /** Maximum length of message before line break (optional) */
+    messageLength: number | undefined;
+    /** Underline styling options */
+    underline: {
+        /** Whether to underline the label */
+        label: boolean;
+        /** Whether to underline prefixes */
+        prefix: boolean;
+        /** Whether to underline suffixes */
+        suffix: boolean;
+    };
+    /** Uppercase styling options */
+    uppercase: {
+        /** Whether to uppercase the label text */
+        label: boolean;
+    };
+};

package/dist/reporter/pretty/index.browser.d.ts

@@ -1,13 +1,2 @@
-import { A as AbstractPrettyReporter, P as PrettyStyleOptions } from '../../packem_shared/abstract-pretty-reporter-BbOWXMCs.js';
-import { e as ReadonlyMeta } from '../../packem_shared/types-D3ycu8-x.js';
-import 'type-fest';
-import '@visulima/colorize';
-import '../../interactive/index.js';
-
-declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> {
-    #private;
-    constructor(options?: Partial<PrettyStyleOptions>);
-    log(meta: ReadonlyMeta<L>): void;
-}
-
-export { PrettyReporter, PrettyStyleOptions };
+export type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
+export { default as PrettyReporter } from "./pretty-reporter.d.ts";

package/dist/reporter/pretty/index.d.ts

@@ -1,25 +1,2 @@
-import { O as Options$1, a as Options } from '../../packem_shared/index.d-BR1GjZri.js';
-import { LiteralUnion } from 'type-fest';
-import { InteractiveManager } from '../../interactive/index.js';
-import { I as InteractiveStreamReporter, e as ReadonlyMeta, E as ExtendedRfc5424LogLevels } from '../../packem_shared/types-D3ycu8-x.js';
-import { P as PrettyStyleOptions, A as AbstractPrettyReporter } from '../../packem_shared/abstract-pretty-reporter-BbOWXMCs.js';
-import '@visulima/colorize';
-
-type PrettyReporterOptions = PrettyStyleOptions & {
-    error: Partial<Omit<Options$1, "color" | "prefix" | "indentation">>;
-    inspect: Partial<Options>;
-};
-declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
-    #private;
-    constructor(options?: Partial<PrettyReporterOptions>);
-    setStdout(stdout_: NodeJS.WriteStream): void;
-    setStderr(stderr_: NodeJS.WriteStream): void;
-    setInteractiveManager(manager?: InteractiveManager): void;
-    setIsInteractive(interactive: boolean): void;
-    log(meta: ReadonlyMeta<L>): void;
-    protected _formatMessage(data: ReadonlyMeta<L>): string;
-    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
-}
-
-export { PrettyReporter };
-export type { PrettyReporterOptions };
+export type { PrettyReporterOptions } from "./pretty-reporter.d.ts";
+export { PrettyReporter } from "./pretty-reporter.d.ts";

package/dist/reporter/pretty/pretty-reporter.browser.d.ts

@@ -0,0 +1,36 @@
+import type { ReadonlyMeta } from "../../types.d.ts";
+import type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
+import { AbstractPrettyReporter } from "./abstract-pretty-reporter.d.ts";
+/**
+ * Browser Pretty Reporter.
+ *
+ * A pretty-printing reporter for browser environments that formats log messages
+ * with colors and structured layout for console output. Uses browser-compatible
+ * color formatting and console APIs.
+ * @template T - Custom logger type names
+ * @template L - Log level types
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ *
+ * const logger = createPail({
+ *   reporters: [new PrettyReporter({
+ *     bold: { label: true },
+ *     uppercase: { label: true }
+ *   })]
+ * });
+ *
+ * logger.info("Application started");
+ * logger.error("Something went wrong", error);
+ * ```
+ */
+declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> {
+    #private;
+    /**
+     * Creates a new Browser Pretty Reporter instance.
+     * @param options Styling options for pretty formatting
+     */
+    constructor(options?: Partial<PrettyStyleOptions>);
+    log(meta: ReadonlyMeta<L>): void;
+}
+export default PrettyReporter;

package/dist/reporter/pretty/pretty-reporter.server.d.ts

@@ -0,0 +1,70 @@
+import type { RenderErrorOptions } from "@visulima/error/error";
+import type { Options as InspectorOptions } from "@visulima/inspector";
+import type { LiteralUnion } from "type-fest";
+import type InteractiveManager from "../../interactive/interactive-manager.d.ts";
+import type { ExtendedRfc5424LogLevels, InteractiveStreamReporter, ReadonlyMeta } from "../../types.d.ts";
+import type { PrettyStyleOptions } from "./abstract-pretty-reporter.d.ts";
+import { AbstractPrettyReporter } from "./abstract-pretty-reporter.d.ts";
+/**
+ * Options for configuring the Server Pretty Reporter.
+ */
+export type PrettyReporterOptions = PrettyStyleOptions & {
+    /** Error rendering options */
+    error: Partial<Omit<RenderErrorOptions, "color" | "prefix" | "indentation">>;
+    /** Object inspection options */
+    inspect: Partial<InspectorOptions>;
+};
+/**
+ * Server Pretty Reporter.
+ *
+ * A comprehensive pretty-printing reporter for Node.js server environments that
+ * formats log messages with colors, structured layout, and advanced features like
+ * error rendering, object inspection, and interactive terminal support.
+ * @template T - Custom logger type names
+ * @template L - Log level types
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ *
+ * const logger = createPail({
+ *   reporters: [new PrettyReporter({
+ *     bold: { label: true },
+ *     error: { color: { title: 'red' } }
+ *   })]
+ * });
+ *
+ * logger.info("Server started on port 3000");
+ * logger.error("Database error", dbError);
+ * ```
+ */
+export declare class PrettyReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
+    #private;
+    /**
+     * Creates a new Server Pretty Reporter instance.
+     * @param options Configuration options for styling, error rendering, and object inspection
+     */
+    constructor(options?: Partial<PrettyReporterOptions>);
+    /**
+     * Sets the stdout stream for the reporter.
+     * @param stdout_ The writable stream to use for standard output
+     */
+    setStdout(stdout_: NodeJS.WriteStream): void;
+    /**
+     * Sets the stderr stream for the reporter.
+     * @param stderr_ The writable stream to use for error output
+     */
+    setStderr(stderr_: NodeJS.WriteStream): void;
+    /**
+     * Sets the interactive manager for handling interactive output.
+     * @param manager The interactive manager instance, or undefined to disable
+     */
+    setInteractiveManager(manager?: InteractiveManager): void;
+    /**
+     * Enables or disables interactive mode.
+     * @param interactive Whether to enable interactive terminal features
+     */
+    setIsInteractive(interactive: boolean): void;
+    log(meta: ReadonlyMeta<L>): void;
+    protected _formatMessage(data: ReadonlyMeta<L>): string;
+    protected _log(message: string, logLevel: LiteralUnion<ExtendedRfc5424LogLevels, L>): void;
+}

package/dist/reporter/raw/raw-reporter.browser.d.ts

@@ -0,0 +1,5 @@
+import type { ReadonlyMeta, Reporter } from "../../types.d.ts";
+declare class RawReporter<L extends string = string> implements Reporter<L> {
+    log(meta: ReadonlyMeta<L>): void;
+}
+export default RawReporter;

package/dist/reporter/raw/raw-reporter.server.d.ts

@@ -0,0 +1,13 @@
+import type { Options as InspectorOptions } from "@visulima/inspector";
+import type InteractiveManager from "../../interactive/interactive-manager.d.ts";
+import type { ReadonlyMeta, StreamAwareReporter } from "../../types.d.ts";
+declare class RawReporter<L extends string = string> implements StreamAwareReporter<L> {
+    #private;
+    constructor(inspectOptions?: Partial<InspectorOptions>);
+    setStdout(stdout_: NodeJS.WriteStream): void;
+    setStderr(stderr_: NodeJS.WriteStream): void;
+    setInteractiveManager(manager?: InteractiveManager): void;
+    setIsInteractive(interactive: boolean): void;
+    log(meta: ReadonlyMeta<L>): void;
+}
+export default RawReporter;

package/dist/reporter/simple/simple-reporter.server.d.ts

@@ -1,15 +1,14 @@
-import { O as Options$1, a as Options } from '../../packem_shared/index.d-BR1GjZri.js';
-import { InteractiveManager } from '../../interactive/index.js';
-import { I as InteractiveStreamReporter, e as ReadonlyMeta } from '../../packem_shared/types-D3ycu8-x.js';
-import { P as PrettyStyleOptions, A as AbstractPrettyReporter } from '../../packem_shared/abstract-pretty-reporter-BbOWXMCs.js';
-import 'type-fest';
-import '@visulima/colorize';
-
-type SimpleReporterOptions = PrettyStyleOptions & {
-    error: Partial<Omit<Options$1, "color | prefix | indentation">>;
-    inspect: Partial<Options>;
+import type { RenderErrorOptions } from "@visulima/error";
+import type { Options as InspectorOptions } from "@visulima/inspector";
+import type InteractiveManager from "../../interactive/interactive-manager.d.ts";
+import type { InteractiveStreamReporter, ReadonlyMeta } from "../../types.d.ts";
+import type { PrettyStyleOptions } from "../pretty/abstract-pretty-reporter.d.ts";
+import { AbstractPrettyReporter } from "../pretty/abstract-pretty-reporter.d.ts";
+export type SimpleReporterOptions = PrettyStyleOptions & {
+    error: Partial<Omit<RenderErrorOptions, "color | prefix | indentation">>;
+    inspect: Partial<InspectorOptions>;
 };
-declare class SimpleReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
+export declare class SimpleReporter<T extends string = string, L extends string = string> extends AbstractPrettyReporter<T, L> implements InteractiveStreamReporter<L> {
     #private;
     constructor(options?: Partial<SimpleReporterOptions>);
     setStdout(stdout_: NodeJS.WriteStream): void;
@@ -19,6 +18,3 @@ declare class SimpleReporter<T extends string = string, L extends string = strin
     log(meta: ReadonlyMeta<L>): void;
     protected formatMessage(data: ReadonlyMeta<L>): string;
 }
-
-export { SimpleReporter };
-export type { SimpleReporterOptions };

package/dist/reporter/utils/default-inspector-config.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from "@visulima/inspector";
+declare const defaultInspectorConfig: Partial<Options>;
+export default defaultInspectorConfig;

package/dist/reporter/utils/format-label.d.ts

@@ -0,0 +1,3 @@
+import type { PrettyStyleOptions } from "../pretty/abstract-pretty-reporter.d.ts";
+declare const formatLabel: (label: string, styles: PrettyStyleOptions) => string;
+export default formatLabel;

package/dist/spinner.d.ts

@@ -1,154 +1,220 @@
-import { InteractiveManager } from './interactive/index.js';
-
-// TODO: Load the spinner names from the JSON file.
-type SpinnerName =
-	| 'dots'
-	| 'dots2'
-	| 'dots3'
-	| 'dots4'
-	| 'dots5'
-	| 'dots6'
-	| 'dots7'
-	| 'dots8'
-	| 'dots9'
-	| 'dots10'
-	| 'dots11'
-	| 'dots12'
-	| 'dots13'
-	| 'dots14'
-	| 'dots8Bit'
-	| 'dotsCircle'
-	| 'sand'
-	| 'line'
-	| 'line2'
-	| 'rollingLine'
-	| 'pipe'
-	| 'simpleDots'
-	| 'simpleDotsScrolling'
-	| 'star'
-	| 'star2'
-	| 'flip'
-	| 'hamburger'
-	| 'growVertical'
-	| 'growHorizontal'
-	| 'balloon'
-	| 'balloon2'
-	| 'noise'
-	| 'bounce'
-	| 'boxBounce'
-	| 'boxBounce2'
-	| 'binary'
-	| 'triangle'
-	| 'arc'
-	| 'circle'
-	| 'squareCorners'
-	| 'circleQuarters'
-	| 'circleHalves'
-	| 'squish'
-	| 'toggle'
-	| 'toggle2'
-	| 'toggle3'
-	| 'toggle4'
-	| 'toggle5'
-	| 'toggle6'
-	| 'toggle7'
-	| 'toggle8'
-	| 'toggle9'
-	| 'toggle10'
-	| 'toggle11'
-	| 'toggle12'
-	| 'toggle13'
-	| 'arrow'
-	| 'arrow2'
-	| 'arrow3'
-	| 'bouncingBar'
-	| 'bouncingBall'
-	| 'smiley'
-	| 'monkey'
-	| 'hearts'
-	| 'clock'
-	| 'earth'
-	| 'material'
-	| 'moon'
-	| 'runner'
-	| 'pong'
-	| 'shark'
-	| 'dqpb'
-	| 'weather'
-	| 'christmas'
-	| 'grenade'
-	| 'point'
-	| 'layer'
-	| 'betaWave'
-	| 'fingerDance'
-	| 'fistBump'
-	| 'soccerHeader'
-	| 'mindblown'
-	| 'speaker'
-	| 'orangePulse'
-	| 'bluePulse'
-	| 'orangeBluePulse'
-	| 'timeTravel'
-	| 'aesthetic'
-	| 'dwarfFortress';
-
-interface SpinnerStyle {
+import type { SpinnerName } from "cli-spinners";
+import type InteractiveManager from "./interactive/interactive-manager.d.ts";
+/**
+ * Spinner style configuration using colorize.
+ */
+export interface SpinnerStyle {
+    /** Background color name (e.g., "bgRed", "bgBlue") */
     bgColor?: string;
+    /** Background color as hex (e.g., "#FF0000") */
     bgHex?: `#${string}`;
+    /** Background color as RGB (e.g., [255, 0, 0]) */
     bgRgb?: [number, number, number];
+    /** Apply bold style */
     bold?: boolean;
+    /** Foreground color name (e.g., "red", "blue", "green") */
     color?: string;
+    /** Apply dim/faint style */
     dim?: boolean;
+    /** Foreground color as hex (e.g., "#FF0000") */
     hex?: `#${string}`;
+    /** Apply inverse style (swap fg/bg) */
     inverse?: boolean;
+    /** Apply italic style */
     italic?: boolean;
+    /** Apply overline style */
     overline?: boolean;
+    /** Foreground color as RGB (e.g., [255, 0, 0]) */
     rgb?: [number, number, number];
+    /** Apply strikethrough style */
     strikethrough?: boolean;
+    /** Apply underline style */
     underline?: boolean;
 }
-interface SpinnerIcons {
+/**
+ * Spinner completion icons.
+ */
+export interface SpinnerIcons {
+    /** Icon to show on failure (default: "✖") */
     error?: string;
+    /** Icon to show on info (default: "ℹ") */
     info?: string;
+    /** Icon to show on success (default: "✓") */
     success?: string;
+    /** Icon to show on warning (default: "⚠") */
     warning?: string;
 }
-interface SpinnerOptions {
+/**
+ * Spinner style options.
+ */
+export interface SpinnerOptions {
+    /** Custom icons for completion states */
     icons?: SpinnerIcons;
+    /** Name of the spinner from cli-spinners */
     name?: SpinnerName;
+    /** Prefix text to show before the spinner */
     prefixText?: string;
+    /** Style configuration for the spinner */
     style?: SpinnerStyle;
+    /** Whether to output spinner (default: true) */
     verbose?: boolean;
 }
-interface SpinnerStartOptions {
+/**
+ * Options for starting a spinner.
+ */
+export interface SpinnerStartOptions {
+    /** Prefix text to show before the spinner */
     prefixText?: string;
 }
-declare class Spinner {
+/**
+ * Spinner class for creating loading indicators in terminal applications.
+ *
+ * Provides an easy-to-use interface for displaying spinners with various styles
+ * from the cli-spinners library. Works seamlessly with interactive terminal features.
+ * @example
+ * ```typescript
+ * const spinner = new Spinner({ name: "dots" });
+ * spinner.start("Loading...");
+ * // ... do work ...
+ * spinner.succeed("Done!");
+ * ```
+ */
+export declare class Spinner {
     #private;
+    /**
+     * Creates a new Spinner instance.
+     * @param options Configuration options for the spinner
+     * @param interactiveManager Optional interactive manager for terminal control
+     */
     constructor(options?: SpinnerOptions, interactiveManager?: InteractiveManager);
+    /**
+     * Current elapsed time in milliseconds.
+     */
     get elapsedTime(): number;
+    /**
+     * Get or set the spinner text.
+     */
     get getText(): string;
     set text(value: string);
+    /**
+     * Get or set the prefix text.
+     */
     get getPrefixText(): string;
     set prefixText(value: string);
+    /**
+     * Whether the spinner is currently active.
+     */
     get isRunning(): boolean;
+    /**
+     * Set the interactive manager for interactive mode.
+     * @internal
+     */
+    setInteractiveManager(manager?: InteractiveManager): void;
+    /**
+     * Set the multi spinner reference.
+     * @internal
+     */
+    setMultiSpinner(multiSpinner?: MultiSpinner): void;
+    /**
+     * Start the spinner with optional text.
+     * @param text Optional text to display
+     * @param options
+     * @param options.prefixText Optional prefix text to display
+     * @returns The spinner instance for chaining
+     */
     start(text?: string, options?: SpinnerStartOptions): this;
+    /**
+     * Stop the spinner with a success message.
+     * @param text Optional success text
+     */
     succeed(text?: string): void;
+    /**
+     * Stop the spinner with a failure message.
+     * @param text Optional failure text
+     */
     failed(text?: string): void;
+    /**
+     * Stop the spinner with a warning message.
+     * @param text Optional warning text
+     */
     warn(text?: string): void;
+    /**
+     * Stop the spinner with an info message.
+     * @param text Optional info text
+     */
     info(text?: string): void;
+    /**
+     * Pause the spinner without stopping it.
+     */
     pause(): void;
+    /**
+     * Resume the spinner if it was paused.
+     */
     resume(): void;
+    /**
+     * Get current frame output.
+     * @internal
+     */
+    getFrameOutput(): string;
 }
-declare class MultiSpinner {
+/**
+ * Multi-Spinner class for managing multiple spinners concurrently.
+ *
+ * Allows displaying and updating multiple spinners simultaneously with
+ * consistent formatting and management.
+ * @example
+ * ```typescript
+ * const multiSpinner = new MultiSpinner({ name: "dots" });
+ *
+ * const spinner1 = multiSpinner.create("Task 1");
+ * const spinner2 = multiSpinner.create("Task 2");
+ *
+ * spinner1.start();
+ * spinner2.start();
+ *
+ * // ... do work ...
+ *
+ * spinner1.succeed();
+ * spinner2.succeed();
+ * multiSpinner.stop();
+ * ```
+ */
+export declare class MultiSpinner {
     #private;
     constructor(options?: SpinnerOptions, interactiveManager?: InteractiveManager);
+    /**
+     * Set the interactive manager for interactive mode.
+     * @internal
+     */
+    setInteractiveManager(manager?: InteractiveManager): void;
+    /**
+     * Create a new spinner instance.
+     * @param text Initial text for the spinner
+     * @param options
+     * @param options.prefixText Optional prefix text to display
+     * @param options.style Optional style for the spinner
+     * @param options.verbose Whether to output spinner (default: true)
+     * @returns A new Spinner instance
+     */
     create(text?: string, options?: SpinnerOptions): Spinner;
+    /**
+     * Remove a spinner from the multi-spinner manager.
+     * @param spinner The spinner to remove
+     * @returns True if the spinner was removed, false otherwise
+     */
     remove(spinner: Spinner): boolean;
+    /**
+     * Stop all spinners.
+     */
     stop(): void;
+    /**
+     * Clear all spinners without stopping them.
+     */
     clear(): void;
+    /**
+     * Render all spinners.
+     * @internal
+     */
+    renderAll(): void;
 }
-type SpinnerType<T extends string = string, L extends string = string> = Record<T, L> & Spinner;
-
-export { MultiSpinner, Spinner };
-export type { SpinnerIcons, SpinnerOptions, SpinnerStartOptions, SpinnerStyle, SpinnerType };
+export type SpinnerType<T extends string = string, L extends string = string> = Record<T, L> & Spinner;