(item: DimItem, store: DimStore, equip: boolean, amount: number) => {
    const reload = item.equipped || equip;
    let promise: IPromise<any> = dimItemService.moveTo(item, store, equip, amount);

    if (reload) {
      // Refresh light levels and such
      promise = promise.then((item: DimItem) => {
        return item
          .getStoresService()
          .updateCharacters()
          .then(() => item);
      });
    }

    promise = promise.then((item: DimItem) => item.updateManualMoveTimestamp()).catch((e) => {
      toaster.pop('error', item.name, e.message);
      console.error('error moving item', item.name, 'to', store.name, e);
      // Some errors aren't worth reporting
      if (
        e.code !== 'wrong-level' &&
        e.code !== 'no-space' &&
        e.code !== 1671 /* PlatformErrorCodes.DestinyCannotPerformActionAtThisLocation */
      ) {
        reportException('moveItem', e);
      }
    });

    loadingTracker.addPromise(promise);

    return promise;
  }

export const consolidate = queuedAction((actionableItem: DimItem, store: DimStore) => {
  const stores = _.filter(actionableItem.getStoresService().getStores(), (s) => {
    return !s.isVault;
  });
  const vault = actionableItem.getStoresService().getVault()!;

  let promise: IPromise<any> = $q.all(
    stores.map((s) => {
      // First move everything into the vault
      const item = _.find(s.items, (i) => {
        return store.id !== i.owner && i.hash === actionableItem.hash && !i.location.inPostmaster;
      });
      if (item) {
        const amount = s.amountOfItem(actionableItem);
        return dimItemService.moveTo(item, vault, false, amount);
      }
      return $q.when();
    })
  );

  // Then move from the vault to the character
  if (!store.isVault) {
    promise = promise.then(
      (): IPromise<any> | undefined => {
        const item = vault.items.find(
          (i) => i.hash === actionableItem.hash && !i.location.inPostmaster
        );
        if (item) {
          const amount = vault.amountOfItem(actionableItem);
          return dimItemService.moveTo(item, store, false, amount);
        }
        return undefined;
      }
    );
  }

  promise = promise
    .then(() => {
      let message;
      if (store.isVault) {
        message = t('ItemMove.ToVault', {
          name: actionableItem.name
        });
      } else {
        message = t('ItemMove.ToStore', {
          name: actionableItem.name,
          store: store.name
        });
      }
      toaster.pop('success', t('ItemMove.Consolidate', { name: actionableItem.name }), message);
    })
    .catch((a) => {
      toaster.pop('error', actionableItem.name, a.message);
      console.log('error consolidating', actionableItem, a);
    });

  loadingTracker.addPromise(promise);

  return promise;
});

 public listMasters(type: BuildServiceType = null): IPromise<string[]> {
   const allMasters: IPromise<string[]> = this.API.one('v2').one('builds').get();
   if (!allMasters) {
     return this.$q.reject('An error occurred when retrieving build masters');
   }
   switch (type) {
     case BuildServiceType.Jenkins:
       return allMasters.then(masters => masters.filter(master => !(/^travis-/.test(master))));
     case BuildServiceType.Travis:
       return allMasters.then(masters => masters.filter(master => /^travis-/.test(master)));
     default:
       return allMasters;
   }
 }

  function dequipItem(item: DimItem, excludeExotic = false): IPromise<DimItem> {
    const storeService = getStoreService(item);
    const similarItem = getSimilarItem(item, [], excludeExotic);
    if (!similarItem) {
      return $q.reject(new Error($i18next.t('ItemService.Deequip', { itemname: item.name })));
    }
    const source = storeService.getStore(item.owner)!;
    const target = storeService.getStore(similarItem.owner)!;

    let p: IPromise<DimItem> = $q.when();
    if (source.id !== target.id) {
      p = moveTo(similarItem, source, true);
    }

    return p
      .then(() => equipItem(similarItem))
      .then(() => item);
  }

 public static listMasters(buildType: BuildServiceType = null): IPromise<string[]> {
   const allMasters: IPromise<string[]> = API.one('v2')
     .one('builds')
     .withParams({ type: buildType })
     .get();
   if (!allMasters) {
     return $q.reject('An error occurred when retrieving build masters');
   }
   switch (buildType) {
     case BuildServiceType.Jenkins:
       return allMasters.then(masters => masters.filter(master => !/^travis-/.test(master)));
     case BuildServiceType.Travis:
       return allMasters.then(masters => masters.filter(master => /^travis-/.test(master)));
     case BuildServiceType.Concourse:
       return allMasters.then(masters => masters.filter(master => /^concourse-/.test(master)));
     default:
       return allMasters;
   }
 }

  /**
   * Check whether this transfer can happen. If necessary, make secondary inventory moves
   * in order to make the primary transfer possible, such as making room or dequipping exotics.
   */
  function isValidTransfer(
    equip: boolean,
    store: DimStore,
    item: DimItem,
    amount: number,
    excludes?: DimItem[],
    reservations?: MoveReservations
  ): IPromise<any> {
    let promise: IPromise<any> = $q.when();

    if (equip) {
      promise = promise.then(() => canEquip(item, store));
      if (item.equippingLabel) {
        promise = promise.then(() => canEquipExotic(item, store));
      }
    }

    return promise.then(() => canMoveToStore(item, store, amount, { excludes, reservations }));
  }

 // interval is in milliseconds
 public static buildRetrySequence<T>(
   func: () => T | IPromise<T>,
   stopCondition: (results: T) => boolean,
   limit: number,
   interval: number,
 ): IPromise<T> {
   const call: T | IPromise<T> = func();
   const promise: IPromise<T> = call.hasOwnProperty('then') ? (call as IPromise<T>) : $q.resolve(call);
   if (limit === 0) {
     return promise;
   } else {
     return promise
       .then((result: T) => {
         if (stopCondition(result)) {
           return result;
         } else {
           return $timeout(interval).then(() => this.buildRetrySequence(func, stopCondition, limit - 1, interval));
         }
       })
       .catch(() => $timeout(interval).then(() => this.buildRetrySequence(func, stopCondition, limit - 1, interval)));
   }
 }

        function applyConfig () {
          optionsAlreadyRead.then(function () {
            checkSelection();
            updateNgModel();
            checkConfig(scope.config, setViewValue);
            controller.$validate();
          });

          if (!configRead) {
            updateStaticTexts();
            configRead = true;
          }
        }

        function render () {
          optionsAlreadyRead.then(function () {
            ngModelAlreadyRead = true;

            let viewValue = controller.$viewValue;

            setSelected(internalOptions, false);

            let i = viewValue.length;
            while (i--) {
              let trackingId = value2trackingId(viewValue[i], w11kSelectHelper, optionsExpParsed);
              let option = internalOptionsMap[trackingId];

              if (option) {
                option.state = OptionState.selected;
              }
            }

            updateHeader();
          });
        }