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

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

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

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

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 erase(self: var Dictionary; key: Variant): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

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

proc get(self: 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 getTypedKeyClassName(self: Dictionary): StringName {....raises: [],
    tags: [RootEffect], forbids: [].}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

proc keys(self: 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 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: [].}

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

proc recursiveEqual(self: 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 sort(self: var Dictionary): void {....raises: [], tags: [RootEffect],
                                        forbids: [].}

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

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