import { OptionParser } from "./frontend.js";
import SettingsSpec from './settingsSpec.js';
import { Settings } from "./settings.js";
import Parser from "./parser.js";
import Writer from "./writer.js";
import Reader from "./reader.js";
import Output from "./io/output.js";
import Input from "./io/input.js";
import { DebugFunction, Document, InputConstructor, LoggerType, OutputConstructor } from "./types.js";
export interface SetupOptionParserArgs {
    usage?: string;
    description?: string;
    settingsSpec?: SettingsSpec;
    configSection?: string;
    defaults?: {};
}
export interface ProcessCommandLineArgs {
    argv: string[];
    usage?: string;
    description?: string;
    settingsSpec?: SettingsSpec;
    configSection?: string;
    settingsOverrides?: {};
}
export interface PublisherArgs {
    reader?: Reader;
    parser?: Parser;
    writer?: Writer;
    source?: Input;
    sourceClass?: InputConstructor;
    destination?: Output<any>;
    destinationClass?: OutputConstructor<any>;
    settings?: Settings;
    debugFn?: DebugFunction;
    debug?: boolean;
    logger: LoggerType;
}
/**
 * A facade encapsulating the high-level logic of a Docutils system.
 */
export declare class Publisher {
    get document(): Document | undefined;
    private sourceClass?;
    settings?: Settings;
    private debugFn;
    private reader?;
    private _document;
    private parser?;
    private writer?;
    private source?;
    private destination?;
    private destinationClass?;
    private debug;
    /**
     * Create a publisher instance.
     * @param {Object} args - arguments
     * @param {Reader} args.reader - instance of StandaloneReader
     * @param {Parser} args.parser - instance of Parser
     * @param {Writer} args.writer - instance of Writer
     * @param {Source} args.source - instance of Source
     * @param {function} args.sourceClass - class for source, mutually exclusive with souce paramter
     * @param {Destination} args.destination - where the output should be written
     * @param {function} args.destinationClass - Class for destination, mutually
     *                                           exclusive with destination paramter.
     * @param {object} args.settings - Settings for docutils engine.
     * @param {function} args.debugFn - Debug function.
     */
    private logger;
    constructor(args: PublisherArgs);
    setReader(readerName: string | undefined, parser?: Parser, parserName?: string): void;
    setWriter(writerName: string | undefined): void;
    setComponents(readerName?: string, parserName?: string, writerName?: string): void;
    setupOptionParser(args: SetupOptionParserArgs): OptionParser;
    process_programmatic_settings(settings_spec: any, settings_overrides: Record<string, any> | null, configSection?: string): void;
    get_settings(options: {
        usage?: string;
        description?: string;
        settingsSpec?: any;
        configSection?: string;
        [key: string]: any;
    }): any;
    processCommandLine(args: ProcessCommandLineArgs): void;
    setIO(sourcePath?: string, destinationPath?: string): void;
    setSource(args: {
        source?: {};
        sourcePath?: string;
    }): void;
    setDestination(args: {
        destination?: Output<{}>;
        destinationPath?: string;
    }): void;
    applyTransforms(): void;
    publish(args: any): Promise<any>;
    debuggingDumps(): void;
}