proc abs(x: Variant): Variant {....raises: [], tags: [RootEffect], forbids: [].}

proc angleDifference(from: Float; to: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc bezierDerivative(start: Float; control1: Float; control2: Float;
                      end: Float; t: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc bezierInterpolate(start: Float; control1: Float; control2: Float;
                       end: Float; t: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc bytesToVar(bytes: PackedByteArray): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc bytesToVarWithObjects(bytes: PackedByteArray): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc ceil(x: Variant): Variant {....raises: [], tags: [RootEffect], forbids: [].}

proc clamp(value: Variant; min: Variant; max: Variant): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc cubicInterpolateAngleInTime(from: Float; to: Float; pre: Float;
                                 post: Float; weight: Float; toT: Float;
                                 preT: Float; postT: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc cubicInterpolateInTime(from: Float; to: Float; pre: Float; post: Float;
                            weight: Float; toT: Float; preT: Float; postT: Float): Float {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc dbToLinear(db: Float): Float {....raises: [], tags: [RootEffect], forbids: [].}

proc ease(x: Float; curve: Float): Float {....raises: [], tags: [RootEffect],
    forbids: [].}

proc errorString(error: Int): String {....raises: [], tags: [RootEffect],
                                       forbids: [].}

proc floor(x: Variant): Variant {....raises: [], tags: [RootEffect], forbids: [].}

proc instanceFromId(instanceId: Int): Object {....raises: [], tags: [RootEffect],
    forbids: [].}

proc inverseLerp(from: Float; to: Float; weight: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc isInstanceIdValid(id: Int): bool {....raises: [], tags: [RootEffect],
                                        forbids: [].}

proc isInstanceValid(instance: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc isSame(a: Variant; b: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc lerp(from: Variant; to: Variant; weight: Variant): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc linearToDb(lin: Float): Float {....raises: [], tags: [RootEffect], forbids: [].}

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

proc max(arg1: Variant; arg2: Variant; args: varargs[Variant, variant]): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc min(arg1: Variant; arg2: Variant; args: varargs[Variant, variant]): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc moveToward(from: Float; to: Float; delta: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc pingpong(value: Float; length: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc print(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc printerr(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc printraw(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc printRich(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc prints(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc printt(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc printVerbose(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc pushError(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc pushWarning(args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc randf(): Float {....raises: [], tags: [RootEffect], forbids: [].}

proc randfn(mean: Float; deviation: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc randfRange(from: Float; to: Float): Float {....raises: [], tags: [RootEffect],
    forbids: [].}

proc randFromSeed(seed: Int): PackedInt64Array {....raises: [], tags: [RootEffect],
    forbids: [].}

proc randi(): Int {....raises: [], tags: [RootEffect], forbids: [].}

proc randiRange(from: Int; to: Int): Int {....raises: [], tags: [RootEffect],
    forbids: [].}

proc randomize(): void {....raises: [], tags: [RootEffect], forbids: [].}

proc remap(value: Float; istart: Float; istop: Float; ostart: Float;
           ostop: Float): Float {....raises: [], tags: [RootEffect], forbids: [].}

proc ridAllocateId(): Int {....raises: [], tags: [RootEffect], forbids: [].}

proc ridFromInt64(base: Int): RID {....raises: [], tags: [RootEffect], forbids: [].}

proc rotateToward(from: Float; to: Float; delta: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc round(x: Variant): Variant {....raises: [], tags: [RootEffect], forbids: [].}

proc seed(base: Int): void {....raises: [], tags: [RootEffect], forbids: [].}

proc sign(x: Variant): Variant {....raises: [], tags: [RootEffect], forbids: [].}

proc smoothstep(from: Float; to: Float; x: Float): Float {....raises: [],
    tags: [RootEffect], forbids: [].}

proc snapped(x: Variant; step: Variant): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc stepDecimals(x: Float): Int {....raises: [], tags: [RootEffect], forbids: [].}

proc str(args: varargs[Variant, variant]): String {....raises: [],
    tags: [RootEffect], forbids: [].}

proc strToVar(string: String): Variant {....raises: [], tags: [RootEffect],
    forbids: [].}

proc typeConvert(variant: Variant; type: Int): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc typeof(variable: Variant): Int {....raises: [], tags: [RootEffect],
                                      forbids: [].}

proc typeString(type: Int): String {....raises: [], tags: [RootEffect], forbids: [].}

proc varToBytes(variable: Variant): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}

proc varToBytesWithObjects(variable: Variant): PackedByteArray {....raises: [],
    tags: [RootEffect], forbids: [].}

proc varToStr(variable: Variant): String {....raises: [], tags: [RootEffect],
    forbids: [].}

proc weakref(obj: Variant): Variant {....raises: [], tags: [RootEffect],
                                      forbids: [].}

proc wrap(value: Variant; min: Variant; max: Variant): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}