proc XkbAddDeviceLedInfo(devi: PXkbDeviceInfoPtr; ledClass, ledId: int16): PXkbDeviceLedInfoPtr {.
    cdecl, dynlib: libX11, importc: "XkbAddDeviceLedInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbAddKeyType(xkb: PXkbDescPtr; name: Atom; map_count: int16;
                   want_preserve: bool; num_lvls: int16): PXkbKeyTypePtr {.
    cdecl, dynlib: libX11, importc: "XkbAddKeyType", ...raises: [], tags: [],
    forbids: [].}

proc XkbAddSymInterpret(xkb: PXkbDescPtr; si: PXkbSymInterpretPtr;
                        updateMap: bool; changes: PXkbChangesPtr): PXkbSymInterpretPtr {.
    cdecl, dynlib: libX11, importc: "XkbAddSymInterpret", ...raises: [], tags: [],
    forbids: [].}

proc XkbAllocClientMap(xkb: PXkbDescPtr; which, nTypes: int16): Status {.cdecl,
    dynlib: libX11, importc: "XkbAllocClientMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbAllocCompatMap(xkb: PXkbDescPtr; which, nInterpret: int16): Status {.
    cdecl, dynlib: libX11, importc: "XkbAllocCompatMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbAllocControls(xkb: PXkbDescPtr; which: int16): Status {.cdecl,
    dynlib: libX11, importc: "XkbAllocControls", ...raises: [], tags: [],
    forbids: [].}

proc XkbAllocDeviceInfo(deviceSpec, nButtons, szLeds: int16): PXkbDeviceInfoPtr {.
    cdecl, dynlib: libX11, importc: "XkbAllocDeviceInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbAllocIndicatorMaps(xkb: PXkbDescPtr): Status {.cdecl, dynlib: libX11,
    importc: "XkbAllocIndicatorMaps", ...raises: [], tags: [], forbids: [].}

proc XkbAllocKeyboard(): PXkbDescPtr {.cdecl, dynlib: libX11,
                                       importc: "XkbAllocKeyboard", ...raises: [],
                                       tags: [], forbids: [].}

proc XkbAllocNames(xkb: PXkbDescPtr; which: int16;
                   nTotalRG, nTotalAliases: int16): Status {.cdecl,
    dynlib: libX11, importc: "XkbAllocNames", ...raises: [], tags: [], forbids: [].}

proc XkbAllocServerMap(xkb: PXkbDescPtr; which, nActions: int16): Status {.
    cdecl, dynlib: libX11, importc: "XkbAllocServerMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbApplyCompatMapToKey(xkb: PXkbDescPtr; key: KeyCode;
                            changes: PXkbChangesPtr): bool {.cdecl,
    dynlib: libX11, importc: "XkbApplyCompatMapToKey", ...raises: [], tags: [],
    forbids: [].}

proc XkbApplyVirtualModChanges(xkb: PXkbDescPtr; changed: int16;
                               changes: PXkbChangesPtr): bool {.cdecl,
    dynlib: libX11, importc: "XkbApplyVirtualModChanges", ...raises: [], tags: [],
    forbids: [].}

proc XkbBell(dpy: PDisplay; win: Window; percent: int16; name: Atom): bool {.
    cdecl, dynlib: libX11, importc: "XkbBell", ...raises: [], tags: [], forbids: [].}

proc XkbBellEvent(dpy: PDisplay; win: Window; percent: int16; name: Atom): bool {.
    cdecl, dynlib: libX11, importc: "XkbBellEvent", ...raises: [], tags: [],
    forbids: [].}

proc XkbChangeControls(d: PDisplay; x: PXkbDescPtr; c: PXkbControlsChangesPtr): bool {.
    ...raises: [], tags: [], forbids: [].}

proc XkbChangeDeviceInfo(dpy: PDisplay; desc: PXkbDeviceInfoPtr;
                         changes: PXkbDeviceChangesPtr): bool {.cdecl,
    dynlib: libX11, importc: "XkbChangeDeviceInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbChangeEnabledControls(dpy: PDisplay; deviceSpec, affect, values: int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbChangeEnabledControls", ...raises: [],
    tags: [], forbids: [].}

proc XkbChangeIndicatorMaps(d: PDisplay; x: PXkbDescPtr;
                            c: PXkbIndicatorChangesPtr): bool {....raises: [],
    tags: [], forbids: [].}

proc XkbChangeMap(dpy: PDisplay; desc: PXkbDescPtr; changes: PXkbMapChangesPtr): bool {.
    cdecl, dynlib: libX11, importc: "XkbChangeMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbChangeNames(dpy: PDisplay; xkb: PXkbDescPtr; changes: PXkbNameChangesPtr): bool {.
    cdecl, dynlib: libX11, importc: "XkbChangeNames", ...raises: [], tags: [],
    forbids: [].}

proc XkbChangeTypesOfKey(xkb: PXkbDescPtr; key, num_groups: int16;
                         groups: int16; newTypes: ptr int16;
                         pChanges: PXkbMapChangesPtr): Status {.cdecl,
    dynlib: libX11, importc: "XkbChangeTypesOfKey", ...raises: [], tags: [],
    forbids: [].}

proc XkbComputeEffectiveMap(xkb: PXkbDescPtr; theType: PXkbKeyTypePtr;
                            map_rtrn: PByte): bool {.cdecl, dynlib: libX11,
    importc: "XkbComputeEffectiveMap", ...raises: [], tags: [], forbids: [].}

proc XkbCopyKeyType(from, into: PXkbKeyTypePtr): Status {.cdecl, dynlib: libX11,
    importc: "XkbCopyKeyType", ...raises: [], tags: [], forbids: [].}

proc XkbCopyKeyTypes(from, into: PXkbKeyTypePtr; num_types: int16): Status {.
    cdecl, dynlib: libX11, importc: "XkbCopyKeyTypes", ...raises: [], tags: [],
    forbids: [].}

proc XkbDeviceBell(dpy: PDisplay; win: Window;
                   deviceSpec, bellClass, bellID, percent: int16; name: Atom): bool {.
    cdecl, dynlib: libX11, importc: "XkbDeviceBell", ...raises: [], tags: [],
    forbids: [].}

proc XkbDeviceBellEvent(dpy: PDisplay; win: Window;
                        deviceSpec, bellClass, bellID, percent: int16;
                        name: Atom): bool {.cdecl, dynlib: libX11,
    importc: "XkbDeviceBellEvent", ...raises: [], tags: [], forbids: [].}

proc XkbForceBell(dpy: PDisplay; percent: int16): bool {.cdecl, dynlib: libX11,
    importc: "XkbForceBell", ...raises: [], tags: [], forbids: [].}

proc XkbForceDeviceBell(dpy: PDisplay;
                        deviceSpec, bellClass, bellID, percent: int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbForceDeviceBell", ...raises: [], tags: [],
    forbids: [].}

proc XkbFreeClientMap(xkb: PXkbDescPtr; what: int16; freeMap: bool) {.cdecl,
    dynlib: libX11, importc: "XkbFreeClientMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbFreeCompatMap(xkib: PXkbDescPtr; which: int16; freeMap: bool) {.cdecl,
    dynlib: libX11, importc: "XkbFreeCompatMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbFreeComponentList(list: PXkbComponentListPtr) {.cdecl, dynlib: libX11,
    importc: "XkbFreeComponentList", ...raises: [], tags: [], forbids: [].}

proc XkbFreeControls(xkb: PXkbDescPtr; which: int16; freeMap: bool) {.cdecl,
    dynlib: libX11, importc: "XkbFreeControls", ...raises: [], tags: [],
    forbids: [].}

proc XkbFreeDeviceInfo(devi: PXkbDeviceInfoPtr; which: int16; freeDevI: bool) {.
    cdecl, dynlib: libX11, importc: "XkbFreeDeviceInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbFreeIndicatorMaps(xkb: PXkbDescPtr) {.cdecl, dynlib: libX11,
    importc: "XkbFreeIndicatorMaps", ...raises: [], tags: [], forbids: [].}

proc XkbFreeKeyboard(xkb: PXkbDescPtr; which: int16; freeDesc: bool) {.cdecl,
    dynlib: libX11, importc: "XkbFreeKeyboard", ...raises: [], tags: [],
    forbids: [].}

proc XkbFreeNames(xkb: PXkbDescPtr; which: int16; freeMap: bool) {.cdecl,
    dynlib: libX11, importc: "XkbFreeNames", ...raises: [], tags: [], forbids: [].}

proc XkbFreeServerMap(xkb: PXkbDescPtr; what: int16; freeMap: bool) {.cdecl,
    dynlib: libX11, importc: "XkbFreeServerMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetAutoRepeatRate(dpy: PDisplay; deviceSpec: int16;
                          delayRtrn, intervalRtrn: PWord): bool {.cdecl,
    dynlib: libX11, importc: "XkbGetAutoRepeatRate", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetAutoResetControls(dpy: PDisplay; auto_ctrls, auto_ctrl_values: PWord): bool {.
    cdecl, dynlib: libX11, importc: "XkbGetAutoResetControls", ...raises: [],
    tags: [], forbids: [].}

proc XkbGetCompatMap(dpy: PDisplay; which: int16; xkb: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetCompatMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetControls(dpy: PDisplay; which: int32; desc: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetControls", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetControlsChanges(d: PDisplay; x: PXkbDescPtr;
                           c: PXkbControlsChangesPtr): Status {....raises: [],
    tags: [], forbids: [].}

proc XkbGetDetectableAutoRepeat(dpy: PDisplay; supported: ptr bool): bool {.
    cdecl, dynlib: libX11, importc: "XkbGetDetectableAutoRepeat", ...raises: [],
    tags: [], forbids: [].}

proc XkbGetDeviceButtonActions(dpy: PDisplay; devi: PXkbDeviceInfoPtr;
                               all: bool; first, nBtns: int16): Status {.cdecl,
    dynlib: libX11, importc: "XkbGetDeviceButtonActions", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetDeviceIndicatorState(dpy: PDisplay;
                                deviceSpec, ledClass, ledID: int16;
                                pStateRtrn: PWord): Status {.cdecl,
    dynlib: libX11, importc: "XkbGetDeviceIndicatorState", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetDeviceInfo(dpy: PDisplay; which, deviceSpec, ledClass, ledID: int16): PXkbDeviceInfoPtr {.
    cdecl, dynlib: libX11, importc: "XkbGetDeviceInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetDeviceInfoChanges(dpy: PDisplay; devi: PXkbDeviceInfoPtr;
                             changes: PXkbDeviceChangesPtr): Status {.cdecl,
    dynlib: libX11, importc: "XkbGetDeviceInfoChanges", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetDeviceLedInfo(dpy: PDisplay; devi: PXkbDeviceInfoPtr;
                         ledClass, ledId, which: int16): Status {.cdecl,
    dynlib: libX11, importc: "XkbGetDeviceLedInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetIndicatorMap(dpy: PDisplay; which: int32; desc: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetIndicatorMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetIndicatorMapChanges(d: PDisplay; x: PXkbDescPtr;
                               c: PXkbIndicatorChangesPtr): Status {....raises: [],
    tags: [], forbids: [].}

proc XkbGetIndicatorState(dpy: PDisplay; deviceSpec: int16; pStateRtrn: PWord): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetIndicatorState", ...raises: [],
    tags: [], forbids: [].}

proc XkbGetKeyActions(dpy: PDisplay; first, num: int16; xkb: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetKeyActions", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetKeyBehaviors(dpy: PDisplay; firstKey, nKeys: int16; desc: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetKeyBehaviors", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetKeyboard(dpy: PDisplay; which, deviceSpec: int16): PXkbDescPtr {.
    cdecl, dynlib: libX11, importc: "XkbGetKeyboard", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetKeyboardByName(dpy: PDisplay; deviceSpec: int16;
                          names: PXkbComponentNamesPtr; want, need: int16;
                          load: bool): PXkbDescPtr {.cdecl, dynlib: libX11,
    importc: "XkbGetKeyboardByName", ...raises: [], tags: [], forbids: [].}

proc XkbGetKeyExplicitComponents(dpy: PDisplay; firstKey, nKeys: int16;
                                 desc: PXkbDescPtr): Status {.cdecl,
    dynlib: libX11, importc: "XkbGetKeyExplicitComponents", ...raises: [],
    tags: [], forbids: [].}

proc XkbGetKeyModifierMap(dpy: PDisplay; firstKey, nKeys: int16;
                          desc: PXkbDescPtr): Status {.cdecl, dynlib: libX11,
    importc: "XkbGetKeyModifierMap", ...raises: [], tags: [], forbids: [].}

proc XkbGetKeySyms(dpy: PDisplay; first, num: int16; xkb: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetKeySyms", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetKeyTypes(dpy: PDisplay; first, num: int16; xkb: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetKeyTypes", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetMap(dpy: PDisplay; which, deviceSpec: int16): PXkbDescPtr {.cdecl,
    dynlib: libX11, importc: "XkbGetMap", ...raises: [], tags: [], forbids: [].}

proc XkbGetMapChanges(dpy: PDisplay; xkb: PXkbDescPtr;
                      changes: PXkbMapChangesPtr): Status {.cdecl,
    dynlib: libX11, importc: "XkbGetMapChanges", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetNamedDeviceIndicator(dpy: PDisplay;
                                deviceSpec, ledClass, ledID: int16; name: Atom;
                                pNdxRtrn: ptr int16; pStateRtrn: ptr bool;
                                pMapRtrn: PXkbIndicatorMapPtr;
                                pRealRtrn: ptr bool): bool {.cdecl,
    dynlib: libX11, importc: "XkbGetNamedDeviceIndicator", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetNamedIndicator(dpy: PDisplay; name: Atom; pNdxRtrn: ptr int16;
                          pStateRtrn: ptr bool; pMapRtrn: PXkbIndicatorMapPtr;
                          pRealRtrn: ptr bool): bool {.cdecl, dynlib: libX11,
    importc: "XkbGetNamedIndicator", ...raises: [], tags: [], forbids: [].}

proc XkbGetNames(dpy: PDisplay; which: int16; desc: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetNames", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetPerClientControls(dpy: PDisplay; ctrls: PWord): bool {.cdecl,
    dynlib: libX11, importc: "XkbGetPerClientControls", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetState(dpy: PDisplay; deviceSpec: int16; rtrnState: PXkbStatePtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetState", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetUpdatedMap(dpy: PDisplay; which: int16; desc: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetUpdatedMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetVirtualMods(dpy: PDisplay; which: int16; desc: PXkbDescPtr): Status {.
    cdecl, dynlib: libX11, importc: "XkbGetVirtualMods", ...raises: [], tags: [],
    forbids: [].}

proc XkbGetXlibControls(dpy: PDisplay): int16 {.cdecl, dynlib: libX11,
    importc: "XkbGetXlibControls", ...raises: [], tags: [], forbids: [].}

proc XkbIgnoreExtension(ignore: bool): bool {.cdecl, dynlib: libX11,
    importc: "XkbIgnoreExtension", ...raises: [], tags: [], forbids: [].}

proc XkbInitCanonicalKeyTypes(xkb: PXkbDescPtr; which: int16; keypadVMod: int16): Status {.
    cdecl, dynlib: libX11, importc: "XkbInitCanonicalKeyTypes", ...raises: [],
    tags: [], forbids: [].}

proc XkbKeycodeToKeysym(dpy: PDisplay; kc: KeyCode; group, level: int16): KeySym {.
    cdecl, dynlib: libX11, importc: "XkbKeycodeToKeysym", ...raises: [], tags: [],
    forbids: [].}

proc XkbKeysymToModifiers(dpy: PDisplay; ks: KeySym): int16 {.cdecl,
    dynlib: libX11, importc: "XkbKeysymToModifiers", ...raises: [], tags: [],
    forbids: [].}

proc XkbKeyTypesForCoreSymbols(xkb: PXkbDescPtr; map_width: int16;
                               core_syms: PKeySym; protected: int16;
                               types_inout: ptr int16; xkb_syms_rtrn: PKeySym): int16 {.
    cdecl, dynlib: libX11, importc: "XkbKeyTypesForCoreSymbols", ...raises: [],
    tags: [], forbids: [].}

proc XkbLatchGroup(dpy: PDisplay; deviceSpec, group: int16): bool {.cdecl,
    dynlib: libX11, importc: "XkbLatchGroup", ...raises: [], tags: [], forbids: [].}

proc XkbLatchModifiers(dpy: PDisplay; deviceSpec, affect, values: int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbLatchModifiers", ...raises: [], tags: [],
    forbids: [].}

proc XkbLibraryVersion(libMajorRtrn, libMinorRtrn: ptr int16): bool {.cdecl,
    dynlib: libX11, importc: "XkbLibraryVersion", ...raises: [], tags: [],
    forbids: [].}

proc XkbListComponents(dpy: PDisplay; deviceSpec: int16;
                       ptrns: PXkbComponentNamesPtr; max_inout: ptr int16): PXkbComponentListPtr {.
    cdecl, dynlib: libX11, importc: "XkbListComponents", ...raises: [], tags: [],
    forbids: [].}

proc XkbLockGroup(dpy: PDisplay; deviceSpec, group: int16): bool {.cdecl,
    dynlib: libX11, importc: "XkbLockGroup", ...raises: [], tags: [], forbids: [].}

proc XkbLockModifiers(dpy: PDisplay; deviceSpec, affect, values: int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbLockModifiers", ...raises: [], tags: [],
    forbids: [].}

proc XkbLookupKeyBinding(dpy: PDisplay; sym_rtrn: KeySym; mods: int16;
                         buffer: cstring; nbytes: int16; extra_rtrn: ptr int16): int16 {.
    cdecl, dynlib: libX11, importc: "XkbLookupKeyBinding", ...raises: [], tags: [],
    forbids: [].}

proc XkbLookupKeySym(dpy: PDisplay; keycode: KeyCode;
                     modifiers, modifiers_return: int16; keysym_return: PKeySym): bool {.
    cdecl, dynlib: libX11, importc: "XkbLookupKeySym", ...raises: [], tags: [],
    forbids: [].}

proc XkbNoteControlsChanges(old: PXkbControlsChangesPtr;
                            new: PXkbControlsNotifyEvent; wanted: int16) {.
    cdecl, dynlib: libX11, importc: "XkbNoteControlsChanges", ...raises: [],
    tags: [], forbids: [].}

proc XkbNoteDeviceChanges(old: PXkbDeviceChangesPtr;
                          new: PXkbExtensionDeviceNotifyEvent; wanted: int16) {.
    cdecl, dynlib: libX11, importc: "XkbNoteDeviceChanges", ...raises: [],
    tags: [], forbids: [].}

proc XkbNoteIndicatorMapChanges(o, n: PXkbIndicatorChangesPtr; w: int16) {.
    ...raises: [], tags: [], forbids: [].}

proc XkbNoteIndicatorStateChanges(o, n: PXkbIndicatorChangesPtr; w: int16) {.
    ...raises: [], tags: [], forbids: [].}

proc XkbNoteMapChanges(old: PXkbMapChangesPtr; new: PXkbMapNotifyEvent;
                       wanted: int16) {.cdecl, dynlib: libX11,
                                        importc: "XkbNoteMapChanges",
                                        ...raises: [], tags: [], forbids: [].}

proc XkbNoteNameChanges(old: PXkbNameChangesPtr; new: PXkbNamesNotifyEvent;
                        wanted: int16) {.cdecl, dynlib: libX11,
    importc: "XkbNoteNameChanges", ...raises: [], tags: [], forbids: [].}

proc XkbOpenDisplay(name: cstring; ev_rtrn, err_rtrn, major_rtrn, minor_rtrn,
                                   reason: ptr int16): PDisplay {.cdecl,
    dynlib: libX11, importc: "XkbOpenDisplay", ...raises: [], tags: [], forbids: [].}

proc XkbQueryExtension(dpy: PDisplay; opcodeReturn, eventBaseReturn,
                                      errorBaseReturn, majorRtrn, minorRtrn: ptr int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbQueryExtension", ...raises: [], tags: [],
    forbids: [].}

proc XkbRefreshKeyboardMapping(event: PXkbMapNotifyEvent): Status {.cdecl,
    dynlib: libX11, importc: "XkbRefreshKeyboardMapping", ...raises: [], tags: [],
    forbids: [].}

proc XkbResizeDeviceButtonActions(devi: PXkbDeviceInfoPtr; newTotal: int16): Status {.
    cdecl, dynlib: libX11, importc: "XkbResizeDeviceButtonActions", ...raises: [],
    tags: [], forbids: [].}

proc XkbResizeKeyActions(desc: PXkbDescPtr; forKey, actsNeeded: int16): PXkbAction {.
    cdecl, dynlib: libX11, importc: "XkbResizeKeyActions", ...raises: [], tags: [],
    forbids: [].}

proc XkbResizeKeySyms(desc: PXkbDescPtr; forKey, symsNeeded: int16): PKeySym {.
    cdecl, dynlib: libX11, importc: "XkbResizeKeySyms", ...raises: [], tags: [],
    forbids: [].}

proc XkbResizeKeyType(xkb: PXkbDescPtr; type_ndx, map_count: int16;
                      want_preserve: bool; new_num_lvls: int16): Status {.cdecl,
    dynlib: libX11, importc: "XkbResizeKeyType", ...raises: [], tags: [],
    forbids: [].}

proc XkbSelectEventDetails(dpy: PDisplay; deviceID, eventType: int16;
                           affect, details: int32): bool {.cdecl,
    dynlib: libX11, importc: "XkbSelectEventDetails", ...raises: [], tags: [],
    forbids: [].}

proc XkbSelectEvents(dpy: PDisplay; deviceID, affect, values: int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbSelectEvents", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetAtomFuncs(getAtom: XkbInternAtomFunc; getName: XkbGetAtomNameFunc) {.
    cdecl, dynlib: libX11, importc: "XkbSetAtomFuncs", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetAutoRepeatRate(dpy: PDisplay; deviceSpec, delay, interval: int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbSetAutoRepeatRate", ...raises: [],
    tags: [], forbids: [].}

proc XkbSetAutoResetControls(dpy: PDisplay; changes: int16;
                             auto_ctrls, auto_values: PWord): bool {.cdecl,
    dynlib: libX11, importc: "XkbSetAutoResetControls", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetCompatMap(dpy: PDisplay; which: int16; xkb: PXkbDescPtr;
                     updateActions: bool): bool {.cdecl, dynlib: libX11,
    importc: "XkbSetCompatMap", ...raises: [], tags: [], forbids: [].}

proc XkbSetControls(dpy: PDisplay; which: int32; desc: PXkbDescPtr): bool {.
    cdecl, dynlib: libX11, importc: "XkbSetControls", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetDebuggingFlags(dpy: PDisplay; mask, flags: int16; msg: cstring;
                          ctrls_mask, ctrls, rtrn_flags, rtrn_ctrls: int16): bool {.
    cdecl, dynlib: libX11, importc: "XkbSetDebuggingFlags", ...raises: [],
    tags: [], forbids: [].}

proc XkbSetDetectableAutoRepeat(dpy: PDisplay; detectable: bool;
                                supported: ptr bool): bool {.cdecl,
    dynlib: libX11, importc: "XkbSetDetectableAutoRepeat", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetDeviceButtonActions(dpy: PDisplay; devi: PXkbDeviceInfoPtr;
                               first, nBtns: int16): bool {.cdecl,
    dynlib: libX11, importc: "XkbSetDeviceButtonActions", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetDeviceInfo(dpy: PDisplay; which: int16; devi: PXkbDeviceInfoPtr): bool {.
    cdecl, dynlib: libX11, importc: "XkbSetDeviceInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetDeviceLedInfo(dpy: PDisplay; devi: PXkbDeviceInfoPtr;
                         ledClass, ledID, which: int16): bool {.cdecl,
    dynlib: libX11, importc: "XkbSetDeviceLedInfo", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetIgnoreLockMods(dpy: PDisplay; deviceSpec, affectReal, realValues,
    affectVirtual, virtualValues: int16): bool {.cdecl, dynlib: libX11,
    importc: "XkbSetIgnoreLockMods", ...raises: [], tags: [], forbids: [].}

proc XkbSetIndicatorMap(dpy: PDisplay; which: int32; desc: PXkbDescPtr): bool {.
    cdecl, dynlib: libX11, importc: "XkbSetIndicatorMap", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetMap(dpy: PDisplay; which: int16; desc: PXkbDescPtr): bool {.cdecl,
    dynlib: libX11, importc: "XkbSetMap", ...raises: [], tags: [], forbids: [].}

proc XkbSetNamedDeviceIndicator(dpy: PDisplay;
                                deviceSpec, ledClass, ledID: int16; name: Atom;
                                changeState, state, createNewMap: bool;
                                pMap: PXkbIndicatorMapPtr): bool {.cdecl,
    dynlib: libX11, importc: "XkbSetNamedDeviceIndicator", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetNamedIndicator(dpy: PDisplay; name: Atom;
                          changeState, state, createNewMap: bool;
                          pMap: PXkbIndicatorMapPtr): bool {.cdecl,
    dynlib: libX11, importc: "XkbSetNamedIndicator", ...raises: [], tags: [],
    forbids: [].}

proc XkbSetNames(dpy: PDisplay; which, firstType, nTypes: int16;
                 desc: PXkbDescPtr): bool {.cdecl, dynlib: libX11,
    importc: "XkbSetNames", ...raises: [], tags: [], forbids: [].}

proc XkbSetPerClientControls(dpy: PDisplay; change: int16; values: PWord): bool {.
    cdecl, dynlib: libX11, importc: "XkbSetPerClientControls", ...raises: [],
    tags: [], forbids: [].}

proc XkbSetServerInternalMods(dpy: PDisplay; deviceSpec, affectReal, realValues,
    affectVirtual, virtualValues: int16): bool {.cdecl, dynlib: libX11,
    importc: "XkbSetServerInternalMods", ...raises: [], tags: [], forbids: [].}

proc XkbSetXlibControls(dpy: PDisplay; affect, values: int16): int16 {.cdecl,
    dynlib: libX11, importc: "XkbSetXlibControls", ...raises: [], tags: [],
    forbids: [].}

proc XkbToControl(c: int8): int8 {.cdecl, dynlib: libX11,
                                   importc: "XkbToControl", ...raises: [],
                                   tags: [], forbids: [].}

proc XkbTranslateKeyCode(xkb: PXkbDescPtr; keycode: KeyCode;
                         modifiers, modifiers_return: int16;
                         keysym_return: PKeySym): bool {.cdecl, dynlib: libX11,
    importc: "XkbTranslateKeyCode", ...raises: [], tags: [], forbids: [].}