public static getInstanceDetails(account: string, region: string, id: string): IPromise<IInstance> {
   return API.one('instances')
     .one(account)
     .one(region)
     .one(id)
     .get();
 }

 private static waitUntilTaskIsDeleted(taskId: string): IPromise<void> {
   // wait until the task is gone, i.e. the promise from the get() is rejected, before succeeding
   const deferred = $q.defer<void>();
   API.one('tasks', taskId)
     .get()
     .then(
       () => {
         $timeout(
           () => {
             // task is still present, try again
             this.waitUntilTaskIsDeleted(taskId).then(() => deferred.resolve());
           },
           1000,
           false,
         );
       },
       (resp: IHttpPromiseCallbackArg<any>) => {
         if (resp.status === 404) {
           // task is no longer present
           deferred.resolve();
         } else {
           $timeout(
             () => {
               // task is maybe still present, try again
               this.waitUntilTaskIsDeleted(taskId).then(deferred.resolve);
             },
             1000,
             false,
           );
         }
       },
     );
   return deferred.promise;
 }

 return $q((resolve, reject) => {
   API.one('v2')
     .one('pipelineTemplates')
     .one('create')
     .post(template)
     .then(resolve, reject);
 });

  public static search<T extends ISearchResult>(
    searchParams: ISearchParams,
    cache: ICache = null,
  ): IPromise<ISearchResults<T>> {
    const defaultParams: ISearchParams = {
      pageSize: SearchService.DEFAULT_PAGE_SIZE,
    };

    const params = { ...searchParams, ...defaultParams };

    const requestBuilder = API.one('search').withParams(params);

    if (cache) {
      requestBuilder.useCache(cache);
    }

    return requestBuilder
      .get()
      .then((response: Array<ISearchResults<T>>) => {
        return response[0] || getFallbackResults();
      })
      .catch((response: IHttpPromiseCallbackArg<any>) => {
        $log.error(response.data, response);
        return getFallbackResults();
      });
  }

 public static getManifest(account: string, location: string, name: string): IPromise<IManifest> {
   return API.all('manifests')
     .all(account)
     .all(location)
     .one(name)
     .get();
 }

 public static listJobsForMaster(master: string): IPromise<string[]> {
   return API.one('v2')
     .one('builds')
     .one(master)
     .one('jobs')
     .get();
 }

 this.accounts$ = Observable.defer(() => {
   const promise = API.one('credentials')
     .useCache()
     .withParams({ expand: true })
     .get();
   return Observable.fromPromise<IAccountDetails[]>(promise);
 })

 public getAllSecurityGroups(): IPromise<ISecurityGroupsByAccountSourceData> {
   // Because these are cached in local storage, we unfortunately need to remove the moniker, as it triples the size
   // of the object being stored, which blows out our LS quota for a sufficiently large footprint
   const cache = InfrastructureCaches.get('securityGroups');
   const cached = !!cache ? cache.get('allGroups') : null;
   if (cached) {
     return this.$q.resolve(cached);
   }
   return API.one('securityGroups')
     .useCache()
     .get()
     .then((groupsByAccount: ISecurityGroupsByAccountSourceData) => {
       Object.keys(groupsByAccount).forEach(account => {
         Object.keys(groupsByAccount[account]).forEach(provider => {
           Object.keys(groupsByAccount[account][provider]).forEach(region => {
             groupsByAccount[account][provider][region].forEach(group => {
               delete group.moniker;
             });
           });
         });
       });
       if (cache) {
         cache.put('allGroups', groupsByAccount);
       }
       return groupsByAccount;
     });
 }

 public static getArtifactNames(type: string, accountName: string): IPromise<string[]> {
   return API.one('artifacts')
     .one('account')
     .one(accountName)
     .one('names')
     .withParams({ type: type })
     .get();
 }

 public static getJobConfig(master: string, job: string): IPromise<IJobConfig> {
   return API.one('v2')
     .one('builds')
     .one(master)
     .one('jobs')
     .one(job)
     .get();
 }