import { IApplication } from './application';
import { IConfiguration } from './configuration';
import { IExecutor } from './executor';
import { Git, GitCommit } from './git';
import { LogReporter } from './log-reporter';
import { PackedPackage } from './pack-artifact';
import { Prefix } from './type-utils';
import { GitSemverTag } from './version-utils';
import { IProject, IWorkspace } from './workspace-utils';
export interface IGitPlatform {
    currentBranch(): Promise<string | null>;
    currentRef(): Promise<string | null>;
    stripMergeMessage(commit: GitCommit): GitCommit;
}
export interface IPackManager {
    ident: string;
    pack(workspace: IWorkspace, outputFolder: string): Promise<string | string[] | Record<string, string> | null>;
    publish(packedPackage: PackedPackage, fileName: string, releaseTag: string, dryRun: boolean, module?: string): Promise<void>;
}
export interface IPluginChangelogFunctions {
    renderCompareUrl?(from: GitSemverTag, to: GitSemverTag): string;
    renderCommitUrl?(commitHash: string): string;
    renderIssueUrl?(issueId: string): string;
}
type Func = (...p: any) => any;
type FuncMap = Record<string, Func>;
export type OptionalProps<Type extends FuncMap> = {
    [Property in keyof Type]: (...a: Parameters<Type[Property]>) => ReturnType<Type[Property]> | undefined;
};
export type IChangelogRenderFunctions = OptionalProps<Required<IPluginChangelogFunctions>>;
export interface IPluginHooks {
    onBump?(application: IApplication, workspace: IWorkspace, version: string): Promise<void> | void;
    onPublish?(application: IApplication, packedPackage: PackedPackage[]): Promise<void> | void;
}
export type DispatchablePluginHooks = Required<Prefix<IPluginHooks, 'dispatch'>>;
export interface IPlugin extends IPluginChangelogFunctions, IPluginHooks {
    name: string;
    gitPlatform?: IGitPlatform;
    project?: IProject;
    packManager?: IPackManager;
}
export interface IPluginInitialize extends IConfiguration {
    git: Git;
    executor: IExecutor;
    logger: LogReporter;
}
export interface IIntializablePlugin {
    /**
     * Initialize the plugin for the current configuration
     * @param configuration The configuration ref
     * @returns A boolean indicating of the plugin is valid for the current configuration
     */
    initialize(configuration: IPluginInitialize): Promise<IPlugin | null> | IPlugin | null;
}
export type NonInitializedPlugin = IPlugin | IIntializablePlugin;
export declare function isInitializable(p: NonInitializedPlugin): p is IIntializablePlugin;
export declare class PluginManager implements IChangelogRenderFunctions, DispatchablePluginHooks {
    project?: IProject;
    packManagers: IPackManager[];
    private _gitPlatform?;
    plugins: NonInitializedPlugin[];
    availablePlugins: IPlugin[];
    get gitPlatform(): IGitPlatform;
    constructor();
    renderCompareUrl(from: GitSemverTag, to: GitSemverTag): string | undefined;
    renderCommitUrl(commitHash: string): string | undefined;
    renderIssueUrl(issueId: string): string | undefined;
    initialize(configuration: IPluginInitialize): Promise<void>;
    register(plugin: NonInitializedPlugin): void;
    render<K extends keyof IPluginChangelogFunctions>(f: K, ...params: Parameters<Required<IPluginChangelogFunctions>[K]>): ReturnType<Required<IPluginChangelogFunctions>[K]> | undefined;
    dispatchHook<K extends keyof IPluginHooks>(f: K, ...params: Parameters<Required<IPluginHooks>[K]>): Promise<void>;
    dispatchOnBump(application: IApplication, workspace: IWorkspace, version: string): Promise<void>;
    dispatchOnPublish(application: IApplication, packedPackage: PackedPackage[]): Promise<void>;
}
export {};