declare module 'factory-girl' {
  export const factory: typeof FactoryGirl;

  export class Generator {
    constructor(factoryGirl: FactoryGirl);
    generate: any;
    getAttribute: <T>(name: string, model: T, key: string) => any;
  }

  export class ChanceGenerator extends Generator {
    generate: (chanceMethod: string, ...options: any[]) => any;
  }

  export class Factory {}

  export class FactoryGirl {
    static FactoryGirl: new () => FactoryGirl;

    constructor(options?: object);
    chance: ChanceGenerator['generate'];

    // TODO: allow for a function inititalizer
    define<T, D = {}>(
      name: string,
      Model: any,
      initializer?:
        | { [P in keyof T]: any }
        | ((options: D) => { [P in keyof T]: any }),
      buildOptions?: D
    ): Factory;

    create<T, I = any, D = {}>(
      name: string,
      attrs?: Partial<I>,
      buildOptions?: D
    ): Promise<T>;

    createMany<T, I = amy, D = {}>(
      name: string,
      num: number,
      attrs?: Partial<I>,
      buildOptions?: D
    ): Promise<T[]>;

    build<T, I = any, D = {}>(
      name: string,
      attrs?: Partial<I>,
      buildOptions?: D
    ): Promise<T>;

    assoc<T>(
      name: string,
      key?: keyof T,
      attrs?: Partial<T> | {},
      buildOptions?: object
    ): any;

    assocMany<T>(
      name: string,
      count: number,
      key?: keyof T | null,
      attrs?: Partial<T> | {},
      buildOptions?: object
    ): T[];

    assocAttrs<T>(
      name: string,
      key?: keyof T | null,
      attrs?: Partial<T> | {},
      buildOptions?: object
    ): T;

    assocAttrsMany<T>(
      name: string,
      count: number,
      key?: keyof T | null,
      attrs?: Partial<T> | {},
      buildOptions?: object
    ): T[];

    setAdapter(adapter: Adapter, name?: string): Adapter;
    cleanUp(): Promise<any>;
  }

  export class DefaultAdapter {
    build<C, T>(Model: C, props: T): C;
    save(model: any, Model: any): Promise<any>;
    destroy(model: any, Model: any): Promise<any>;
    get: <T, I extends keyof T, C>(model: T, attr: I, Model: C) => I;
    set: <T, I extends keyof T, C>(props: I, model: T, Model: C) => T;
  }

  export class MongooseAdapter extends DefaultAdapter {}
}