proc `$`(self: Handlers): string {....raises: [KeyError], tags: [], forbids: [].}

proc `$`(self: Sigmasks): string {....raises: [KeyError], tags: [], forbids: [].}

proc `$`(self: Signals): string {....raises: [KeyError], tags: [], forbids: [].}

proc `==`(self: Handlers; other: Handlers): bool {....raises: [], tags: [],
    forbids: [].}

proc `==`(self: Sigmasks; other: Sigmasks): bool {....raises: [], tags: [],
    forbids: [].}

proc `==`(self: Signals; other: Signals): bool {....raises: [], tags: [],
    forbids: [].}

proc `[]`(cls: cls:type; name: string): Handlers

proc `[]`(cls: cls:type; name: string): Sigmasks

proc `[]`(cls: cls:type; name: string): Signals

proc add_alias(self: Handlers; name: string) {....raises: [KeyError, NameError],
    tags: [], forbids: [].}

proc add_alias(self: Sigmasks; name: string) {....raises: [KeyError, NameError],
    tags: [], forbids: [].}

proc add_alias(self: Signals; name: string) {....raises: [KeyError, NameError],
    tags: [], forbids: [].}

proc add_member(enum_class: typedesc[Handlers]; name: string; value: int): Handlers

proc add_member(enum_class: typedesc[Sigmasks]; name: string; value: int): Sigmasks

proc add_member(enum_class: typedesc[Signals]; name: string; value: int): Signals

proc contains(cls: cls:type; value: int): bool

proc contains(cls: cls:type; value: int): bool

proc contains(cls: cls:type; value: int): bool

proc Handlers(value: Handlers): Handlers {....raises: [], tags: [], forbids: [].}

proc Handlers(value: int): Handlers {....raises: [KeyError, ValueError], tags: [],
                                      forbids: [].}

proc hash(self: Handlers): Hash {....raises: [KeyError], tags: [], forbids: [].}

proc hash(self: Sigmasks): Hash {....raises: [KeyError], tags: [], forbids: [].}

proc hash(self: Signals): Hash {....raises: [KeyError], tags: [], forbids: [].}

proc len(cls: cls:type): int

proc len(cls: cls:type): int

proc len(cls: cls:type): int

proc name(self: Handlers): string {.inline, ...raises: [KeyError], tags: [],
                                    forbids: [].}

proc name(self: Sigmasks): string {.inline, ...raises: [KeyError], tags: [],
                                    forbids: [].}

proc name(self: Signals): string {.inline, ...raises: [KeyError], tags: [],
                                   forbids: [].}

proc repr(self: Handlers): string {....raises: [KeyError], tags: [], forbids: [].}

proc repr(self: Sigmasks): string {....raises: [KeyError], tags: [], forbids: [].}

proc repr(self: Signals): string {....raises: [KeyError], tags: [], forbids: [].}

proc Sigmasks(value: int): Sigmasks {....raises: [KeyError, ValueError], tags: [],
                                      forbids: [].}

proc Sigmasks(value: Sigmasks): Sigmasks {....raises: [], tags: [], forbids: [].}

proc Signals(value: int): Signals {....raises: [KeyError, ValueError], tags: [],
                                    forbids: [].}

proc Signals(value: Signals): Signals {....raises: [], tags: [], forbids: [].}

proc value(self: Handlers): int {.inline, ...raises: [], tags: [], forbids: [].}

proc value(self: Sigmasks): int {.inline, ...raises: [], tags: [], forbids: [].}

proc value(self: Signals): int {.inline, ...raises: [], tags: [], forbids: [].}

iterator items(cls: cls:type): Handlers

iterator items(cls: cls:type): Sigmasks

iterator items(cls: cls:type): Signals

converter toInt(self: Handlers): int {....raises: [], tags: [], forbids: [].}

converter toInt(self: Sigmasks): int {....raises: [], tags: [], forbids: [].}

converter toInt(self: Signals): int {....raises: [], tags: [], forbids: [].}

template contains(cls; value: Handlers): bool

template contains(cls; value: Sigmasks): bool

template contains(cls; value: Signals): bool