/**
  * Decorates states when they are registered
  *
  * Allows you to extend (carefully) or override (at your own peril) the
  * `stateBuilder` object used internally by [[StateRegistry]].
  * This can be used to add custom functionality to ui-router,
  * for example inferring templateUrl based on the state name.
  *
  * When passing only a name, it returns the current (original or decorated) builder
  * function that matches `name`.
  *
  * The builder functions that can be decorated are listed below. Though not all
  * necessarily have a good use case for decoration, that is up to you to decide.
  *
  * In addition, users can attach custom decorators, which will generate new
  * properties within the state's internal definition. There is currently no clear
  * use-case for this beyond accessing internal states (i.e. $state.$current),
  * however, expect this to become increasingly relevant as we introduce additional
  * meta-programming features.
  *
  * **Warning**: Decorators should not be interdependent because the order of
  * execution of the builder functions in non-deterministic. Builder functions
  * should only be dependent on the state definition object and super function.
  *
  *
  * Existing builder functions and current return values:
  *
  * - **parent** `{object}` - returns the parent state object.
  * - **data** `{object}` - returns state data, including any inherited data that is not
  *   overridden by own values (if any).
  * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}
  *   or `null`.
  * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is
  *   navigable).
  * - **params** `{object}` - returns an array of state params that are ensured to
  *   be a super-set of parent's params.
  * - **views** `{object}` - returns a views object where each key is an absolute view
  *   name (i.e. "viewName@stateName") and each value is the config object
  *   (template, controller) for the view. Even when you don't use the views object
  *   explicitly on a state config, one is still created for you internally.
  *   So by decorating this builder function you have access to decorating template
  *   and controller properties.
  * - **ownParams** `{object}` - returns an array of params that belong to the state,
  *   not including any params defined by ancestor states.
  * - **path** `{string}` - returns the full path from the root down to this state.
  *   Needed for state activation.
  * - **includes** `{object}` - returns an object that includes every state that
  *   would pass a `$state.includes()` test.
  *
  * #### Example:
  * Override the internal 'views' builder with a function that takes the state
  * definition, and a reference to the internal function being overridden:
  * ```js
  * $stateProvider.decorator('views', function (state, parent) {
  *   let result = {},
  *       views = parent(state);
  *
  *   angular.forEach(views, function (config, name) {
  *     let autoName = (state.name + '.' + name).replace('.', '/');
  *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
  *     result[name] = config;
  *   });
  *   return result;
  * });
  *
  * $stateProvider.state('home', {
  *   views: {
  *     'contact.list': { controller: 'ListController' },
  *     'contact.item': { controller: 'ItemController' }
  *   }
  * });
  * ```
  *
  *
  * ```js
  * // Auto-populates list and item views with /partials/home/contact/list.html,
  * // and /partials/home/contact/item.html, respectively.
  * $state.go('home');
  * ```
  *
  * @param {string} name The name of the builder function to decorate.
  * @param {object} func A function that is responsible for decorating the original
  * builder function. The function receives two parameters:
  *
  *   - `{object}` - state - The state config object.
  *   - `{object}` - super - The original builder function.
  *
  * @return {object} $stateProvider - $stateProvider instance
  */
 decorator(name: string, func: BuilderFunction) {
   return this.stateRegistry.decorator(name, func) || this;
 }

 state(name: any, definition?: any) {
   if (isObject(name)) {
     definition = name;
   } else {
     definition.name = name;
   }
   this.stateRegistry.register(definition);
   return this;
 }