ERR: int = to(getAttr(pyImport("curses"), "ERR"), int)

OK: int = to(getAttr(pyImport("curses"), "OK"), int)

version: int = to(getAttr(pyImport("curses"), "version"), int)

A_ALTCHARSET: int = to(getAttr(pyImport("curses"), "A_ALTCHARSET"), int)

A_BLINK: int = to(getAttr(pyImport("curses"), "A_BLINK"), int)

A_BOLD: int = to(getAttr(pyImport("curses"), "A_BOLD"), int)

A_DIM: int = to(getAttr(pyImport("curses"), "A_DIM"), int)

A_INVIS: int = to(getAttr(pyImport("curses"), "A_INVIS"), int)

A_ITALIC: int = to(getAttr(pyImport("curses"), "A_ITALIC"), int)

A_NORMAL: int = to(getAttr(pyImport("curses"), "A_NORMAL"), int)

A_PROTECT: int = to(getAttr(pyImport("curses"), "A_PROTECT"), int)

A_REVERSE: int = to(getAttr(pyImport("curses"), "A_REVERSE"), int)

A_STANDOUT: int = to(getAttr(pyImport("curses"), "A_STANDOUT"), int)

A_UNDERLINE: int = to(getAttr(pyImport("curses"), "A_UNDERLINE"), int)

A_HORIZONTAL: int = to(getAttr(pyImport("curses"), "A_HORIZONTAL"), int)

A_LEFT: int = to(getAttr(pyImport("curses"), "A_LEFT"), int)

A_LOW: int = to(getAttr(pyImport("curses"), "A_LOW"), int)

A_RIGHT: int = to(getAttr(pyImport("curses"), "A_RIGHT"), int)

A_TOP: int = to(getAttr(pyImport("curses"), "A_TOP"), int)

A_VERTICAL: int = to(getAttr(pyImport("curses"), "A_VERTICAL"), int)

A_CHARTEXT: int = to(getAttr(pyImport("curses"), "A_CHARTEXT"), int)

A_ATTRIBUTES: int = to(getAttr(pyImport("curses"), "A_ATTRIBUTES"), int)

A_COLOR: int = to(getAttr(pyImport("curses"), "A_COLOR"), int)

KEY_MIN: int = to(getAttr(pyImport("curses"), "KEY_MIN"), int)

KEY_BREAK: int = to(getAttr(pyImport("curses"), "KEY_BREAK"), int)

KEY_DOWN: int = to(getAttr(pyImport("curses"), "KEY_DOWN"), int)

KEY_UP: int = to(getAttr(pyImport("curses"), "KEY_UP"), int)

KEY_LEFT: int = to(getAttr(pyImport("curses"), "KEY_LEFT"), int)

KEY_RIGHT: int = to(getAttr(pyImport("curses"), "KEY_RIGHT"), int)

KEY_HOME: int = to(getAttr(pyImport("curses"), "KEY_HOME"), int)

KEY_BACKSPACE: int = to(getAttr(pyImport("curses"), "KEY_BACKSPACE"), int)

KEY_F0: int = to(getAttr(pyImport("curses"), "KEY_F0"), int)

KEY_Fn: int = to(getAttr(pyImport("curses"), "KEY_Fn"), int)

KEY_DL: int = to(getAttr(pyImport("curses"), "KEY_DL"), int)

KEY_IL: int = to(getAttr(pyImport("curses"), "KEY_IL"), int)

KEY_DC: int = to(getAttr(pyImport("curses"), "KEY_DC"), int)

KEY_IC: int = to(getAttr(pyImport("curses"), "KEY_IC"), int)

KEY_EIC: int = to(getAttr(pyImport("curses"), "KEY_EIC"), int)

KEY_CLEAR: int = to(getAttr(pyImport("curses"), "KEY_CLEAR"), int)

KEY_EOS: int = to(getAttr(pyImport("curses"), "KEY_EOS"), int)

KEY_EOL: int = to(getAttr(pyImport("curses"), "KEY_EOL"), int)

KEY_SF: int = to(getAttr(pyImport("curses"), "KEY_SF"), int)

KEY_SR: int = to(getAttr(pyImport("curses"), "KEY_SR"), int)

KEY_NPAGE: int = to(getAttr(pyImport("curses"), "KEY_NPAGE"), int)

KEY_PPAGE: int = to(getAttr(pyImport("curses"), "KEY_PPAGE"), int)

KEY_STAB: int = to(getAttr(pyImport("curses"), "KEY_STAB"), int)

KEY_CTAB: int = to(getAttr(pyImport("curses"), "KEY_CTAB"), int)

KEY_CATAB: int = to(getAttr(pyImport("curses"), "KEY_CATAB"), int)

KEY_ENTER: int = to(getAttr(pyImport("curses"), "KEY_ENTER"), int)

KEY_SRESET: int = to(getAttr(pyImport("curses"), "KEY_SRESET"), int)

KEY_RESET: int = to(getAttr(pyImport("curses"), "KEY_RESET"), int)

KEY_PRINT: int = to(getAttr(pyImport("curses"), "KEY_PRINT"), int)

KEY_LL: int = to(getAttr(pyImport("curses"), "KEY_LL"), int)

KEY_A1: int = to(getAttr(pyImport("curses"), "KEY_A1"), int)

KEY_A3: int = to(getAttr(pyImport("curses"), "KEY_A3"), int)

KEY_B2: int = to(getAttr(pyImport("curses"), "KEY_B2"), int)

KEY_C1: int = to(getAttr(pyImport("curses"), "KEY_C1"), int)

KEY_C3: int = to(getAttr(pyImport("curses"), "KEY_C3"), int)

KEY_BTAB: int = to(getAttr(pyImport("curses"), "KEY_BTAB"), int)

KEY_BEG: int = to(getAttr(pyImport("curses"), "KEY_BEG"), int)

KEY_CANCEL: int = to(getAttr(pyImport("curses"), "KEY_CANCEL"), int)

KEY_CLOSE: int = to(getAttr(pyImport("curses"), "KEY_CLOSE"), int)

KEY_COMMAND: int = to(getAttr(pyImport("curses"), "KEY_COMMAND"), int)

KEY_COPY: int = to(getAttr(pyImport("curses"), "KEY_COPY"), int)

KEY_CREATE: int = to(getAttr(pyImport("curses"), "KEY_CREATE"), int)

KEY_END: int = to(getAttr(pyImport("curses"), "KEY_END"), int)

KEY_EXIT: int = to(getAttr(pyImport("curses"), "KEY_EXIT"), int)

KEY_FIND: int = to(getAttr(pyImport("curses"), "KEY_FIND"), int)

KEY_HELP: int = to(getAttr(pyImport("curses"), "KEY_HELP"), int)

KEY_MARK: int = to(getAttr(pyImport("curses"), "KEY_MARK"), int)

KEY_MESSAGE: int = to(getAttr(pyImport("curses"), "KEY_MESSAGE"), int)

KEY_MOVE: int = to(getAttr(pyImport("curses"), "KEY_MOVE"), int)

KEY_NEXT: int = to(getAttr(pyImport("curses"), "KEY_NEXT"), int)

KEY_OPEN: int = to(getAttr(pyImport("curses"), "KEY_OPEN"), int)

KEY_OPTIONS: int = to(getAttr(pyImport("curses"), "KEY_OPTIONS"), int)

KEY_PREVIOUS: int = to(getAttr(pyImport("curses"), "KEY_PREVIOUS"), int)

KEY_REDO: int = to(getAttr(pyImport("curses"), "KEY_REDO"), int)

KEY_REFERENCE: int = to(getAttr(pyImport("curses"), "KEY_REFERENCE"), int)

KEY_REFRESH: int = to(getAttr(pyImport("curses"), "KEY_REFRESH"), int)

KEY_REPLACE: int = to(getAttr(pyImport("curses"), "KEY_REPLACE"), int)

KEY_RESTART: int = to(getAttr(pyImport("curses"), "KEY_RESTART"), int)

KEY_RESUME: int = to(getAttr(pyImport("curses"), "KEY_RESUME"), int)

KEY_SAVE: int = to(getAttr(pyImport("curses"), "KEY_SAVE"), int)

KEY_SBEG: int = to(getAttr(pyImport("curses"), "KEY_SBEG"), int)

KEY_SCANCEL: int = to(getAttr(pyImport("curses"), "KEY_SCANCEL"), int)

KEY_SCOMMAND: int = to(getAttr(pyImport("curses"), "KEY_SCOMMAND"), int)

KEY_SCOPY: int = to(getAttr(pyImport("curses"), "KEY_SCOPY"), int)

KEY_SCREATE: int = to(getAttr(pyImport("curses"), "KEY_SCREATE"), int)

KEY_SDC: int = to(getAttr(pyImport("curses"), "KEY_SDC"), int)

KEY_SDL: int = to(getAttr(pyImport("curses"), "KEY_SDL"), int)

KEY_SELECT: int = to(getAttr(pyImport("curses"), "KEY_SELECT"), int)

KEY_SEND: int = to(getAttr(pyImport("curses"), "KEY_SEND"), int)

KEY_SEOL: int = to(getAttr(pyImport("curses"), "KEY_SEOL"), int)

KEY_SEXIT: int = to(getAttr(pyImport("curses"), "KEY_SEXIT"), int)

KEY_SFIND: int = to(getAttr(pyImport("curses"), "KEY_SFIND"), int)

KEY_SHELP: int = to(getAttr(pyImport("curses"), "KEY_SHELP"), int)

KEY_SHOME: int = to(getAttr(pyImport("curses"), "KEY_SHOME"), int)

KEY_SIC: int = to(getAttr(pyImport("curses"), "KEY_SIC"), int)

KEY_SLEFT: int = to(getAttr(pyImport("curses"), "KEY_SLEFT"), int)

KEY_SMESSAGE: int = to(getAttr(pyImport("curses"), "KEY_SMESSAGE"), int)

KEY_SMOVE: int = to(getAttr(pyImport("curses"), "KEY_SMOVE"), int)

KEY_SNEXT: int = to(getAttr(pyImport("curses"), "KEY_SNEXT"), int)

KEY_SOPTIONS: int = to(getAttr(pyImport("curses"), "KEY_SOPTIONS"), int)

KEY_SPREVIOUS: int = to(getAttr(pyImport("curses"), "KEY_SPREVIOUS"), int)

KEY_SPRINT: int = to(getAttr(pyImport("curses"), "KEY_SPRINT"), int)

KEY_SREDO: int = to(getAttr(pyImport("curses"), "KEY_SREDO"), int)

KEY_SREPLACE: int = to(getAttr(pyImport("curses"), "KEY_SREPLACE"), int)

KEY_SRIGHT: int = to(getAttr(pyImport("curses"), "KEY_SRIGHT"), int)

KEY_SRSUME: int = to(getAttr(pyImport("curses"), "KEY_SRSUME"), int)

KEY_SSAVE: int = to(getAttr(pyImport("curses"), "KEY_SSAVE"), int)

KEY_SSUSPEND: int = to(getAttr(pyImport("curses"), "KEY_SSUSPEND"), int)

KEY_SUNDO: int = to(getAttr(pyImport("curses"), "KEY_SUNDO"), int)

KEY_SUSPEND: int = to(getAttr(pyImport("curses"), "KEY_SUSPEND"), int)

KEY_UNDO: int = to(getAttr(pyImport("curses"), "KEY_UNDO"), int)

KEY_MOUSE: int = to(getAttr(pyImport("curses"), "KEY_MOUSE"), int)

KEY_RESIZE: int = to(getAttr(pyImport("curses"), "KEY_RESIZE"), int)

KEY_MAX: int = to(getAttr(pyImport("curses"), "KEY_MAX"), int)

COLOR_BLACK: int = to(getAttr(pyImport("curses"), "COLOR_BLACK"), int)

COLOR_BLUE: int = to(getAttr(pyImport("curses"), "COLOR_BLUE"), int)

COLOR_CYAN: int = to(getAttr(pyImport("curses"), "COLOR_CYAN"), int)

COLOR_GREEN: int = to(getAttr(pyImport("curses"), "COLOR_GREEN"), int)

COLOR_MAGENTA: int = to(getAttr(pyImport("curses"), "COLOR_MAGENTA"), int)

COLOR_RED: int = to(getAttr(pyImport("curses"), "COLOR_RED"), int)

COLOR_WHITE: int = to(getAttr(pyImport("curses"), "COLOR_WHITE"), int)

COLOR_YELLOW: int = to(getAttr(pyImport("curses"), "COLOR_YELLOW"), int)

ncurses_version: tuple[major, minor, patch: int] = to(
    getAttr(pyImport("curses"), "ncurses_version"),
    tuple[major, minor, patch: int])

proc isalnum(c: string or char): bool

proc isalpha(c: string or char): bool

proc isascii(c: string or char): bool

proc isblank(c: string or char): bool

proc iscntrl(c: string or char): bool

proc isdigit(c: string or char): bool

proc isgraph(c: string or char): bool

proc islower(c: string or char): bool

proc isprint(c: string or char): bool

proc ispunct(c: string or char): bool

proc isspace(c: string or char): bool

proc isupper(c: string or char): bool

proc isZdigit(c: string or char): bool

proc isctrl(c: string or char): bool

proc ismeta(c: string or char): bool

proc ascii(c: char or int): string

proc ctrl(c: char or int): string

proc alt(c: char or int): string

proc unctrl(c: char or int): string

proc baudrate() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                           KeyError], tags: [RootEffect].}

proc beep() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                       KeyError], tags: [RootEffect].}

proc can_change_color(): bool {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc cbreak() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                         KeyError], tags: [RootEffect].}

proc def_prog_mode() {....raises: [Exception, ValueError, OSError, IOError,
                                EOFError, KeyError], tags: [RootEffect].}

proc def_shell_mode() {....raises: [Exception, ValueError, OSError, IOError,
                                 EOFError, KeyError], tags: [RootEffect].}

proc delay_output(ms: int) {....raises: [Exception, ValueError, OSError, IOError,
                                      EOFError, KeyError], tags: [RootEffect].}

proc doupdate() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                           KeyError], tags: [RootEffect].}

proc endwin() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                         KeyError], tags: [RootEffect].}

proc erasechar(): string {....raises: [Exception, ValueError, OSError, IOError,
                                    EOFError, KeyError], tags: [RootEffect].}

proc filter() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                         KeyError], tags: [RootEffect].}

proc flash() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                        KeyError], tags: [RootEffect].}

proc flushinp() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                           KeyError], tags: [RootEffect].}

proc has_ic(): bool {....raises: [Exception, ValueError, OSError, IOError,
                               EOFError, KeyError], tags: [RootEffect].}

proc has_il(): bool {....raises: [Exception, ValueError, OSError, IOError,
                               EOFError, KeyError], tags: [RootEffect].}

proc has_key(ch: string or char): bool

proc has_colors(): bool {....raises: [Exception, ValueError, OSError, IOError,
                                   EOFError, KeyError], tags: [RootEffect].}

proc isendwin() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                           KeyError], tags: [RootEffect].}

proc keyname(k: int) {....raises: [Exception, ValueError, OSError, IOError,
                                EOFError, KeyError], tags: [RootEffect].}

proc killchar(): string {....raises: [Exception, ValueError, OSError, IOError,
                                   EOFError, KeyError], tags: [RootEffect].}

proc longname(): string {....raises: [Exception, ValueError, OSError, IOError,
                                   EOFError, KeyError], tags: [RootEffect].}

proc meta(flag: bool) {....raises: [Exception, ValueError, OSError, IOError,
                                 EOFError, KeyError], tags: [RootEffect].}

proc getsyx(): tuple[y, x: int] {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc napms(ms: int) {....raises: [Exception, ValueError, OSError, IOError,
                               EOFError, KeyError], tags: [RootEffect].}

proc nl() {....raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
            tags: [RootEffect].}

proc nocbreak() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                           KeyError], tags: [RootEffect].}

proc noecho() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                         KeyError], tags: [RootEffect].}

proc nonl() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                       KeyError], tags: [RootEffect].}

proc noqiflush() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                            KeyError], tags: [RootEffect].}

proc noraw() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                        KeyError], tags: [RootEffect].}

proc mouseinterval(interval: int): int {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc putp(str: string) {....raises: [Exception, ValueError, OSError, IOError,
                                  EOFError, KeyError], tags: [RootEffect].}

proc qiflush(flag: bool) {....raises: [Exception, ValueError, OSError, IOError,
                                    EOFError, KeyError], tags: [RootEffect].}

proc qiflush() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                          KeyError], tags: [RootEffect].}

proc raw() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                      KeyError], tags: [RootEffect].}

proc reset_prog_mode() {....raises: [Exception, ValueError, OSError, IOError,
                                  EOFError, KeyError], tags: [RootEffect].}

proc reset_shell_mode() {....raises: [Exception, ValueError, OSError, IOError,
                                   EOFError, KeyError], tags: [RootEffect].}

proc resetty() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                          KeyError], tags: [RootEffect].}

proc halfdelay(tenths: range[1 .. 255]) {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc savetty() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                          KeyError], tags: [RootEffect].}

proc get_escdelay(): int {....raises: [Exception, ValueError, OSError, IOError,
                                    EOFError, KeyError], tags: [RootEffect].}

proc resize_term(nlines, ncols: int) {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc set_escdelay(ms: int) {....raises: [Exception, ValueError, OSError, IOError,
                                      EOFError, KeyError], tags: [RootEffect].}

proc get_tabsize(): int {....raises: [Exception, ValueError, OSError, IOError,
                                   EOFError, KeyError], tags: [RootEffect].}

proc set_tabsize(size: int): int {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc setsyx(y, x: int): int {....raises: [Exception, ValueError, OSError, IOError,
                                       EOFError, KeyError], tags: [RootEffect].}

proc setupterm(term: string; fd = -1) {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc start_color() {....raises: [Exception, ValueError, OSError, IOError, EOFError,
                              KeyError], tags: [RootEffect].}

proc termattrs(): int {....raises: [Exception, ValueError, OSError, IOError,
                                 EOFError, KeyError], tags: [RootEffect].}

proc termname(): string {....raises: [Exception, ValueError, OSError, IOError,
                                   EOFError, KeyError], tags: [RootEffect].}

proc tigetflag(capname: int): int {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc tigetnum(capname: int): int {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc tigetstr(capname: string): int {....raises: [Exception, ValueError, OSError,
    IOError, EOFError, KeyError], tags: [RootEffect].}

proc typeahead(fd: int) {....raises: [Exception, ValueError, OSError, IOError,
                                   EOFError, KeyError], tags: [RootEffect].}

proc update_lines_cols() {....raises: [Exception, ValueError, OSError, IOError,
                                    EOFError, KeyError], tags: [RootEffect].}

proc unget_wch(ch: char or string)

proc use_env(flag: bool) {....raises: [Exception, ValueError, OSError, IOError,
                                    EOFError, KeyError], tags: [RootEffect].}

proc use_default_colors() {....raises: [Exception, ValueError, OSError, IOError,
                                     EOFError, KeyError], tags: [RootEffect].}

proc unctrl(ch: char or string): string

proc ungetch(ch: char or string): string

proc color_content(color_number: int): tuple[red, green, blue: int] {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc color_pair(pair_number: int): string {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc getmouse(): tuple[id, x, y, z, bstate: int] {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc has_extended_color_support(): bool {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc init_color(color_number, r, g, b: range[0 .. 1000]) {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc is_term_resized(nlines, ncols: int) {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}

proc pair_content(pair_number: int): tuple[fg, bg: int] {.
    ...raises: [Exception, ValueError, OSError, IOError, EOFError, KeyError],
    tags: [RootEffect].}