import type * as typings from './typings';
export type DefinitionSubTree = {
    description: string;
    subcommands: DefinitionTree;
};
export type DefinitionTree = {
    [key: string]: DefinitionTreeNode;
};
export type DefinitionTreeNode = typings.CommandDefinition | DefinitionSubTree;
export type ImplementationSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {
    subcommands: ImplementationTree<D['subcommands']>;
};
export type ImplementationTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> = N extends typings.CommandDefinition ? typings.CommandImplementation<N> : N extends DefinitionSubTree ? ImplementationSubTree<N> : never;
export type ImplementationTree<D extends DefinitionTree = DefinitionTree> = {
    [K in keyof D]: ImplementationTreeNode<D[K]>;
};
export type CommandSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {
    description: string;
    subcommands: CommandTree<D['subcommands']>;
};
export type CommandTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> = N extends typings.CommandDefinition ? typings.CommandLeaf<N> : N extends DefinitionSubTree ? CommandSubTree<N> : never;
export type CommandTree<D extends DefinitionTree = DefinitionTree> = {
    [K in keyof D]: CommandTreeNode<D[K]>;
};
export declare const guards: {
    definition: {
        isDef: (x: DefinitionTreeNode) => x is typings.CommandDefinition;
        isSubTree: (x: DefinitionTreeNode) => x is DefinitionSubTree;
    };
    implementation: {
        isImpl: (x: ImplementationTreeNode) => x is typings.CommandImplementation;
        isSubTree: (x: ImplementationTreeNode) => x is ImplementationSubTree;
    };
    command: {
        isLeaf: (x: CommandTreeNode) => x is typings.CommandLeaf;
        isSubTree: (x: CommandTreeNode) => x is CommandSubTree;
    };
};
export declare const zipTree: <T extends DefinitionTree>(defTree: T, implTree: ImplementationTree<T>) => CommandTree<T>;
