import { KernelRef, KernelspecInfo, LocalKernelProps, RemoteKernelProps } from "@nteract/types";
import { Action, ErrorAction, HasContent, HasKernel, MaybeHasContent, MaybeHasKernel } from "../utils";
export declare type RestartKernelOutputHandling = "None" | "Clear All" | "Run All";
export declare const INTERRUPT_KERNEL = "INTERRUPT_KERNEL";
export declare const INTERRUPT_KERNEL_SUCCESSFUL = "INTERRUPT_KERNEL_SUCCESSFUL";
export declare const INTERRUPT_KERNEL_FAILED = "INTERRUPT_KERNEL_FAILED";
export declare const KILL_KERNEL = "KILL_KERNEL";
export declare const KILL_KERNEL_SUCCESSFUL = "KILL_KERNEL_SUCCESSFUL";
export declare const KILL_KERNEL_FAILED = "KILL_KERNEL_FAILED";
export declare const RESTART_KERNEL = "RESTART_KERNEL";
export declare const RESTART_KERNEL_SUCCESSFUL = "RESTART_KERNEL_SUCCESSFUL";
export declare const RESTART_KERNEL_FAILED = "RESTART_KERNEL_FAILED";
export declare const CHANGE_KERNEL_BY_NAME = "CHANGE_KERNEL_BY_NAME";
export declare const LAUNCH_KERNEL = "LAUNCH_KERNEL";
export declare const LAUNCH_KERNEL_BY_NAME = "LAUNCH_KERNEL_BY_NAME";
export declare const LAUNCH_KERNEL_SUCCESSFUL = "LAUNCH_KERNEL_SUCCESSFUL";
export declare const LAUNCH_KERNEL_FAILED = "LAUNCH_KERNEL_FAILED";
export declare const SHUTDOWN_REPLY_SUCCEEDED = "SHUTDOWN_REPLY_SUCCEEDED";
export declare const SHUTDOWN_REPLY_TIMED_OUT = "SHUTDOWN_REPLY_TIMED_OUT";
export declare const DISPOSE_KERNEL = "DISPOSE_KERNEL";
export declare type InterruptKernel = Action<typeof INTERRUPT_KERNEL, MaybeHasContent & MaybeHasKernel>;
export declare type InterruptKernelSuccessful = Action<typeof INTERRUPT_KERNEL_SUCCESSFUL, MaybeHasContent & MaybeHasKernel>;
export declare type InterruptKernelFailed = ErrorAction<typeof INTERRUPT_KERNEL_FAILED, MaybeHasKernel>;
export declare type KillKernelAction = Action<typeof KILL_KERNEL, MaybeHasContent & MaybeHasKernel & {
    restarting: boolean;
    dispose?: boolean;
}>;
export declare type KillKernelSuccessful = Action<typeof KILL_KERNEL_SUCCESSFUL, MaybeHasKernel>;
export declare type KillKernelFailed = ErrorAction<typeof KILL_KERNEL_FAILED, MaybeHasKernel>;
export declare type RestartKernel = Action<typeof RESTART_KERNEL, HasContent & MaybeHasKernel & {
    outputHandling: RestartKernelOutputHandling;
}>;
export declare type RestartKernelSuccessful = Action<typeof RESTART_KERNEL_SUCCESSFUL, HasContent & HasKernel>;
export declare type RestartKernelFailed = ErrorAction<typeof RESTART_KERNEL_FAILED, HasContent & HasKernel>;
export declare type ChangeKernelByName = Action<typeof CHANGE_KERNEL_BY_NAME, HasContent & {
    kernelSpecName: string;
    oldKernelRef?: KernelRef | null;
}>;
export declare type LaunchKernelAction = Action<typeof LAUNCH_KERNEL, HasContent & HasKernel & {
    kernelSpec: KernelspecInfo;
    cwd: string;
    selectNextKernel: boolean;
}>;
export declare type LaunchKernelByNameAction = Action<typeof LAUNCH_KERNEL_BY_NAME, HasContent & HasKernel & {
    kernelSpecName?: string | null;
    cwd: string;
    selectNextKernel: boolean;
}>;
export declare type NewKernelAction = Action<typeof LAUNCH_KERNEL_SUCCESSFUL, HasContent & HasKernel & {
    kernel: LocalKernelProps | RemoteKernelProps;
    selectNextKernel: boolean;
}>;
export declare type LaunchKernelFailed = ErrorAction<typeof LAUNCH_KERNEL_FAILED, MaybeHasContent & MaybeHasKernel>;
export declare type ShutdownReplySucceeded = Action<typeof SHUTDOWN_REPLY_SUCCEEDED, HasKernel & {
    content: {
        restart: boolean;
    };
}>;
export declare type ShutdownReplyTimedOut = Action<typeof SHUTDOWN_REPLY_TIMED_OUT, HasKernel>;
export declare type DisposeKernel = Action<typeof DISPOSE_KERNEL, HasKernel>;
export declare const interruptKernel: {
    (payload: MaybeHasContent & MaybeHasKernel): {
        type: "INTERRUPT_KERNEL";
        payload: MaybeHasContent & MaybeHasKernel;
    };
    with<U extends Partial<MaybeHasContent & MaybeHasKernel>>(partial: U): (payload: Pick<MaybeHasContent & MaybeHasKernel, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U>>) => {
        type: "INTERRUPT_KERNEL";
        payload: MaybeHasContent & MaybeHasKernel;
    };
};
export declare const interruptKernelSuccessful: {
    (payload: MaybeHasContent & MaybeHasKernel): {
        type: "INTERRUPT_KERNEL_SUCCESSFUL";
        payload: MaybeHasContent & MaybeHasKernel;
    };
    with<U extends Partial<MaybeHasContent & MaybeHasKernel>>(partial: U): (payload: Pick<MaybeHasContent & MaybeHasKernel, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U>>) => {
        type: "INTERRUPT_KERNEL_SUCCESSFUL";
        payload: MaybeHasContent & MaybeHasKernel;
    };
};
export declare const interruptKernelFailed: (payload: MaybeHasKernel & {
    error: Error;
    code?: string | undefined;
}) => {
    type: "INTERRUPT_KERNEL_FAILED";
    payload: MaybeHasKernel & {
        error: Error;
        code?: string | undefined;
    };
    error: true;
};
export declare const killKernel: {
    (payload: MaybeHasContent & MaybeHasKernel & {
        restarting: boolean;
        dispose?: boolean | undefined;
    }): {
        type: "KILL_KERNEL";
        payload: MaybeHasContent & MaybeHasKernel & {
            restarting: boolean;
            dispose?: boolean | undefined;
        };
    };
    with<U extends Partial<MaybeHasContent & MaybeHasKernel & {
        restarting: boolean;
        dispose?: boolean | undefined;
    }>>(partial: U): (payload: Pick<MaybeHasContent & MaybeHasKernel & {
        restarting: boolean;
        dispose?: boolean | undefined;
    }, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U> | import("utility-types").SetDifference<"restarting", keyof U> | import("utility-types").SetDifference<"dispose", keyof U>>) => {
        type: "KILL_KERNEL";
        payload: MaybeHasContent & MaybeHasKernel & {
            restarting: boolean;
            dispose?: boolean | undefined;
        };
    };
};
export declare const killKernelSuccessful: {
    (payload: MaybeHasKernel): {
        type: "KILL_KERNEL_SUCCESSFUL";
        payload: MaybeHasKernel;
    };
    with<U extends Partial<MaybeHasKernel>>(partial: U): (payload: Pick<MaybeHasKernel, import("utility-types").SetDifference<"kernelRef", keyof U>>) => {
        type: "KILL_KERNEL_SUCCESSFUL";
        payload: MaybeHasKernel;
    };
};
export declare const killKernelFailed: (payload: MaybeHasKernel & {
    error: Error;
    code?: string | undefined;
}) => {
    type: "KILL_KERNEL_FAILED";
    payload: MaybeHasKernel & {
        error: Error;
        code?: string | undefined;
    };
    error: true;
};
export declare const restartKernel: {
    (payload: HasContent & MaybeHasKernel & {
        outputHandling: RestartKernelOutputHandling;
    }): {
        type: "RESTART_KERNEL";
        payload: HasContent & MaybeHasKernel & {
            outputHandling: RestartKernelOutputHandling;
        };
    };
    with<U extends Partial<HasContent & MaybeHasKernel & {
        outputHandling: RestartKernelOutputHandling;
    }>>(partial: U): (payload: Pick<HasContent & MaybeHasKernel & {
        outputHandling: RestartKernelOutputHandling;
    }, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U> | import("utility-types").SetDifference<"outputHandling", keyof U>>) => {
        type: "RESTART_KERNEL";
        payload: HasContent & MaybeHasKernel & {
            outputHandling: RestartKernelOutputHandling;
        };
    };
};
export declare const restartKernelSuccessful: {
    (payload: HasContent & HasKernel): {
        type: "RESTART_KERNEL_SUCCESSFUL";
        payload: HasContent & HasKernel;
    };
    with<U extends Partial<HasContent & HasKernel>>(partial: U): (payload: Pick<HasContent & HasKernel, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U>>) => {
        type: "RESTART_KERNEL_SUCCESSFUL";
        payload: HasContent & HasKernel;
    };
};
export declare const restartKernelFailed: (payload: HasContent & HasKernel & {
    error: Error;
    code?: string | undefined;
}) => {
    type: "RESTART_KERNEL_FAILED";
    payload: HasContent & HasKernel & {
        error: Error;
        code?: string | undefined;
    };
    error: true;
};
export declare const changeKernelByName: {
    (payload: HasContent & {
        kernelSpecName: string;
        oldKernelRef?: string | null | undefined;
    }): {
        type: "CHANGE_KERNEL_BY_NAME";
        payload: HasContent & {
            kernelSpecName: string;
            oldKernelRef?: string | null | undefined;
        };
    };
    with<U extends Partial<HasContent & {
        kernelSpecName: string;
        oldKernelRef?: string | null | undefined;
    }>>(partial: U): (payload: Pick<HasContent & {
        kernelSpecName: string;
        oldKernelRef?: string | null | undefined;
    }, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelSpecName", keyof U> | import("utility-types").SetDifference<"oldKernelRef", keyof U>>) => {
        type: "CHANGE_KERNEL_BY_NAME";
        payload: HasContent & {
            kernelSpecName: string;
            oldKernelRef?: string | null | undefined;
        };
    };
};
export declare const launchKernel: {
    (payload: HasContent & HasKernel & {
        kernelSpec: KernelspecInfo;
        cwd: string;
        selectNextKernel: boolean;
    }): {
        type: "LAUNCH_KERNEL";
        payload: HasContent & HasKernel & {
            kernelSpec: KernelspecInfo;
            cwd: string;
            selectNextKernel: boolean;
        };
    };
    with<U extends Partial<HasContent & HasKernel & {
        kernelSpec: KernelspecInfo;
        cwd: string;
        selectNextKernel: boolean;
    }>>(partial: U): (payload: Pick<HasContent & HasKernel & {
        kernelSpec: KernelspecInfo;
        cwd: string;
        selectNextKernel: boolean;
    }, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U> | import("utility-types").SetDifference<"kernelSpec", keyof U> | import("utility-types").SetDifference<"cwd", keyof U> | import("utility-types").SetDifference<"selectNextKernel", keyof U>>) => {
        type: "LAUNCH_KERNEL";
        payload: HasContent & HasKernel & {
            kernelSpec: KernelspecInfo;
            cwd: string;
            selectNextKernel: boolean;
        };
    };
};
export declare const launchKernelByName: {
    (payload: HasContent & HasKernel & {
        kernelSpecName?: string | null | undefined;
        cwd: string;
        selectNextKernel: boolean;
    }): {
        type: "LAUNCH_KERNEL_BY_NAME";
        payload: HasContent & HasKernel & {
            kernelSpecName?: string | null | undefined;
            cwd: string;
            selectNextKernel: boolean;
        };
    };
    with<U extends Partial<HasContent & HasKernel & {
        kernelSpecName?: string | null | undefined;
        cwd: string;
        selectNextKernel: boolean;
    }>>(partial: U): (payload: Pick<HasContent & HasKernel & {
        kernelSpecName?: string | null | undefined;
        cwd: string;
        selectNextKernel: boolean;
    }, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U> | import("utility-types").SetDifference<"kernelSpecName", keyof U> | import("utility-types").SetDifference<"cwd", keyof U> | import("utility-types").SetDifference<"selectNextKernel", keyof U>>) => {
        type: "LAUNCH_KERNEL_BY_NAME";
        payload: HasContent & HasKernel & {
            kernelSpecName?: string | null | undefined;
            cwd: string;
            selectNextKernel: boolean;
        };
    };
};
export declare const launchKernelSuccessful: {
    (payload: HasContent & HasKernel & {
        kernel: LocalKernelProps | RemoteKernelProps;
        selectNextKernel: boolean;
    }): {
        type: "LAUNCH_KERNEL_SUCCESSFUL";
        payload: HasContent & HasKernel & {
            kernel: LocalKernelProps | RemoteKernelProps;
            selectNextKernel: boolean;
        };
    };
    with<U extends Partial<HasContent & HasKernel & {
        kernel: LocalKernelProps | RemoteKernelProps;
        selectNextKernel: boolean;
    }>>(partial: U): (payload: Pick<HasContent & HasKernel & {
        kernel: LocalKernelProps | RemoteKernelProps;
        selectNextKernel: boolean;
    }, import("utility-types").SetDifference<"contentRef", keyof U> | import("utility-types").SetDifference<"kernelRef", keyof U> | import("utility-types").SetDifference<"selectNextKernel", keyof U> | import("utility-types").SetDifference<"kernel", keyof U>>) => {
        type: "LAUNCH_KERNEL_SUCCESSFUL";
        payload: HasContent & HasKernel & {
            kernel: LocalKernelProps | RemoteKernelProps;
            selectNextKernel: boolean;
        };
    };
};
export declare const launchKernelFailed: (payload: MaybeHasContent & MaybeHasKernel & {
    error: Error;
    code?: string | undefined;
}) => {
    type: "LAUNCH_KERNEL_FAILED";
    payload: MaybeHasContent & MaybeHasKernel & {
        error: Error;
        code?: string | undefined;
    };
    error: true;
};
export declare const shutdownReplySucceeded: {
    (payload: HasKernel & {
        content: {
            restart: boolean;
        };
    }): {
        type: "SHUTDOWN_REPLY_SUCCEEDED";
        payload: HasKernel & {
            content: {
                restart: boolean;
            };
        };
    };
    with<U extends Partial<HasKernel & {
        content: {
            restart: boolean;
        };
    }>>(partial: U): (payload: Pick<HasKernel & {
        content: {
            restart: boolean;
        };
    }, import("utility-types").SetDifference<"kernelRef", keyof U> | import("utility-types").SetDifference<"content", keyof U>>) => {
        type: "SHUTDOWN_REPLY_SUCCEEDED";
        payload: HasKernel & {
            content: {
                restart: boolean;
            };
        };
    };
};
export declare const shutdownReplyTimedOut: {
    (payload: HasKernel): {
        type: "SHUTDOWN_REPLY_TIMED_OUT";
        payload: HasKernel;
    };
    with<U extends Partial<HasKernel>>(partial: U): (payload: Pick<HasKernel, import("utility-types").SetDifference<"kernelRef", keyof U>>) => {
        type: "SHUTDOWN_REPLY_TIMED_OUT";
        payload: HasKernel;
    };
};
export declare const disposeKernel: {
    (payload: HasKernel): {
        type: "DISPOSE_KERNEL";
        payload: HasKernel;
    };
    with<U extends Partial<HasKernel>>(partial: U): (payload: Pick<HasKernel, import("utility-types").SetDifference<"kernelRef", keyof U>>) => {
        type: "DISPOSE_KERNEL";
        payload: HasKernel;
    };
};