@git-emoji/dataset-js/out/word.d.ts

Emoji data and contextual emoji data

export declare type WordTag = 'verb' | 'acronym' | 'abbreviation';
export declare type WordEntry = {
    cover: string[];
    tag: WordTag[];
};
export declare type WordDict = {
    [key: string]: WordEntry;
};
export declare const word: {
    abort: {
        cover: never[];
        tag: string[];
    };
    access: {
        cover: never[];
        tag: string[];
    };
    acl: {
        cover: never[];
        tag: string[];
    };
    action: {
        cover: never[];
        tag: never[];
    };
    add: {
        cover: never[];
        tag: string[];
    };
    addin: {
        cover: string[];
        tag: never[];
    };
    address: {
        cover: never[];
        tag: never[];
    };
    align: {
        cover: never[];
        tag: string[];
    };
    alternate: {
        cover: string[];
        tag: string[];
    };
    alternative: {
        cover: never[];
        tag: never[];
    };
    amend: {
        cover: never[];
        tag: string[];
    };
    android: {
        cover: never[];
        tag: never[];
    };
    antivirus: {
        cover: string[];
        tag: never[];
    };
    append: {
        cover: never[];
        tag: string[];
    };
    application: {
        cover: string[];
        tag: never[];
    };
    apply: {
        cover: string[];
        tag: string[];
    };
    archive: {
        cover: string[];
        tag: string[];
    };
    area: {
        cover: never[];
        tag: never[];
    };
    argument: {
        cover: never[];
        tag: never[];
    };
    arrange: {
        cover: string[];
        tag: string[];
    };
    array: {
        cover: never[];
        tag: never[];
    };
    ask: {
        cover: never[];
        tag: string[];
    };
    assess: {
        cover: never[];
        tag: string[];
    };
    attach: {
        cover: never[];
        tag: string[];
    };
    attempt: {
        cover: never[];
        tag: string[];
    };
    authenticate: {
        cover: string[];
        tag: string[];
    };
    authorize: {
        cover: string[];
        tag: string[];
    };
    avoid: {
        cover: never[];
        tag: string[];
    };
    await: {
        cover: never[];
        tag: string[];
    };
    awake: {
        cover: string[];
        tag: string[];
    };
    away: {
        cover: never[];
        tag: never[];
    };
    base: {
        cover: never[];
        tag: never[];
    };
    bash: {
        cover: never[];
        tag: string[];
    };
    beautiful: {
        cover: never[];
        tag: never[];
    };
    beautify: {
        cover: string[];
        tag: string[];
    };
    beauty: {
        cover: never[];
        tag: never[];
    };
    begin: {
        cover: string[];
        tag: string[];
    };
    behave: {
        cover: string[];
        tag: string[];
    };
    behavior: {
        cover: string[];
        tag: never[];
    };
    beware: {
        cover: string[];
        tag: never[];
    };
    block: {
        cover: never[];
        tag: string[];
    };
    body: {
        cover: never[];
        tag: never[];
    };
    bogus: {
        cover: never[];
        tag: never[];
    };
    book: {
        cover: never[];
        tag: string[];
    };
    boot: {
        cover: never[];
        tag: string[];
    };
    bound: {
        cover: never[];
        tag: string[];
    };
    boundary: {
        cover: string[];
        tag: never[];
    };
    box: {
        cover: never[];
        tag: never[];
    };
    boy: {
        cover: never[];
        tag: never[];
    };
    brain: {
        cover: never[];
        tag: never[];
    };
    breach: {
        cover: never[];
        tag: string[];
    };
    broadcast: {
        cover: never[];
        tag: string[];
    };
    browse: {
        cover: string[];
        tag: string[];
    };
    buffer: {
        cover: never[];
        tag: string[];
    };
    bug: {
        cover: never[];
        tag: never[];
    };
    bugfix: {
        cover: never[];
        tag: never[];
    };
    bump: {
        cover: never[];
        tag: string[];
    };
    calendar: {
        cover: never[];
        tag: never[];
    };
    callback: {
        cover: string[];
        tag: never[];
    };
    cancel: {
        cover: never[];
        tag: string[];
    };
    canvas: {
        cover: never[];
        tag: never[];
    };
    caution: {
        cover: never[];
        tag: never[];
    };
    ceiling: {
        cover: never[];
        tag: never[];
    };
    center: {
        cover: string[];
        tag: never[];
    };
    change: {
        cover: string[];
        tag: string[];
    };
    check: {
        cover: never[];
        tag: string[];
    };
    clean: {
        cover: never[];
        tag: string[];
    };
    click: {
        cover: never[];
        tag: string[];
    };
    client: {
        cover: never[];
        tag: never[];
    };
    close: {
        cover: string[];
        tag: string[];
    };
    clutter: {
        cover: never[];
        tag: string[];
    };
    cmd: {
        cover: never[];
        tag: string[];
    };
    code: {
        cover: string[];
        tag: never[];
    };
    combine: {
        cover: string[];
        tag: string[];
    };
    comment: {
        cover: never[];
        tag: string[];
    };
    commit: {
        cover: never[];
        tag: string[];
    };
    component: {
        cover: never[];
        tag: never[];
    };
    compromise: {
        cover: string[];
        tag: string[];
    };
    conceal: {
        cover: never[];
        tag: string[];
    };
    config: {
        cover: never[];
        tag: never[];
    };
    confirm: {
        cover: never[];
        tag: string[];
    };
    conform: {
        cover: never[];
        tag: string[];
    };
    constrain: {
        cover: never[];
        tag: string[];
    };
    construct: {
        cover: never[];
        tag: string[];
    };
    consume: {
        cover: string[];
        tag: string[];
    };
    contain: {
        cover: never[];
        tag: string[];
    };
    container: {
        cover: never[];
        tag: never[];
    };
    content: {
        cover: never[];
        tag: never[];
    };
    convolve: {
        cover: string[];
        tag: string[];
    };
    core: {
        cover: never[];
        tag: never[];
    };
    correct: {
        cover: never[];
        tag: never[];
    };
    cosmetics: {
        cover: never[];
        tag: never[];
    };
    cover: {
        cover: never[];
        tag: string[];
    };
    crash: {
        cover: never[];
        tag: never[];
    };
    cron: {
        cover: never[];
        tag: never[];
    };
    css: {
        cover: never[];
        tag: string[];
    };
    cursor: {
        cover: never[];
        tag: never[];
    };
    danger: {
        cover: never[];
        tag: never[];
    };
    dark: {
        cover: never[];
        tag: never[];
    };
    data: {
        cover: never[];
        tag: never[];
    };
    date: {
        cover: never[];
        tag: never[];
    };
    day: {
        cover: never[];
        tag: never[];
    };
    daylight: {
        cover: never[];
        tag: never[];
    };
    deadlock: {
        cover: string[];
        tag: never[];
    };
    dealer: {
        cover: never[];
        tag: never[];
    };
    decode: {
        cover: string[];
        tag: string[];
    };
    decrease: {
        cover: string[];
        tag: string[];
    };
    decrement: {
        cover: never[];
        tag: string[];
    };
    decrypt: {
        cover: never[];
        tag: string[];
    };
    degrade: {
        cover: string[];
        tag: string[];
    };
    delete: {
        cover: string[];
        tag: string[];
    };
    demonstrate: {
        cover: string[];
        tag: string[];
    };
    dependency: {
        cover: string[];
        tag: never[];
    };
    dependent: {
        cover: never[];
        tag: never[];
    };
    deploy: {
        cover: never[];
        tag: string[];
    };
    deprecate: {
        cover: string[];
        tag: string[];
    };
    deserialize: {
        cover: string[];
        tag: string[];
    };
    destroy: {
        cover: string[];
        tag: string[];
    };
    destruct: {
        cover: never[];
        tag: string[];
    };
    detail: {
        cover: never[];
        tag: never[];
    };
    dig: {
        cover: never[];
        tag: string[];
    };
    direct: {
        cover: never[];
        tag: never[];
    };
    disable: {
        cover: string[];
        tag: string[];
    };
    disc: {
        cover: never[];
        tag: never[];
    };
    display: {
        cover: never[];
        tag: never[];
    };
    dispose: {
        cover: string[];
        tag: string[];
    };
    distill: {
        cover: never[];
        tag: string[];
    };
    do: {
        cover: never[];
        tag: string[];
    };
    doc: {
        cover: never[];
        tag: string[];
    };
    document: {
        cover: never[];
        tag: string[];
    };
    dos: {
        cover: never[];
        tag: string[];
    };
    down: {
        cover: never[];
        tag: never[];
    };
    downgrade: {
        cover: string[];
        tag: string[];
    };
    draft: {
        cover: never[];
        tag: never[];
    };
    draw: {
        cover: string[];
        tag: string[];
    };
    drive: {
        cover: string[];
        tag: string[];
    };
    drop: {
        cover: never[];
        tag: string[];
    };
    edge: {
        cover: never[];
        tag: never[];
    };
    element: {
        cover: never[];
        tag: never[];
    };
    email: {
        cover: never[];
        tag: string[];
    };
    embellish: {
        cover: never[];
        tag: string[];
    };
    emulate: {
        cover: string[];
        tag: string[];
    };
    enable: {
        cover: string[];
        tag: string[];
    };
    encode: {
        cover: string[];
        tag: string[];
    };
    encrypt: {
        cover: never[];
        tag: string[];
    };
    end: {
        cover: never[];
        tag: string[];
    };
    enhance: {
        cover: string[];
        tag: string[];
    };
    enumerate: {
        cover: string[];
        tag: string[];
    };
    erroneous: {
        cover: never[];
        tag: never[];
    };
    error: {
        cover: never[];
        tag: never[];
    };
    establish: {
        cover: never[];
        tag: string[];
    };
    ethernet: {
        cover: never[];
        tag: never[];
    };
    exam: {
        cover: never[];
        tag: never[];
    };
    exception: {
        cover: never[];
        tag: never[];
    };
    exclude: {
        cover: string[];
        tag: string[];
    };
    execute: {
        cover: string[];
        tag: string[];
    };
    face: {
        cover: string[];
        tag: never[];
    };
    fake: {
        cover: string[];
        tag: never[];
    };
    faulty: {
        cover: never[];
        tag: never[];
    };
    feature: {
        cover: string[];
        tag: never[];
    };
    female: {
        cover: never[];
        tag: never[];
    };
    fetch: {
        cover: never[];
        tag: string[];
    };
    field: {
        cover: never[];
        tag: never[];
    };
    find: {
        cover: string[];
        tag: string[];
    };
    fish: {
        cover: never[];
        tag: string[];
    };
    fix: {
        cover: never[];
        tag: string[];
    };
    fixture: {
        cover: string[];
        tag: never[];
    };
    floor: {
        cover: never[];
        tag: never[];
    };
    for: {
        cover: never[];
        tag: never[];
    };
    forget: {
        cover: string[];
        tag: string[];
    };
    format: {
        cover: never[];
        tag: string[];
    };
    foul: {
        cover: never[];
        tag: never[];
    };
    free: {
        cover: never[];
        tag: never[];
    };
    fresh: {
        cover: never[];
        tag: never[];
    };
    frontend: {
        cover: string[];
        tag: never[];
    };
    function: {
        cover: never[];
        tag: string[];
    };
    girl: {
        cover: never[];
        tag: never[];
    };
    give: {
        cover: string[];
        tag: string[];
    };
    good: {
        cover: never[];
        tag: never[];
    };
    graph: {
        cover: never[];
        tag: never[];
    };
    ground: {
        cover: never[];
        tag: never[];
    };
    guard: {
        cover: never[];
        tag: string[];
    };
    guide: {
        cover: string[];
        tag: string[];
    };
    hack: {
        cover: never[];
        tag: string[];
    };
    handshake: {
        cover: string[];
        tag: string[];
    };
    hang: {
        cover: never[];
        tag: string[];
    };
    hash: {
        cover: never[];
        tag: string[];
    };
    hazard: {
        cover: never[];
        tag: never[];
    };
    heart: {
        cover: never[];
        tag: never[];
    };
    hide: {
        cover: string[];
        tag: string[];
    };
    hinder: {
        cover: never[];
        tag: string[];
    };
    hold: {
        cover: string[];
        tag: string[];
    };
    holdup: {
        cover: string[];
        tag: never[];
    };
    hole: {
        cover: never[];
        tag: never[];
    };
    home: {
        cover: never[];
        tag: never[];
    };
    host: {
        cover: never[];
        tag: never[];
    };
    html: {
        cover: never[];
        tag: string[];
    };
    human: {
        cover: never[];
        tag: never[];
    };
    identifier: {
        cover: never[];
        tag: never[];
    };
    ignore: {
        cover: string[];
        tag: string[];
    };
    illustrate: {
        cover: string[];
        tag: string[];
    };
    image: {
        cover: string[];
        tag: never[];
    };
    immature: {
        cover: never[];
        tag: never[];
    };
    impersonate: {
        cover: string[];
        tag: string[];
    };
    implement: {
        cover: never[];
        tag: string[];
    };
    improve: {
        cover: string[];
        tag: string[];
    };
    improvise: {
        cover: string[];
        tag: string[];
    };
    inbound: {
        cover: never[];
        tag: never[];
    };
    incorrect: {
        cover: never[];
        tag: never[];
    };
    increase: {
        cover: string[];
        tag: string[];
    };
    increment: {
        cover: never[];
        tag: string[];
    };
    info: {
        cover: string[];
        tag: never[];
    };
    init: {
        cover: never[];
        tag: string[];
    };
    initial: {
        cover: never[];
        tag: never[];
    };
    initialize: {
        cover: string[];
        tag: string[];
    };
    inquiry: {
        cover: never[];
        tag: string[];
    };
    insert: {
        cover: never[];
        tag: string[];
    };
    inspect: {
        cover: never[];
        tag: string[];
    };
    install: {
        cover: never[];
        tag: string[];
    };
    instruct: {
        cover: never[];
        tag: string[];
    };
    intermediate: {
        cover: string[];
        tag: never[];
    };
    internet: {
        cover: never[];
        tag: never[];
    };
    interrupt: {
        cover: never[];
        tag: string[];
    };
    introduce: {
        cover: string[];
        tag: string[];
    };
    investigate: {
        cover: string[];
        tag: string[];
    };
    ios: {
        cover: never[];
        tag: never[];
    };
    item: {
        cover: never[];
        tag: never[];
    };
    iterate: {
        cover: string[];
        tag: string[];
    };
    job: {
        cover: never[];
        tag: never[];
    };
    jump: {
        cover: never[];
        tag: string[];
    };
    keep: {
        cover: string[];
        tag: string[];
    };
    key: {
        cover: never[];
        tag: never[];
    };
    keyboard: {
        cover: never[];
        tag: never[];
    };
    kill: {
        cover: never[];
        tag: string[];
    };
    lan: {
        cover: never[];
        tag: string[];
    };
    landmark: {
        cover: never[];
        tag: never[];
    };
    launch: {
        cover: never[];
        tag: string[];
    };
    layer: {
        cover: never[];
        tag: never[];
    };
    leaf: {
        cover: string[];
        tag: never[];
    };
    library: {
        cover: never[];
        tag: never[];
    };
    light: {
        cover: never[];
        tag: never[];
    };
    limit: {
        cover: never[];
        tag: string[];
    };
    line: {
        cover: never[];
        tag: never[];
    };
    lint: {
        cover: never[];
        tag: string[];
    };
    list: {
        cover: never[];
        tag: string[];
    };
    listen: {
        cover: never[];
        tag: string[];
    };
    load: {
        cover: never[];
        tag: string[];
    };
    location: {
        cover: never[];
        tag: never[];
    };
    lock: {
        cover: never[];
        tag: string[];
    };
    log: {
        cover: never[];
        tag: string[];
    };
    lookout: {
        cover: string[];
        tag: never[];
    };
    lookup: {
        cover: string[];
        tag: string[];
    };
    loop: {
        cover: never[];
        tag: never[];
    };
    loopback: {
        cover: string[];
        tag: never[];
    };
    mail: {
        cover: never[];
        tag: string[];
    };
    male: {
        cover: never[];
        tag: never[];
    };
    man: {
        cover: never[];
        tag: never[];
    };
    manual: {
        cover: never[];
        tag: never[];
    };
    measure: {
        cover: string[];
        tag: string[];
    };
    memory: {
        cover: string[];
        tag: never[];
    };
    merge: {
        cover: string[];
        tag: string[];
    };
    meter: {
        cover: never[];
        tag: string[];
    };
    method: {
        cover: never[];
        tag: never[];
    };
    metre: {
        cover: never[];
        tag: never[];
    };
    metric: {
        cover: never[];
        tag: never[];
    };
    middle: {
        cover: string[];
        tag: never[];
    };
    middleman: {
        cover: string[];
        tag: never[];
    };
    middleware: {
        cover: string[];
        tag: never[];
    };
    mix: {
        cover: never[];
        tag: string[];
    };
    mobile: {
        cover: never[];
        tag: never[];
    };
    mock: {
        cover: never[];
        tag: string[];
    };
    module: {
        cover: string[];
        tag: never[];
    };
    monitor: {
        cover: never[];
        tag: string[];
    };
    mouse: {
        cover: never[];
        tag: never[];
    };
    move: {
        cover: string[];
        tag: string[];
    };
    navigate: {
        cover: string[];
        tag: string[];
    };
    neglect: {
        cover: never[];
        tag: string[];
    };
    net: {
        cover: never[];
        tag: never[];
    };
    network: {
        cover: never[];
        tag: never[];
    };
    new: {
        cover: never[];
        tag: never[];
    };
    night: {
        cover: never[];
        tag: never[];
    };
    note: {
        cover: string[];
        tag: string[];
    };
    notice: {
        cover: string[];
        tag: string[];
    };
    object: {
        cover: never[];
        tag: never[];
    };
    off: {
        cover: never[];
        tag: never[];
    };
    on: {
        cover: never[];
        tag: never[];
    };
    open: {
        cover: never[];
        tag: string[];
    };
    operation: {
        cover: never[];
        tag: never[];
    };
    operator: {
        cover: never[];
        tag: never[];
    };
    option: {
        cover: never[];
        tag: never[];
    };
    order: {
        cover: never[];
        tag: string[];
    };
    organize: {
        cover: string[];
        tag: string[];
    };
    origin: {
        cover: never[];
        tag: never[];
    };
    out: {
        cover: never[];
        tag: never[];
    };
    overlook: {
        cover: string[];
        tag: string[];
    };
    package: {
        cover: string[];
        tag: string[];
    };
    paint: {
        cover: never[];
        tag: string[];
    };
    parameter: {
        cover: never[];
        tag: never[];
    };
    patch: {
        cover: never[];
        tag: string[];
    };
    path: {
        cover: never[];
        tag: never[];
    };
    pause: {
        cover: string[];
        tag: string[];
    };
    pend: {
        cover: never[];
        tag: string[];
    };
    penetrate: {
        cover: string[];
        tag: string[];
    };
    period: {
        cover: never[];
        tag: never[];
    };
    persist: {
        cover: never[];
        tag: string[];
    };
    picture: {
        cover: never[];
        tag: never[];
    };
    ping: {
        cover: never[];
        tag: string[];
    };
    play: {
        cover: never[];
        tag: string[];
    };
    plug: {
        cover: never[];
        tag: string[];
    };
    plugin: {
        cover: string[];
        tag: never[];
    };
    polish: {
        cover: never[];
        tag: string[];
    };
    pong: {
        cover: never[];
        tag: string[];
    };
    postfix: {
        cover: never[];
        tag: never[];
    };
    powershell: {
        cover: never[];
        tag: never[];
    };
    prefix: {
        cover: never[];
        tag: never[];
    };
    premature: {
        cover: string[];
        tag: never[];
    };
    prepend: {
        cover: never[];
        tag: string[];
    };
    prettify: {
        cover: string[];
        tag: string[];
    };
    pretty: {
        cover: string[];
        tag: never[];
    };
    prevent: {
        cover: never[];
        tag: string[];
    };
    print: {
        cover: never[];
        tag: string[];
    };
    process: {
        cover: string[];
        tag: string[];
    };
    produce: {
        cover: string[];
        tag: string[];
    };
    program: {
        cover: never[];
        tag: string[];
    };
    property: {
        cover: string[];
        tag: never[];
    };
    protect: {
        cover: never[];
        tag: string[];
    };
    publish: {
        cover: never[];
        tag: string[];
    };
    put: {
        cover: never[];
        tag: string[];
    };
    pwsh: {
        cover: never[];
        tag: string[];
    };
    query: {
        cover: never[];
        tag: string[];
    };
    question: {
        cover: never[];
        tag: string[];
    };
    queue: {
        cover: string[];
        tag: string[];
    };
    radial: {
        cover: never[];
        tag: never[];
    };
    range: {
        cover: string[];
        tag: never[];
    };
    read: {
        cover: never[];
        tag: string[];
    };
    readability: {
        cover: never[];
        tag: never[];
    };
    readable: {
        cover: never[];
        tag: never[];
    };
    readme: {
        cover: string[];
        tag: never[];
    };
    rearrange: {
        cover: string[];
        tag: string[];
    };
    reattempt: {
        cover: string[];
        tag: string[];
    };
    reboot: {
        cover: string[];
        tag: string[];
    };
    receive: {
        cover: string[];
        tag: string[];
    };
    reconnect: {
        cover: never[];
        tag: string[];
    };
    reconstruct: {
        cover: never[];
        tag: string[];
    };
    record: {
        cover: never[];
        tag: string[];
    };
    recycle: {
        cover: string[];
        tag: string[];
    };
    redirect: {
        cover: never[];
        tag: string[];
    };
    redo: {
        cover: never[];
        tag: string[];
    };
    reestablish: {
        cover: string[];
        tag: string[];
    };
    refactor: {
        cover: string[];
        tag: string[];
    };
    reference: {
        cover: string[];
        tag: string[];
    };
    refresh: {
        cover: never[];
        tag: string[];
    };
    register: {
        cover: never[];
        tag: string[];
    };
    reimplement: {
        cover: string[];
        tag: string[];
    };
    release: {
        cover: string[];
        tag: string[];
    };
    remove: {
        cover: string[];
        tag: string[];
    };
    reorder: {
        cover: never[];
        tag: string[];
    };
    repair: {
        cover: never[];
        tag: string[];
    };
    repeat: {
        cover: never[];
        tag: string[];
    };
    repetitive: {
        cover: string[];
        tag: never[];
    };
    replace: {
        cover: string[];
        tag: string[];
    };
    repopulate: {
        cover: string[];
        tag: string[];
    };
    request: {
        cover: never[];
        tag: string[];
    };
    rerun: {
        cover: string[];
        tag: string[];
    };
    reset: {
        cover: never[];
        tag: string[];
    };
    resolve: {
        cover: string[];
        tag: string[];
    };
    restart: {
        cover: string[];
        tag: string[];
    };
    restrain: {
        cover: never[];
        tag: string[];
    };
    restrict: {
        cover: never[];
        tag: string[];
    };
    rethink: {
        cover: never[];
        tag: string[];
    };
    retro: {
        cover: never[];
        tag: never[];
    };
    retrospect: {
        cover: never[];
        tag: never[];
    };
    retry: {
        cover: string[];
        tag: string[];
    };
    reveal: {
        cover: never[];
        tag: string[];
    };
    revert: {
        cover: never[];
        tag: string[];
    };
    review: {
        cover: never[];
        tag: string[];
    };
    revision: {
        cover: never[];
        tag: never[];
    };
    rewrite: {
        cover: string[];
        tag: string[];
    };
    rollback: {
        cover: string[];
        tag: string[];
    };
    root: {
        cover: never[];
        tag: never[];
    };
    route: {
        cover: string[];
        tag: string[];
    };
    run: {
        cover: string[];
        tag: string[];
    };
    safe: {
        cover: never[];
        tag: never[];
    };
    save: {
        cover: string[];
        tag: string[];
    };
    schedule: {
        cover: string[];
        tag: string[];
    };
    scramble: {
        cover: string[];
        tag: string[];
    };
    screen: {
        cover: never[];
        tag: never[];
    };
    seal: {
        cover: never[];
        tag: string[];
    };
    search: {
        cover: never[];
        tag: string[];
    };
    secret: {
        cover: never[];
        tag: never[];
    };
    secure: {
        cover: string[];
        tag: string[];
    };
    security: {
        cover: never[];
        tag: never[];
    };
    select: {
        cover: never[];
        tag: string[];
    };
    send: {
        cover: string[];
        tag: string[];
    };
    serialize: {
        cover: string[];
        tag: string[];
    };
    serve: {
        cover: string[];
        tag: string[];
    };
    set: {
        cover: never[];
        tag: string[];
    };
    setting: {
        cover: never[];
        tag: never[];
    };
    setup: {
        cover: string[];
        tag: string[];
    };
    shadow: {
        cover: never[];
        tag: never[];
    };
    shell: {
        cover: never[];
        tag: never[];
    };
    shield: {
        cover: never[];
        tag: never[];
    };
    show: {
        cover: never[];
        tag: string[];
    };
    sign: {
        cover: never[];
        tag: never[];
    };
    silence: {
        cover: string[];
        tag: string[];
    };
    silent: {
        cover: never[];
        tag: never[];
    };
    simulate: {
        cover: string[];
        tag: string[];
    };
    skip: {
        cover: never[];
        tag: string[];
    };
    sleep: {
        cover: never[];
        tag: string[];
    };
    smartphone: {
        cover: string[];
        tag: never[];
    };
    sort: {
        cover: never[];
        tag: string[];
    };
    spy: {
        cover: string[];
        tag: never[];
    };
    stack: {
        cover: never[];
        tag: string[];
    };
    standby: {
        cover: string[];
        tag: string[];
    };
    start: {
        cover: never[];
        tag: string[];
    };
    stop: {
        cover: never[];
        tag: string[];
    };
    store: {
        cover: string[];
        tag: string[];
    };
    structure: {
        cover: string[];
        tag: string[];
    };
    stub: {
        cover: never[];
        tag: never[];
    };
    style: {
        cover: string[];
        tag: never[];
    };
    subscribe: {
        cover: string[];
        tag: string[];
    };
    substitute: {
        cover: string[];
        tag: string[];
    };
    suffix: {
        cover: never[];
        tag: never[];
    };
    supervise: {
        cover: string[];
        tag: string[];
    };
    support: {
        cover: never[];
        tag: string[];
    };
    suppress: {
        cover: never[];
        tag: string[];
    };
    suspend: {
        cover: string[];
        tag: string[];
    };
    switch: {
        cover: never[];
        tag: string[];
    };
    take: {
        cover: string[];
        tag: string[];
    };
    temporary: {
        cover: string[];
        tag: never[];
    };
    terminal: {
        cover: never[];
        tag: never[];
    };
    test: {
        cover: never[];
        tag: string[];
    };
    text: {
        cover: never[];
        tag: never[];
    };
    thread: {
        cover: never[];
        tag: never[];
    };
    threshold: {
        cover: never[];
        tag: never[];
    };
    time: {
        cover: string[];
        tag: string[];
    };
    transform: {
        cover: never[];
        tag: string[];
    };
    transport: {
        cover: never[];
        tag: string[];
    };
    trash: {
        cover: never[];
        tag: never[];
    };
    tree: {
        cover: never[];
        tag: never[];
    };
    trespass: {
        cover: never[];
        tag: string[];
    };
    try: {
        cover: string[];
        tag: string[];
    };
    ui: {
        cover: string[];
        tag: string[];
    };
    uncover: {
        cover: string[];
        tag: string[];
    };
    undo: {
        cover: never[];
        tag: string[];
    };
    unfollow: {
        cover: string[];
        tag: string[];
    };
    unify: {
        cover: string[];
        tag: string[];
    };
    unit: {
        cover: never[];
        tag: never[];
    };
    unite: {
        cover: string[];
        tag: string[];
    };
    unleash: {
        cover: never[];
        tag: string[];
    };
    unscramble: {
        cover: string[];
        tag: string[];
    };
    unveil: {
        cover: never[];
        tag: string[];
    };
    up: {
        cover: never[];
        tag: never[];
    };
    update: {
        cover: string[];
        tag: string[];
    };
    upgrade: {
        cover: string[];
        tag: string[];
    };
    uri: {
        cover: never[];
        tag: string[];
    };
    url: {
        cover: never[];
        tag: string[];
    };
    user: {
        cover: never[];
        tag: never[];
    };
    ux: {
        cover: string[];
        tag: string[];
    };
    validate: {
        cover: string[];
        tag: never[];
    };
    variable: {
        cover: never[];
        tag: never[];
    };
    verify: {
        cover: string[];
        tag: string[];
    };
    version: {
        cover: never[];
        tag: never[];
    };
    view: {
        cover: never[];
        tag: string[];
    };
    visibility: {
        cover: string[];
        tag: never[];
    };
    visible: {
        cover: never[];
        tag: never[];
    };
    vulnerability: {
        cover: string[];
        tag: never[];
    };
    wait: {
        cover: never[];
        tag: string[];
    };
    wake: {
        cover: string[];
        tag: string[];
    };
    wan: {
        cover: never[];
        tag: string[];
    };
    warn: {
        cover: string[];
        tag: string[];
    };
    web: {
        cover: never[];
        tag: never[];
    };
    while: {
        cover: string[];
        tag: never[];
    };
    wifi: {
        cover: never[];
        tag: string[];
    };
    window: {
        cover: never[];
        tag: never[];
    };
    winphone: {
        cover: string[];
        tag: never[];
    };
    wip: {
        cover: string[];
        tag: string[];
    };
    wireless: {
        cover: never[];
        tag: never[];
    };
    wlan: {
        cover: never[];
        tag: string[];
    };
    woman: {
        cover: never[];
        tag: never[];
    };
    wrap: {
        cover: never[];
        tag: string[];
    };
    write: {
        cover: string[];
        tag: string[];
    };
    wrong: {
        cover: never[];
        tag: never[];
    };
    www: {
        cover: never[];
        tag: string[];
    };
    zsh: {
        cover: never[];
        tag: string[];
    };
};