return function (target: any) {

        let currentMetadata: interfaces.ControllerMetadata = {
            middleware: middleware,
            path: path,
            target: target
        };

        decorate(injectable(), target);
        Reflect.defineMetadata(METADATA_KEY.controller, currentMetadata, target);

        // We need to create an array that contains the metadata of all
        // the controllers in the application, the metadata cannot be
        // attached to a controller. It needs to be attached to a global
        // We attach metadata to the Reflect object itself to avoid
        // declaring additonal globals. Also, the Reflect is avaiable
        // in both node and web browsers.
        const previousMetadata: interfaces.ControllerMetadata[] = Reflect.getMetadata(
            METADATA_KEY.controller,
            Reflect
        ) || [];

        const newMetadata = [currentMetadata, ...previousMetadata];

        Reflect.defineMetadata(
            METADATA_KEY.controller,
            newMetadata,
            Reflect
        );

    };

  return function (target: any) {

    const isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_METADATA_KEY.PARAM_TYPES, target);
    const redecorateWithInject = force === true;

    if (redecorateWithInject === true && isAlreadyDecorated === false) {
      decorate(injectable(), target);
    } else if (redecorateWithInject === true && isAlreadyDecorated === true) {
      // Do nothing
    } else {
      try {
        decorate(injectable(), target);
      } catch (e) {
        throw new Error(
          "Cannot apply @provide decorator multiple times but is has been used " +
          `multiple times in ${target.name} ` +
          "Please use @provide(ID, true) if you are trying to declare multiple bindings!"
        );
      }
    }

    const currentMetadata: interfaces.ProvideSyntax = {
      constraint: (bind: inversifyInterfaces.Bind, bindTarget: any) => bind(serviceIdentifier).to(bindTarget),
      implementationType: target
    };

    const previousMetadata: interfaces.ProvideSyntax[] = Reflect.getMetadata(
      METADATA_KEY.provide,
      Reflect
    ) || [];

    const newMetadata = [currentMetadata, ...previousMetadata];

    Reflect.defineMetadata(
      METADATA_KEY.provide,
      newMetadata,
      Reflect
    );
    return target;

  };

import { Container, interfaces, decorate, injectable } from 'inversify'
import { autoProvide, makeFluentProvideDecorator, makeProvideDecorator } from 'inversify-binding-decorators'
import { Controller } from 'tsoa'

const iocContainer = new Container()

const provide = makeProvideDecorator(iocContainer)
const fluentProvider = makeFluentProvideDecorator(iocContainer)

const provideNamed = (
  identifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>,
  name: string,
) => {
    return fluentProvider(identifier)
      .whenTargetNamed(name)
      .done()
}

const provideSingleton = (
  identifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>,
) => {
    return fluentProvider(identifier)
      .inSingletonScope()
      .done()
}

// Needed to make controller injectable for extended Singleton class
decorate(injectable(), Controller)

export { iocContainer, autoProvide, provide, provideSingleton, provideNamed }

 return function (target: any) {
     decorate(injectable(), target);
     Reflect.defineMetadata("prettygoat:method", method, target);
     Reflect.defineMetadata("prettygoat:path", path, target);
     return target;
 };

} from './types';
import JsonConfigStore from './JsonConfigStore';
import QuoteAggregator from './QuoteAggregator';
import PositionService from './PositionService';
import BrokerAdapterRouter from './BrokerAdapterRouter';
import SpreadAnalyzer from './SpreadAnalyzer';
import ConfigValidator from './ConfigValidator';
import LimitCheckerFactory from './LimitCheckerFactory';
import { getActivePairStore } from './ActivePairLevelStore';
import { getChronoDB } from './chrono';
import OppotunitySearcher from './OpportunitySearcher';
import PairTrader from './PairTrader';
import SingleLegHandler from './SingleLegHandler';
import { EventEmitter } from 'events';

decorate(injectable(), EventEmitter);

const container = new Container();
container.bind<Arbitrager>(Arbitrager).toSelf();
container
  .bind<ConfigStore>(symbols.ConfigStore)
  .to(JsonConfigStore)
  .inSingletonScope();
container
  .bind<QuoteAggregator>(QuoteAggregator)
  .toSelf()
  .inSingletonScope();
container
  .bind<PositionService>(PositionService)
  .toSelf()
  .inSingletonScope();

 return function (target: any) {
     decorate(injectable(), target);
     Reflect.defineMetadata("ninjagoat:viewmodel", name, target);
     return target;
 };

 Object.keys(module).forEach((key) => {
   let entity = module[key];
   let decorator = provide(entity);
   decorate(decorator, entity);
 });