func `==`(left: Dictionary; right: Dictionary): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc `[]`(self: Dictionary; key: SomeProperty): Variant

proc `[]`(self: Dictionary; key: Variant): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc `[]`(self: var Dictionary; key: SomeProperty): var Variant

proc `[]`(self: var Dictionary; key: Variant): var Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc `[]=`(self: var Dictionary; key: SomeProperty; value: sink Variant)

proc `[]=`(self: var Dictionary; key: Variant; value: sink Variant) {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc `[]=`[A, B: SomeProperty](self: var Dictionary; key: A; value: sink B)

proc assign(self: var Dictionary; dictionary: Dictionary): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc clear(self: var Dictionary): void {....raises: [], tags: [RootEffect],
    forbids: [].}

proc contains[T: SomeProperty](dict: Dictionary; value: T): bool

proc duplicate(self: Dictionary; deep: bool = false): Dictionary {....raises: [],
    tags: [RootEffect], forbids: [].}

proc duplicate(self: var Dictionary; deep: bool = false): Dictionary {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc erase(self: var Dictionary; key: Variant): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc findKey(self: Dictionary; value: Variant): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc findKey(self: var Dictionary; value: Variant): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc get(self: Dictionary; key: Variant; default: Variant = default(Variant)): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc get(self: var Dictionary; key: Variant; default: Variant = default(Variant)): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc getOrAdd(self: var Dictionary; key: Variant;
              default: Variant = default(Variant)): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedKeyBuiltin(self: Dictionary): Int {....raises: [], tags: [RootEffect],
    forbids: [].}

proc getTypedKeyBuiltin(self: var Dictionary): Int {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedKeyClassName(self: Dictionary): StringName {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedKeyClassName(self: var Dictionary): StringName {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedKeyScript(self: Dictionary): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedKeyScript(self: var Dictionary): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedValueBuiltin(self: Dictionary): Int {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedValueBuiltin(self: var Dictionary): Int {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedValueClassName(self: Dictionary): StringName {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedValueClassName(self: var Dictionary): StringName {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedValueScript(self: Dictionary): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getTypedValueScript(self: var Dictionary): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc has(self: Dictionary; key: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc has(self: var Dictionary; key: Variant): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc hasAll(self: Dictionary; keys: Array): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc hasAll(self: var Dictionary; keys: Array): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

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

proc hash(self: var Dictionary): Hash {....raises: [], tags: [RootEffect],
                                        forbids: [].}

proc isEmpty(self: Dictionary): bool {....raises: [], tags: [RootEffect],
                                       forbids: [].}

proc isEmpty(self: var Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isReadOnly(self: Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isReadOnly(self: var Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isSameTyped(self: Dictionary; dictionary: Dictionary): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc isSameTyped(self: var Dictionary; dictionary: Dictionary): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc isSameTypedKey(self: Dictionary; dictionary: Dictionary): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc isSameTypedKey(self: var Dictionary; dictionary: Dictionary): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc isSameTypedValue(self: Dictionary; dictionary: Dictionary): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc isSameTypedValue(self: var Dictionary; dictionary: Dictionary): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc isTyped(self: Dictionary): bool {....raises: [], tags: [RootEffect],
                                       forbids: [].}

proc isTyped(self: var Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isTypedKey(self: Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isTypedKey(self: var Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isTypedValue(self: Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isTypedValue(self: var Dictionary): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc keys(self: Dictionary): Array {....raises: [], tags: [RootEffect], forbids: [].}

proc keys(self: var Dictionary): Array {....raises: [], tags: [RootEffect],
    forbids: [].}

proc makeReadOnly(self: var Dictionary): void {....raises: [], tags: [RootEffect],
    forbids: [].}

proc merge(self: var Dictionary; dictionary: Dictionary; overwrite: bool = false): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc merged(self: Dictionary; dictionary: Dictionary; overwrite: bool = false): Dictionary {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc merged(self: var Dictionary; dictionary: Dictionary;
            overwrite: bool = false): Dictionary {....raises: [],
    tags: [RootEffect], forbids: [].}

proc newDictionary(): Dictionary {....raises: [], tags: [RootEffect], forbids: [].}

proc newDictionary(base: Dictionary; keyType: Int; keyClassName: StringName;
                   keyScript: Variant; valueType: Int;
                   valueClassName: StringName; valueScript: Variant): Dictionary {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc newDictionary(from: Dictionary): Dictionary {....raises: [],
    tags: [RootEffect], forbids: [].}

proc newDictionary(table: Table): Dictionary

proc newDictionary(table: TableRef): Dictionary

proc newDictionary[A, B](pairs: openArray[(A, B)]): Dictionary

func `not`(left: Dictionary): bool {....raises: [], tags: [RootEffect], forbids: [].}

proc recursiveEqual(self: Dictionary; dictionary: Dictionary;
                    recursionCount: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc recursiveEqual(self: var Dictionary; dictionary: Dictionary;
                    recursionCount: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc set(self: var Dictionary; key: Variant; value: Variant): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc size(self: Dictionary): Int {....raises: [], tags: [RootEffect], forbids: [].}

proc size(self: var Dictionary): Int {....raises: [], tags: [RootEffect],
                                       forbids: [].}

proc sort(self: var Dictionary): void {....raises: [], tags: [RootEffect],
                                        forbids: [].}

proc values(self: Dictionary): Array {....raises: [], tags: [RootEffect],
                                       forbids: [].}

proc values(self: var Dictionary): Array {....raises: [], tags: [RootEffect],
    forbids: [].}

iterator keys(self: Dictionary): Variant {....raises: [], tags: [RootEffect],
    forbids: [].}

iterator mpairs(self: var Dictionary): tuple[key: Variant, item: var Variant] {.
    ...raises: [], tags: [RootEffect], forbids: [].}

iterator mvalues(self: var Dictionary): var Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

iterator pairs(self: Dictionary): tuple[key, item: Variant] {....raises: [],
    tags: [RootEffect], forbids: [].}

iterator values(self: Dictionary): Variant {....raises: [], tags: [RootEffect],
    forbids: [].}

template dictionary(args: varargs[untyped]): untyped {.
    ...deprecated: "use newDictionary instead".}

template nilCheck(self: Dictionary)

template nilCheck(self: var Dictionary)