@gesslar/bedoc 1.11.0 → 2.1.0

package/LICENSE.txt

@@ -0,0 +1,12 @@
+Copyright (C) 2026 by Brian M. Workman bmw@gesslar.dev
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -7,14 +7,14 @@
 
 **BeDoc** is a powerful, pluggable documentation generator designed to handle
 any programming language and output format. With its extensible framework, you
-can easily create custom parsers and printers to generate structured
+can easily create custom parsers and formatters to generate structured
 documentation for your projects.
 
 ---
 
 ## Key Features
 
-- **Pluggable Design**: BeDoc works seamlessly with custom parsers and printers
+- **Pluggable Design**: BeDoc works seamlessly with custom parsers and formatters
   to fit your unique needs. BeDoc also supports async operations, allowing for
   efficient handling of large projects.
 - **Customizable Input**: Accommodate any text input, whether it’s a well-known
@@ -85,7 +85,19 @@ Contributions are welcome! Feel free to open an issue or submit a pull request.
 
 ## License
 
-This project is licensed under the [Unlicense](./LICENSE).
+`@gesslar/bedoc` is released into the public domain under the [Unlicense](LICENSE.txt).
+
+This package includes or depends on third-party components under their own
+licenses:
+
+| Dependency | License |
+| --- | --- |
+| [@gesslar/actioneer](https://github.com/gesslar/actioneer) | 0BSD |
+| [@gesslar/colours](https://github.com/gesslar/colours) | 0BSD |
+| [@gesslar/negotiator](https://github.com/gesslar/Negotiator) | 0BSD |
+| [@gesslar/toolkit](https://github.com/gesslar/toolkit) | 0BSD |
+| [commander](https://github.com/tj/commander.js) | MIT |
+| [error-stack-parser](https://github.com/stacktracejs/error-stack-parser) | MIT |
 
 ---
 

package/dist/schema/bedoc.action.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://schema.gesslar.dev/v1/bedoc-action.json",
+  "title": "BeDoc Action Schema",
+  "type": "object",
+  "properties": {
+    "accepts": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "object"
+        }
+      },
+      "required": [
+        "type"
+      ]
+    },
+    "provides": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "object"
+        }
+      },
+      "required": [
+        "type"
+      ]
+    }
+  },
+  "oneOf": [
+    {
+      "required": [
+        "accepts"
+      ]
+    },
+    {
+      "required": [
+        "provides"
+      ]
+    }
+  ]
+}

package/dist/types/Action.d.ts

@@ -0,0 +1,3 @@
+declare const _default: object;
+export default _default;
+//# sourceMappingURL=Action.d.ts.map

package/dist/types/Action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../src/Action.js"],"names":[],"mappings":""}

package/dist/types/BeDoc.d.ts

@@ -0,0 +1,208 @@
+/**
+ * @import {Glog} from "@gesslar/toolkit"
+ */
+export default class BeDoc {
+    /**
+     * Create a new instance of Core.
+     *
+     * @param {object} args
+     * @param {object} args.options - The options passed into BeDoc
+     * @param {string} args.source - The environment BeDoc is running in
+     * @param {Glog} args.glog - The Glog logger instance
+     * @returns {Promise<BeDoc>} A new instance of Core
+     */
+    static "new"({ options, source, glog, validateBeDocSchema }: {
+        options: object;
+        source: string;
+        glog: {
+            new (options?: {
+                name?: string;
+                debugLevel?: number;
+                logLevel?: number;
+                prefix?: string;
+                colours?: object;
+                symbols?: object;
+                stackTrace?: boolean;
+                tagsAsStrings?: boolean;
+                displayName?: boolean;
+                env?: string;
+            }): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            logLevel: number;
+            logPrefix: string;
+            colours: any;
+            stackTrace: boolean;
+            name: string;
+            tagsAsStrings: boolean;
+            symbols: any;
+            setLogPrefix(prefix: string): /*elided*/ any;
+            setLogLevel(level: number): /*elided*/ any;
+            withName(name: string): /*elided*/ any;
+            withColours(colours?: object): /*elided*/ any;
+            withStackTrace(enabled?: boolean): /*elided*/ any;
+            withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+            withSymbols(symbols?: object): /*elided*/ any;
+            use(prefix: string): object;
+            create(options?: object): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            execute(...args: unknown[]): void;
+            colourize(strings: Array<string>, ...values: unknown[]): void;
+            success(message: string, ...args: unknown[]): void;
+            group(...args: unknown[]): void;
+            groupEnd(): void;
+            groupDebug(message: string, level?: number): void;
+            groupInfo(message: string): void;
+            groupSuccess(message: string): void;
+            table(data: object | any[], labelOrOptions?: string | object, options?: {
+                properties?: Array<string>;
+                showHeader?: boolean;
+                quotedStrings?: boolean;
+            }): void;
+            setAlias(alias: string, colourCode: string): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            get raw(): object;
+        };
+    }): Promise<BeDoc>;
+    constructor(glog: any);
+    processFiles(): Promise<{
+        totalFiles: any;
+        succeeded: any;
+        warned: any;
+        errored: any;
+        duration: string;
+    }>;
+    #private;
+}
+//# sourceMappingURL=BeDoc.d.ts.map

package/dist/types/BeDoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeDoc.d.ts","sourceRoot":"","sources":["../../src/BeDoc.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAcE;;;;;;;;OAQG;IACH,6DALG;QAAqB,OAAO,EAApB,MAAM;QACO,MAAM,EAAnB,MAAM;QACK,IAAI;;oBAsLk/G,CAAC;0BAA4B,CAAC;wBAA0B,CAAC;sBAAwB,CAAC;uBAAyB,CAAC;uBAAyB,CAAC;0BAA4B,CAAC;6BAAgC,CAAC;2BAA8B,CAAC;mBAAsB,CAAC;;;wBAAg+B,CAAC;8BAA4B,CAAC;4BAA0B,CAAC;0BAAwB,CAAC;2BAAyB,CAAC;2BAAyB,CAAC;8BAA4B,CAAC;iCAAgC,CAAC;+BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAA+0O,CAAC;8BAAmC,CAAC;iCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;wBAAxnP,CAAC;8BAA4B,CAAC;4BAA0B,CAAC;0BAAwB,CAAC;2BAAyB,CAAC;2BAAyB,CAAC;8BAA4B,CAAC;iCAAgC,CAAC;+BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAA+0O,CAAC;8BAAmC,CAAC;iCAAgC,CAAC;;;;;;;;;;;;;;;0BAAxgW,CAAC;0BAAmC,CAAC;6BAAgC,CAAC;;;;wBAA00G,CAAC;8BAA4B,CAAC;4BAA0B,CAAC;0BAAwB,CAAC;2BAAyB,CAAC;2BAAyB,CAAC;8BAA4B,CAAC;iCAAgC,CAAC;+BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAA+0O,CAAC;8BAAmC,CAAC;iCAAgC,CAAC;;;;;;;;KArL31Y,GAAU,OAAO,CAAC,KAAK,CAAC,CAoB1B;IA/BD,uBAEC;IAyJD;;;;;;OAmCC;;CACF"}

package/dist/types/Configuration.d.ts

@@ -0,0 +1,11 @@
+export default class Configuration {
+    validate({ options, source }: {
+        options: any;
+        source: any;
+    }): Promise<{
+        status: string;
+        validated: boolean;
+    }>;
+    #private;
+}
+//# sourceMappingURL=Configuration.d.ts.map

package/dist/types/Configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Configuration.d.ts","sourceRoot":"","sources":["../../src/Configuration.js"],"names":[],"mappings":"AAUA;IACE;;;;;;OAwIC;;CAgPF"}

package/dist/types/ConfigurationParameters.d.ts

@@ -0,0 +1,3 @@
+export const ConfigurationParameters: object;
+export const ConfigurationPriorityKeys: object;
+//# sourceMappingURL=ConfigurationParameters.d.ts.map

package/dist/types/ConfigurationParameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigurationParameters.d.ts","sourceRoot":"","sources":["../../src/ConfigurationParameters.js"],"names":[],"mappings":"AAEA,6CA6IE;AAEF,+CAA6E"}

package/dist/types/Conveyor.d.ts

@@ -0,0 +1,27 @@
+export default class Conveyor {
+    constructor({ parse, print, glog, contract, output }: {
+        parse: any;
+        print: any;
+        glog: any;
+        contract: any;
+        output: any;
+    });
+    /**
+     * Defines the per-file processing pipeline.
+     *
+     * @param {ActionBuilder} builder - The Actioneer builder instance.
+     */
+    setup(builder: ActionBuilder): void;
+    /**
+     * Processes files through the parse→print pipeline with concurrency.
+     *
+     * @param {Array<FileObject>} files - List of files to process.
+     * @param {number} maxConcurrent - Maximum number of concurrent tasks.
+     * @returns {Promise<object>} - Resolves with {succeeded, errored, warned}.
+     */
+    convey(files: Array<FileObject>, maxConcurrent?: number): Promise<object>;
+    #private;
+}
+import { ActionBuilder } from "@gesslar/actioneer";
+import { FileObject } from "@gesslar/toolkit";
+//# sourceMappingURL=Conveyor.d.ts.map

package/dist/types/Conveyor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Conveyor.d.ts","sourceRoot":"","sources":["../../src/Conveyor.js"],"names":[],"mappings":"AAKA;IAOE;;;;;;OAMC;IAED;;;;OAIG;IACH,eAFW,aAAa,QASvB;IAED;;;;;;OAMG;IACH,cAJW,KAAK,CAAC,UAAU,CAAC,kBACjB,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAS3B;;CAsGF;8BAtJmD,oBAAoB;2BACzC,kBAAkB"}

package/dist/types/Discovery.d.ts

@@ -0,0 +1,215 @@
+/**
+ * @import {Glog} from "@gesslar/toolkit"
+ */
+export default class Discovery {
+    /**
+     * Constructor for Discovery.
+     *
+     * @param {object} arg - Constructor argument
+     * @param {object} arg.options - BeDoc options
+     * @param {Glog} arg.glog - Glog instance
+     */
+    constructor({ options, glog }: {
+        options: object;
+        glog: {
+            new (options?: {
+                name?: string;
+                debugLevel?: number;
+                logLevel?: number;
+                prefix?: string;
+                colours?: object;
+                symbols?: object;
+                stackTrace?: boolean;
+                tagsAsStrings?: boolean;
+                displayName?: boolean;
+                env?: string;
+            }): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            logLevel: number;
+            logPrefix: string;
+            colours: any;
+            stackTrace: boolean;
+            name: string;
+            tagsAsStrings: boolean;
+            symbols: any;
+            setLogPrefix(prefix: string): /*elided*/ any;
+            setLogLevel(level: number): /*elided*/ any;
+            withName(name: string): /*elided*/ any;
+            withColours(colours?: object): /*elided*/ any;
+            withStackTrace(enabled?: boolean): /*elided*/ any;
+            withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+            withSymbols(symbols?: object): /*elided*/ any;
+            use(prefix: string): object;
+            create(options?: object): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            execute(...args: unknown[]): void;
+            colourize(strings: Array<string>, ...values: unknown[]): void;
+            success(message: string, ...args: unknown[]): void;
+            group(...args: unknown[]): void;
+            groupEnd(): void;
+            groupDebug(message: string, level?: number): void;
+            groupInfo(message: string): void;
+            groupSuccess(message: string): void;
+            table(data: object | any[], labelOrOptions?: string | object, options?: {
+                properties?: Array<string>;
+                showHeader?: boolean;
+                quotedStrings?: boolean;
+            }): void;
+            setAlias(alias: string, colourCode: string): {
+                setOptions(options: {
+                    name?: string;
+                    debugLevel?: number;
+                    logLevel?: number;
+                    prefix?: string;
+                    colours?: object;
+                    symbols?: object;
+                    stackTrace?: boolean;
+                    tagsAsStrings?: boolean;
+                    displayName?: boolean;
+                }): /*elided*/ any;
+                withName(name: string): /*elided*/ any;
+                withLogLevel(level: number): /*elided*/ any;
+                withPrefix(prefix: string): /*elided*/ any;
+                withColours(colours?: object): /*elided*/ any;
+                withStackTrace(enabled?: boolean): /*elided*/ any;
+                withTagsAsStrings(enabled?: boolean): /*elided*/ any;
+                withSymbols(symbols?: object): /*elided*/ any;
+                noDisplayName(): /*elided*/ any;
+                use(prefix: string): object;
+                get name(): string;
+                get debugLevel(): number;
+                get options(): object;
+                newDebug(tag: string): Function;
+                debug(message: string, level?: number, ...arg: unknown[]): void;
+                info(message: string, ...arg: unknown[]): void;
+                warn(message: string, ...arg: unknown[]): void;
+                error(message: string, ...arg: unknown[]): void;
+                execute(...args: unknown[]): void;
+                colourize(strings: Array<string>, ...values: unknown[]): void;
+                success(message: string, ...args: unknown[]): void;
+                group(...args: unknown[]): void;
+                groupEnd(): void;
+                groupDebug(message: string, level?: number): void;
+                groupInfo(message: string): void;
+                groupSuccess(message: string): void;
+                table(data: object | any[], labelOrOptions?: string | object, options?: {
+                    properties?: Array<string>;
+                    showHeader?: boolean;
+                    quotedStrings?: boolean;
+                }): void;
+                get colours(): any;
+                get raw(): object;
+                "__#private@#private": any;
+            };
+            get raw(): object;
+        };
+    });
+    /**
+     * Discover actions from local or global node_modules
+     *
+     * @param {object} [specific] Configuration options for action discovery
+     * @param {FileObject} [specific.print] Print-related configuration options
+     * @param {FileObject} [specific.parse] Parse-related configuration options
+     * @param {Function} validateBeDocSchema - The validator function for BeDoc's action schema
+     * @returns {Promise<object>} A map of discovered modules
+     */
+    discoverActions(specific?: {
+        print?: FileObject;
+        parse?: FileObject;
+    }, validateBeDocSchema: Function): Promise<object>;
+    satisfyCriteria(actions: any, validatedConfig: any): {
+        parse: any[];
+        print: any[];
+    };
+    #private;
+}
+import { FileObject } from "@gesslar/toolkit";
+//# sourceMappingURL=Discovery.d.ts.map

package/dist/types/Discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Discovery.d.ts","sourceRoot":"","sources":["../../src/Discovery.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;IAME;;;;;;OAMG;IACH,+BAHG;QAAoB,OAAO,EAAnB,MAAM;QACI,IAAI;;oBAiQb,CAAC;0BACX,CAAA;wBAA0B,CAAC;sBACrB,CAAC;uBAAyB,CAAC;uBAC/B,CAAA;0BAA4B,CAAC;6BAG7B,CAAD;2BAA8B,CAAC;mBAE3B,CAAC;;;wBAuCN,CAAF;8BAEE,CAAF;4BAA0B,CAAC;0BAAwB,CAAC;2BAEpC,CAAC;2BACf,CAAJ;8BACM,CAAC;iCAAgC,CAAC;+BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA6FizI,CAAC;8BAAmC,CAAC;iCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;wBAnG17I,CAAF;8BAEE,CAAF;4BAA0B,CAAC;0BAAwB,CAAC;2BAEpC,CAAC;2BACf,CAAJ;8BACM,CAAC;iCAAgC,CAAC;+BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA6FizI,CAAC;8BAAmC,CAAC;iCAAgC,CAAC;;;;;;;;;;;;;;;0BA/Nl5I,CAAC;0BACjB,CAAC;6BAInB,CAAA;;;;wBAuHN,CAAF;8BAEE,CAAF;4BAA0B,CAAC;0BAAwB,CAAC;2BAEpC,CAAC;2BACf,CAAJ;8BACM,CAAC;iCAAgC,CAAC;+BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA6FizI,CAAC;8BAAmC,CAAC;iCAAgC,CAAC;;;;;;;;KAlZ37I,EAIA;IAED;;;;;;;;OAQG;IACH,2BALG;QAA8B,KAAK,GAA3B,UAAU;QACY,KAAK,GAA3B,UAAU;KAClB,kCACU,OAAO,CAAC,MAAM,CAAC,CA4I3B;IAqJD;;;MAsDC;;CA6CF;2BAva2E,kBAAkB"}

package/dist/types/Environment.d.ts

@@ -0,0 +1,3 @@
+declare const _default: object;
+export default _default;
+//# sourceMappingURL=Environment.d.ts.map

package/dist/types/Environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Environment.d.ts","sourceRoot":"","sources":["../../src/Environment.js"],"names":[],"mappings":""}

package/dist/types/Logger.d.ts

@@ -0,0 +1,47 @@
+export namespace loggerColours {
+    let debug: string[];
+    let info: string;
+    let warn: string;
+    let error: string;
+    let reset: string;
+}
+/**
+ * Logger class
+ *
+ * Log levels:
+ * - debug: Debugging information
+ *   - Debug levels
+ *     - 0: No/critical debug information, not error level, but, should be
+ *          logged
+ *     - 1: Basic debug information, startup, shutdown, etc
+ *     - 2: Intermediate debug information, discovery, starting to get more
+ *         detailed
+ *     - 3: Detailed debug information, parsing, processing, etc
+ *     - 4: Very detailed debug information, nerd mode!
+ * - warn: Warning information
+ * - info: Informational information
+ * - error: Error information
+ */
+export default class Logger {
+    constructor(options: any);
+    vscodeError: any;
+    vscodeWarn: any;
+    vscodeInfo: any;
+    get name(): any;
+    get debugLevel(): number;
+    get options(): {
+        name: any;
+        debugLevel: number;
+    };
+    setOptions(options: any): void;
+    lastStackLine(error?: Error, stepsRemoved?: number): ErrorStackParser.StackFrame;
+    extractFileFunction(level?: number): string;
+    newDebug(tag: any): any;
+    debug(message: any, level?: number, ...arg: any[]): void;
+    warn(message: any, ...arg: any[]): void;
+    info(message: any, ...arg: any[]): void;
+    error(message: any, ...arg: any[]): void;
+    #private;
+}
+import ErrorStackParser from "error-stack-parser";
+//# sourceMappingURL=Logger.d.ts.map

package/dist/types/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../src/Logger.js"],"names":[],"mappings":";;;;;;;AA4CA;;;;;;;;;;;;;;;;GAgBG;AAEH;IAIE,0BAYC;IALK,iBAAiD;IACjD,gBAAkD;IAClD,gBAAsD;IAK5D,gBAEC;IAED,yBAEC;IAED;;;MAKC;IAED,+BAGC;IAWD,iFAIC;IAED,4CAsCC;IAED,wBAKC;IAED,yDAGC;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;;CACF;6BA5J4B,oBAAoB"}

package/dist/types/Schema.d.ts

@@ -0,0 +1,3 @@
+declare const _default: object;
+export default _default;
+//# sourceMappingURL=Schema.d.ts.map

package/dist/types/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../src/Schema.js"],"names":[],"mappings":""}

package/dist/types/cli.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-export {}
-//# sourceMappingURL=cli.d.ts.map
+export {};
+//# sourceMappingURL=cli.d.ts.map