/**
   * Return all endpoints from the given class. This method doesn't return the endpoints from the parent of the given class.
   * @param {Type<any>} target
   * @returns {any}
   */
  static getOwnEndpoints(target: Type<any>) {
    if (!this.hasEndpoints(target)) {
      Metadata.set("endpoints", [], target);
    }

    return Metadata.getOwn("endpoints", target);
  }

  /**
   * Get an endpoint.
   * @param target
   * @param method
   */
  static get(target: Type<any>, method: string): EndpointMetadata {
    if (!this.has(target, method)) {
      const endpoint = new EndpointMetadata(target, method);
      this.getOwnEndpoints(target).push(endpoint);
      Metadata.set("endpoints", endpoint, target, method);
    }

    return Metadata.getOwn("endpoints", target, method);
  }

  /**
   *
   * @param target
   * @param propertyKey
   * @param property
   */
  static set(target: Type<any>, propertyKey: string | symbol, property: PropertyMetadata): void {
    const properties = this.getOwnProperties(target);

    properties.set(propertyKey, property);

    Metadata.set(PROPERTIES_METADATA, properties, target);
  }

  return (target: any, propertyKey: string, index: number) => {
    const store = Store.from(target);
    const type = Metadata.getParamTypes(target, propertyKey)[index];
    const param = {
      filter: SocketFilters.ARGS,
      useConverter: false
    };

    if (mapIndex !== undefined) {
      Object.assign(param, {
        mapIndex,
        useConverter: true,
        type: useType || type,
        collectionType: isCollection(type) ? type : undefined
      });
    }

    return store.merge("socketIO", {
      handlers: {
        [propertyKey]: {
          parameters: {
            [index]: param
          }
        }
      }
    });
  };

  return (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<Function> | number): any => {
    const bindingType = getDecoratorType([target, propertyKey, descriptor], true);

    switch (bindingType) {
      case "parameter":
      case "parameter.constructor":
        if (symbol) {
          const paramTypes = Metadata.getParamTypes(target, propertyKey);

          paramTypes[descriptor as number] = symbol;
          Metadata.setParamTypes(target, propertyKey, paramTypes);
        }
        break;

      case "property":
        Store.from(target).merge("injectableProperties", {
          [propertyKey]: {
            bindingType,
            propertyKey,
            useType: symbol || Metadata.getType(target, propertyKey)
          }
        });
        break;

      case "method":
        Store.from(target).merge("injectableProperties", {
          [propertyKey]: {
            bindingType,
            propertyKey
          }
        });

        return descriptor;

      default:
        throw new UnsupportedDecoratorType(Inject, [target, propertyKey, descriptor]);
    }
  };

    before(() => {
      this.endpointMetadata = new EndpointMetadata(Test, "method");

      this.endpointMetadata.path = "/";
      this.endpointMetadata.httpMethod = "get";
      this.endpointMetadata.beforeMiddlewares = [() => {}];
      this.endpointMetadata.middlewares = [() => {}];
      this.endpointMetadata.afterMiddlewares = [() => {}];
      this.endpointMetadata.before([() => {}]);
      this.endpointMetadata.after([() => {}]);

      EndpointRegistry.store(Test, "method").set("test", "value");

      Metadata.set("design:returntype", Object, Test, "method");

      this.store = {};
      this.endpointMetadata.store.forEach((v: any, k: any) => (this.store[k] = v));
    });

  before(() => {
    class TestServer extends ServerLoader {
      $onInit() {
      }

      $onReady() {
      }

      $onMountingMiddlewares() {
      }

      $afterRoutesInit() {
      }
    }

    Metadata.set(SERVER_SETTINGS, {debug: true, port: 8000, httpsPort: 8080}, TestServer);

    this.server = new TestServer();
    this.server.settings.httpPort = 8080;
    this.server.settings.httpsPort = 8000;
    this.useStub = Sinon.stub(this.server.expressApp, "use");
    this.setStub = Sinon.stub(this.server.expressApp, "set");
    this.engineStub = Sinon.stub(this.server.expressApp, "engine");
  });

 /**
  * Gets a value indicating whether the target object or its prototype chain has already method registered.
  * @param target
  * @param method
  */
 static has(target: Type<any>, method: string): boolean {
   return Metadata.hasOwn("endpoints", target, method);
 }

 /**
  * Gets a value indicating whether the target object or its prototype chain has endpoints.
  * @param {Type<any>} target
  * @returns {boolean}
  */
 static hasEndpoints(target: Type<any>) {
   return Metadata.hasOwn("endpoints", target);
 }

 /**
  *
  * @param {Type<any>} target
  * @returns {Map<string | symbol, PropertyMetadata>}
  */
 static getOwnProperties(target: Type<any>): Map<string | symbol, PropertyMetadata> {
   return Metadata.hasOwn(PROPERTIES_METADATA, target)
     ? Metadata.getOwn(PROPERTIES_METADATA, target)
     : new Map<string | symbol, PropertyMetadata>();
 }