kui-shell/packages/core/models/command.d.ts

This is the monorepo for Kui, the hybrid command-line/GUI electron-based Kubernetes tool

import REPL from './repl';
import { Entity } from './entity';
import { CodedError } from './errors';
import { ExecOptions } from './execOptions';
import { UsageModel } from '../core/usage-error';
import { Tab } from '../webapp/cli';
import { StreamableFactory } from './streamable';
export declare enum ExecType {
    TopLevel = 0,
    ClickHandler = 1,
    Nested = 2
}
export interface CommandOptions extends CapabilityRequirements {
    noArgs?: boolean;
    usage?: UsageModel;
    flags?: YargsParserFlags;
    hidden?: boolean;
    incognito?: 'popup'[];
    viewName?: string;
    width?: number;
    height?: number;
    clearREPLOnLoad?: boolean;
    placeholder?: string;
    isDirectory?: boolean;
    listen?: CommandListener;
    docs?: string;
    synonymFor?: Command;
    hide?: boolean;
    override?: CommandHandler;
    plugin?: string;
    okOptions?: string[];
    isIntention?: boolean;
    requiresFullyQualifiedRoute?: boolean;
}
export interface Event {
    tab?: Tab;
    command?: string;
    route?: string;
    plugin?: string;
    isIntention?: boolean;
    error?: string;
    options?: string[];
    execType?: ExecType;
    isDrilldown?: boolean;
}
export interface ParsedOptions {
    _?: string[];
    [key: string]: string | boolean | number | string[];
}
export interface CommandLine<Options = ParsedOptions> {
    command: string;
    argv: string[];
    argvNoOptions: string[];
    parsedOptions: Options;
}
export interface EvaluatorArgs<Options = ParsedOptions> extends CommandLine<Options> {
    tab: Tab;
    REPL: REPL;
    execOptions: ExecOptions;
    createOutputStream: StreamableFactory;
    block: HTMLElement | boolean;
    nextBlock: HTMLElement;
}
export declare type Response = Entity;
export declare type CommandHandler<T = Response, O = ParsedOptions> = (args: EvaluatorArgs<O>) => T | Promise<T>;
export declare type CommandOverrideHandler<T = Response, O = ParsedOptions> = (args: EvaluatorArgs<O>, underlyingHandler: CommandHandler<T, O>) => T | Promise<T>;
export interface Evaluator {
    eval: CommandHandler;
}
export interface CommandBase {
    route: string;
    plugin?: string;
    options?: CommandOptions;
}
declare type CommandKey = string;
interface CommandKeyMap {
    [key: string]: Command;
}
export interface Disambiguator {
    [key: string]: CommandBase[];
}
export interface Command extends CommandBase {
    $: CommandHandler;
    key: CommandKey;
    parent: Command;
    children?: CommandKeyMap;
    synonyms?: CommandKeyMap;
}
export declare type CommandTree = Command;
export interface CapabilityRequirements {
    needsUI?: boolean;
    inBrowserOk?: boolean;
    requiresLocal?: boolean;
    noAuthOk?: boolean | string[];
    fullscreen?: boolean;
}
export declare type OnSuccess = (args: {
    tab: Tab;
    type: ExecType;
    command: string;
    isDrilldown: boolean;
    parsedOptions: ParsedOptions;
}) => void;
export declare type OnError = (command: string, tab: Tab, type: ExecType, err: CodedError) => CodedError;
export interface CommandHandlerWithEvents extends Evaluator {
    subtree: Command;
    route: string;
    options: CommandOptions;
    success: OnSuccess;
    error: OnError;
}
export declare function isCommandHandlerWithEvents(evaluator: Evaluator): evaluator is CommandHandlerWithEvents;
export declare type CommandTreeResolution = boolean | CommandHandlerWithEvents | CodedError;
export interface YargsParserFlags {
    boolean?: string[];
    alias?: string[];
}
export declare type CatchAllOffer = (argv: string[]) => boolean;
export interface CatchAllHandler extends Command {
    prio: number;
    plugin: string;
    offer: CatchAllOffer;
    eval: CommandHandler;
}
declare type CommandListener = (route: string, handler: CommandHandler, options?: CommandOptions) => Command;
export interface CommandRegistrar {
    find: (route: string, fromPlugin?: string, noOverride?: boolean) => Promise<Command>;
    listen: CommandListener;
    override: (route: string, fromPlugin: string, handler: CommandOverrideHandler, options?: CommandOptions) => Promise<Command>;
    synonym: (route: string, handler: CommandHandler, master: Command, options?: CommandOptions) => void;
    subtree: (route: string, options: CommandOptions) => Command;
    subtreeSynonym: (route: string, masterTree: Command, options?: CommandOptions) => void;
    catchall: (offer: CatchAllOffer, handler: CommandHandler, prio: number, options: CommandOptions) => void;
}
export {};