code: function createTypedBindable(type) {
      /**
       * There no attempts to protect user from mis-using the decorators.
       * ex. @observable({}, accidentParam) class SomeClass {}
       * If we have some flag to use in if block, which can be remove at build time, it would be great.
       */
      return bindable[type] = function (nameOrTargetOrConfig, key, descriptor) {
          if (nameOrTargetOrConfig === undefined) {
              /**
               * MyClass {
               *   @bindable.number() num
               * }
               */
              return bindable({ coerce: type });
          }
          if (key === undefined) {
              /**
               * @bindable.number('num')
               * class MyClass {}
               *
               * @bindable.number({...})
               * class MyClass
               *
               * class MyClass {
               *   @bindable.number({...})
               *   num
               * }
               */
              nameOrTargetOrConfig = typeof nameOrTargetOrConfig === 'string' ? { name: nameOrTargetOrConfig } : nameOrTargetOrConfig;
              nameOrTargetOrConfig.coerce = type;
              return bindable(nameOrTargetOrConfig);
          }
          /**
           * class MyClass {
           *   @bindable.number num
           * }
           */
          return bindable({ coerce: type })(nameOrTargetOrConfig, key, descriptor);
      };
  }
docs: Create a new fluent syntax bindable decorator  ex: builtin: `@bindable.string`, custom: `@bindable.customType`
  Need to use together with setting the type in `coerceFunctions`:
  
  ```js
  import {
  createTypedBindable,
  coerceFunctions
  } from 'aurelia-framework'
  
  // create the typed bindable
  createTypedBindable('point'); // => enable `@bindable.point`
  // Set the instruction
  coerceFunctions.point = function(value: string) {
  // convert to point from value
  }
  ```
  
  @param type The type to added to bindable for fluent syntax.