Oibackoff typing generator (typings don't work)

generator-v2.ts

import * as fs from 'fs';

// Settings
let generics = ['a','b','c','d','e','f','g','h','i'];
let maxParameters = 10;
let parameterName = 'arg';

// File
let fileStream = fs.createWriteStream('index.d.ts');

// Generate the instance
let instanceLines: string[] = [];
for (let maxGeneric = 1; maxGeneric <= generics.length; maxGeneric++) {
    let genericNotation = `<${generics.slice(0, maxGeneric).map(v => v.toUpperCase()).join(',')}>`;
    let callbackNotation = `callback: (${generics.slice(0, maxGeneric).map(v => `${v}: ${v.toUpperCase()}`).join(', ')}) => void`;

    // Loop through each allowed amount of backoff parameters
    for (let maxBackoffParamNumber = 0; maxBackoffParamNumber < maxParameters; maxBackoffParamNumber++) {
        
        // Build the list of backoff parameters
        let backoffParams: string[] = [];
        for (let backoffParamNumber = 0; backoffParamNumber <= maxBackoffParamNumber; backoffParamNumber++) {
            backoffParams.push(`${parameterName}${backoffParamNumber + 1}: any`)
        }

        let immediateArgs: string[] = [];
        immediateArgs.push(`fn: BackoffFunction${generics[maxGeneric - 1].toUpperCase()}${genericNotation}`)
        immediateArgs = immediateArgs.concat(backoffParams);
        immediateArgs.push('intermediate: BackoffIntermediate<A>');
        immediateArgs.push(callbackNotation);
        instanceLines.push(`${genericNotation}(${immediateArgs.join(', ')}): void;`)

        let noImmediateArgs: string[] = [];
        noImmediateArgs.push(`fn: BackoffFunction${generics[maxGeneric - 1].toUpperCase()}${genericNotation}`)
        noImmediateArgs = noImmediateArgs.concat(backoffParams);
        noImmediateArgs.push(callbackNotation);
        instanceLines.push(`${genericNotation}(${noImmediateArgs.join(', ')}): void;`)

    }
}
fileStream.write(`export declare interface BackoffInstance {\n    ${instanceLines.join('\n    ')}\n}\n`);

// Generate the interfaces
let interfaces: string[] = [];
for (let maxGeneric = 1; maxGeneric <= generics.length; maxGeneric++) {
    let genericNotation = `<${generics.slice(0, maxGeneric).map(v => v.toUpperCase()).join(',')}>`;
    let callbackNotation = `callback: (${generics.slice(0, maxGeneric).map(v => `${v}: ${v.toUpperCase()}`).join(', ')}) => void`;
    let lines: string[] = [];
    
    // Loop through each allowed amount of callback parameters
    for (let maxCallbackParamNumber = 0; maxCallbackParamNumber < maxParameters; maxCallbackParamNumber++) {

        // Build the list of callback parameters
        let callbackParams: string[] = [];
        for (let callbackParamNumber = 0; callbackParamNumber < maxCallbackParamNumber; callbackParamNumber++) {
            callbackParams.push(`${parameterName}${callbackParamNumber}: any`)
        }
        callbackParams.push(callbackNotation);

        lines.push(`(${callbackParams.join(', ')}): void;`);

    }
    interfaces.push(`declare interface BackoffFunction${generics[maxGeneric - 1].toUpperCase()}${genericNotation} {\n    ${lines.join('\n    ')}\n}`);
}
fileStream.write(interfaces.join('\n'));

index.d.ts

export declare interface BackoffInstance {
    <A>(fn: BackoffFunctionA<A>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A) => void): void;
    <A>(fn: BackoffFunctionA<A>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B) => void): void;
    <A,B>(fn: BackoffFunctionB<A,B>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C>(fn: BackoffFunctionC<A,B,C>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B, c: C) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D>(fn: BackoffFunctionD<A,B,C,D>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E>(fn: BackoffFunctionE<A,B,C,D,E>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F>(fn: BackoffFunctionF<A,B,C,D,E,F>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G>(fn: BackoffFunctionG<A,B,C,D,E,F,G>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H>(fn: BackoffFunctionH<A,B,C,D,E,F,G,H>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, intermediate: BackoffIntermediate<A>, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    <A,B,C,D,E,F,G,H,I>(fn: BackoffFunctionI<A,B,C,D,E,F,G,H,I>, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, arg9: any, arg10: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
}
declare interface BackoffFunctionA<A> {
    (callback: (a: A) => void): void;
    (arg0: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A) => void): void;
}
declare interface BackoffFunctionB<A,B> {
    (callback: (a: A, b: B) => void): void;
    (arg0: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B) => void): void;
}
declare interface BackoffFunctionC<A,B,C> {
    (callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C) => void): void;
}
declare interface BackoffFunctionD<A,B,C,D> {
    (callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D) => void): void;
}
declare interface BackoffFunctionE<A,B,C,D,E> {
    (callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E) => void): void;
}
declare interface BackoffFunctionF<A,B,C,D,E,F> {
    (callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F) => void): void;
}
declare interface BackoffFunctionG<A,B,C,D,E,F,G> {
    (callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => void): void;
}
declare interface BackoffFunctionH<A,B,C,D,E,F,G,H> {
    (callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => void): void;
}
declare interface BackoffFunctionI<A,B,C,D,E,F,G,H,I> {
    (callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, arg2: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
    (arg0: any, arg1: any, arg2: any, arg3: any, arg4: any, arg5: any, arg6: any, arg7: any, arg8: any, callback: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I) => void): void;
}