/// <reference types="node" />

import connect from 'connect';
import { default as ejs_2 } from 'ejs';
import type { FSWatcher } from 'chokidar';
import http from 'http';
import { Liquid } from 'liquidjs';
import MarkdownIt from 'markdown-it';
import path from 'path';
import * as ulka from '@ulkajs/template-engine';

export declare function box(str: string, padding?: number, fn?: Function): string;

export declare function build(ulka: Ulka): Promise<void>;

export declare function clearConsole(): void;

export declare class Collection {
    ulka: Ulka;
    name: string;
    contents: Template[];
    config?: ValidContentConfig;
    constructor(ulka: Ulka, name: string);
    updateConfig(config: ContentConfig): this;
    read(): Promise<void>;
    write(): Promise<this>;
    getContents(cwd?: string): Promise<void>;
    paginate(): void;
}

export declare interface Configs {
    input: string;
    output: string;
    layout: string;
    contents: {
        [key: string]: ContentConfig;
    };
    verbose: boolean;
    plugins: PluginConfig[];
    copy: ({
        match: string[] | string;
        output: (path: string) => string;
    } | string | string[])[];
    metaData: {
        [key: string]: any;
    };
    concurrency: number;
}

export declare type ContentConfig = Partial<ValidContentConfig>;

export declare function defineConfig(configs: Partial<Configs> | ((ulka: Ulka) => Partial<Configs>) | ((ulka: Ulka) => Promise<Partial<Configs>>)): Partial<Configs> | ((ulka: Ulka) => Partial<Configs>) | ((ulka: Ulka) => Promise<Partial<Configs>>);

export declare class EjsTemplate extends Template {
    static ejs: typeof ejs_2;
    static reset(): void;
    compile(): Promise<(ctx?: object) => Promise<string>>;
    get hasMatter(): boolean;
    get buildExt(): string;
}

export declare interface Engines {
    '.ejs': typeof EjsTemplate;
    '.liquid': typeof LiquidTemplate;
    '.md': typeof MdTemplate;
    '.ulka': typeof UlkaTemplate;
    default: typeof Template;
    [key: string]: typeof Template;
}

export declare class FileInfo {
    filepath: string;
    parsedpath: path.ParsedPath;
    buffer: Buffer | undefined;
    constructor(filepath: string);
    read(): Promise<this>;
    get str(): string;
}

export declare class LiquidTemplate extends Template {
    static liquid: Liquid;
    static reset(): void;
    compile(): Promise<(ctx?: object) => Promise<any>>;
    get hasMatter(): boolean;
    get buildExt(): string;
}

export declare class MdTemplate extends Template {
    static md: MarkdownIt;
    static reset(): void;
    compile(): Promise<(ctx?: object) => Promise<any>>;
    get hasMatter(): boolean;
    get buildExt(): string;
}

declare type Plugin_2<T = any> = (options: T) => Partial<{
    [key in PluginName]: PluginFunction<key>;
}>;
export { Plugin_2 as Plugin }

export declare type PluginArg<T extends PluginName> = T extends 'beforeRender' | 'afterRender' | 'beforeWrite' | 'afterWrite' | 'beforeCreateContext' | 'afterCreateContext' ? {
    template: Template;
    ulka: Ulka;
} : {
    ulka: Ulka;
};

export declare type PluginConfig = string | {
    plugin: string;
    options: {
        [key: string]: any;
    };
} | Plugin_2;

export declare type PluginFunction<T extends PluginName = any> = (arg: PluginArg<T>) => any;

export declare type PluginName = 'afterSetup' | 'beforeBuild' | 'afterBuild' | 'beforeCreateContext' | 'afterCreateContext' | 'beforeRender' | 'afterRender' | 'beforeWrite' | 'afterWrite';

export declare type PluginsList = {
    [key in PluginName]: PluginFunction<key>[];
};

export declare function resolvePlugin(pluginConfig: PluginConfig, ulka: Ulka): void;

export declare function runPlugins<T extends PluginName = any>(name: T, options: PluginArg<T>): Promise<void>;

export declare function setup(cwd: string, task: string, cpath: string): Promise<Ulka>;

export declare const slugify: (str: string) => string;

export declare class Template {
    ulka: Ulka;
    fileinfo: FileInfo;
    configName?: string | undefined;
    configLayout?: string | ((temp: Template) => string) | null | undefined;
    configLink?: string | ((temp: Template) => string) | null | undefined;
    content: string | Buffer;
    link: string;
    buildPath: string;
    context: {
        [key: string]: any;
    };
    constructor(ulka: Ulka, fileinfo: FileInfo, configName?: string | undefined, configLayout?: string | ((temp: Template) => string) | null | undefined, configLink?: string | ((temp: Template) => string) | null | undefined);
    static reset(): void;
    clone(): Template;
    compile(): Promise<(_ctx?: object) => Promise<string | Buffer>>;
    protected layout(content: string | Buffer, ctx?: {
        [key: string]: any;
    }): Promise<string | Buffer>;
    render(ctx?: object): Promise<void>;
    write(content?: string | Buffer): Promise<this>;
    createCtx(ctx?: object): this;
    readMatter(): this;
    getBuildPath(ext?: string): {
        link: string;
        buildPath: string;
    };
    log(): void;
    _renderUlkaTemplate(data: string, context?: object): string;
    get hasMatter(): boolean;
    get buildExt(): string;
    get contentShouldBeString(): boolean;
}

export declare class Ulka {
    cwd: string;
    task: string;
    configpath: string;
    port: number;
    engines: Engines;
    layout?: Collection;
    configs: Configs;
    server: UlkaServer;
    plugins: PluginsList;
    collections: {
        [key: string]: Collection;
    };
    collectionContents: any;
    private constructor();
    private _setup;
    static init(cwd: string, task: string, configpath: string, port?: number): Promise<Ulka>;
    reset(): Promise<this>;
    getLayouts(): Promise<void>;
    getCollections(): Promise<this>;
    write(): Promise<void>;
    copy(cwd?: string): Promise<string[]>;
}

export declare class UlkaError extends Error {
    custom: string;
    constructor(message: string, custom: string);
}

export declare class UlkaServer {
    base: string;
    port: number;
    app: connect.Server;
    server: http.Server;
    wss: {
        send(data: string): void;
        reload(): void;
        reloadCss(): void;
    };
    use: {
        (fn: connect.NextHandleFunction): connect.Server;
        (fn: connect.HandleFunction): connect.Server;
        (route: string, fn: connect.NextHandleFunction): connect.Server;
        (route: string, fn: connect.HandleFunction): connect.Server;
    };
    constructor(base: string, port: number);
    findPort(): Promise<this>;
    listen(fn?: Function): void;
    log(): void;
    staticServer(port: number, base: string): connect.NextHandleFunction;
}

export declare class UlkaTemplate extends Template {
    static ulka: typeof ulka;
    compile(): Promise<(ctx?: object) => Promise<string>>;
    static reset(): void;
    get hasMatter(): boolean;
    get buildExt(): string;
}

export declare interface ValidContentConfig {
    forEach: (temp: Template, index: number, temps: Template[]) => any;
    sort: (a: Template, b: Template) => any;
    match: string | string[];
    ignore: string[];
    layout: ((temp: Template) => string) | string | null;
    link: ((temp: Template) => string) | string | null;
}

export declare function watch(ulka: Ulka, verbose?: boolean, customFn?: Function): Promise<FSWatcher>;

export { }