ShellArg = object
  cmd*: string               ## Shell command argument string
  kind*: ShellArgKind

ShellArgKind = enum
  cpkArgument,              ## String argument to command
  cpkTemplated               ## Interpolated parameter

ShellCmd = object
  bin*: string               ## Binary name or absolute path
  opts*: seq[ShellArg]       ## Arguments
  

ShellResult = object
  cmd*: ShellCmd
  cwd*: string               ## Absolute path of initial command execution directory
  retcode*: int              ## Exit code
  stderr*: string            ## Stderr for command
  stdout*: string            ## Stdout for command
  

ShInterpolate = Table[string, seq[ShellArg]]

func add(cmd: var ShellCmd; arg: ShellArg) {....raises: [], tags: [].}

func add(cmd: var ShellCmd; args: openArray[ShellArg]) {....raises: [], tags: [].}

func arg(cmd: var ShellCmd; format: string; args: varargs[string]) {.
    ...raises: [ValueError], tags: [].}

func args(cmd: var ShellCmd; args: openArray[ShellArg]) {....raises: [], tags: [].}

func args(cmd: var ShellCmd; args: openArray[string]) {....raises: [], tags: [].}

func argsToStr(cmd: ShellCmd): seq[string] {....raises: [], tags: [].}

proc exec(cmd: ShellCmd; dir: string = ""; stdin: string = "";
          options: set[ProcessOption] = {poUsePath};
          maxOutSize: int = 40960 * 1024): ShellResult {.
    ...raises: [OSError, Exception, IOError], tags: [ExecIOEffect, ReadEnvEffect,
    RootEffect, WriteIOEffect, ReadIOEffect].}

proc exec(cmds: openArray[ShellCmd]; options: set[ProcessOption] = {poUsePath};
          maxParallel: int = countProcessors(); dir: string = "";
          beforeRunEvent: proc (idx: int) = nil;
          afterRunEvent: proc (idx: int; p: Process) = nil): seq[ShellResult] {.
    ...raises: [OSError, Exception, IOError], tags: [ExecIOEffect, ReadEnvEffect,
    RootEffect, ReadIOEffect, WriteIOEffect].}

func interpolate(cmd: ShellCmd; map: openArray[(string, seq[string])]): ShellCmd {.
    ...raises: [KeyError], tags: [].}

func interpolate(cmd: ShellCmd; map: ShInterpolate): ShellCmd {.
    ...raises: [KeyError], tags: [].}

func interpolate(part: ShellArg; map: ShInterpolate): seq[ShellArg] {.
    ...raises: [KeyError], tags: [].}

func shArg(arg: string): ShellArg {....raises: [], tags: [].}

func shell(bin: string; args: openArray[ShellArg]): ShellCmd {....raises: [],
    tags: [].}

func shell(bin: string; args: openArray[string] = @[]): ShellCmd {....raises: [],
    tags: [].}

func shSub(arg: string): ShellArg {....raises: [], tags: [].}

func shSub(cmd: var ShellCmd; subs: openArray[string]) {....raises: [], tags: [].}

proc start(cmd: ShellCmd; dir: string = "";
           options: set[ProcessOption] = {poUsePath}): Process {.
    ...raises: [OSError, Exception],
    tags: [ExecIOEffect, ReadEnvEffect, RootEffect].}

func toStr(cmd: ShellCmd): seq[string] {....raises: [], tags: [].}

func toStr(part: ShellArg): string {....raises: [], tags: [].}