@spinnaker/core 2026.2.2 → 2026.3.0

package/src/filterModel/FilterModelService.spec.ts

@@ -0,0 +1,34 @@
+import { setDirectRouter } from '../navigation/directRouter';
+import { FilterModelService } from './FilterModelService';
+import type { IFilterConfig, IFilterModel } from './IFilterModel';
+
+describe('FilterModelService direct router integration', () => {
+  afterEach(() => {
+    setDirectRouter(null);
+  });
+
+  it('registers shared filter hooks and hydrates permalink params', () => {
+    const onBefore = jasmine.createSpy('onBefore');
+    const onStart = jasmine.createSpy('onStart');
+    const onSuccess = jasmine.createSpy('onSuccess');
+    const stateGlob = '**.application.insight.test.**';
+    const router = { transitionService: { onBefore, onStart, onSuccess } };
+    const config: IFilterConfig[] = [
+      { model: 'account', param: 'acct', type: 'trueKeyObject' },
+      { model: 'filter', param: 'q', type: 'string' },
+    ];
+    const filterModel = FilterModelService.configureFilterModel({} as IFilterModel, config);
+    setDirectRouter(router as any);
+
+    FilterModelService.registerRouterHooks(filterModel, stateGlob);
+
+    expect(onSuccess).toHaveBeenCalledWith({ exiting: stateGlob, retained: '**.application' }, jasmine.any(Function));
+    expect(onBefore).toHaveBeenCalledWith({ entering: stateGlob, retained: '**.application' }, jasmine.any(Function));
+    expect(onStart).toHaveBeenCalledWith({ exiting: '**.application' }, jasmine.any(Function));
+    const hydrateHook = onBefore.calls.allArgs().find(([criteria]) => criteria.to === stateGlob)?.[1];
+
+    expect(hydrateHook).toEqual(jasmine.any(Function));
+    hydrateHook({ params: () => ({ acct: { production: true }, q: 'payments' }) });
+    expect(filterModel.sortFilter).toEqual({ account: { production: true }, filter: 'payments' });
+  });
+});

package/src/filterModel/FilterModelService.ts

@@ -1,7 +1,7 @@
 import { cloneDeep, forOwn, includes, isNil, pick, reduce, size, some } from 'lodash';
 
 import type { IFilterConfig, IFilterModel, ITrueKeyModel } from './IFilterModel';
-import { ReactInjector } from '../reactShims';
+import { getDirectRouter } from '../navigation/directRouter';
 
 export class FilterModelService {
   public static configureFilterModel(filterModel: IFilterModel, filterModelConfig: IFilterConfig[]) {
@@ -33,7 +33,7 @@ export class FilterModelService {
     // Apply any mutations to the current sortFilter values as ui-router state params
     filterModel.applyParamsToUrl = () => {
       const toParams = FilterModelService.mapSortFilterToRouterParams(filterModel);
-      ReactInjector.$state.go('.', toParams, { location: 'replace' });
+      getDirectRouter()?.stateService.go('.', toParams, { location: 'replace' });
     };
 
     return filterModel;
@@ -60,13 +60,21 @@ export class FilterModelService {
       const valueIfNil = filterTypeDefaults[filter.type];
       const rawValue = params[filter.param];
       const paramValue = isNil(rawValue) ? valueIfNil : rawValue;
-      // Clone deep so angularjs mutations happen on a different object reference
-      return { ...acc, [filter.model]: cloneDeep(paramValue) };
+      const normalizedValue = filter.normalizeParamValue
+        ? filter.normalizeParamValue(paramValue, { valueIfNil, rawValue, params })
+        : paramValue;
+      // Isolate the filter model from subsequent mutations to router params.
+      return { ...acc, [filter.model]: cloneDeep(normalizedValue) };
     }, {} as any);
   }
 
   public static registerRouterHooks(filterModel: IFilterModel, stateGlob: string) {
-    const { transitionService } = ReactInjector.$uiRouter;
+    const router = getDirectRouter();
+    if (!router) {
+      return;
+    }
+
+    const { transitionService } = router;
     const filterParams = filterModel.config.map((cfg) => cfg.param);
     let savedParamsForScreen: any = {};
 
@@ -94,8 +102,7 @@ export class FilterModelService {
       savedParamsForScreen = {};
     });
 
-    // Map transition param values to sortFilter values and save on the filterModel before each transition
-    // In the future, we should remove  the AngularJS code that watches for mutations on the sortFilter object
+    // Map transition param values onto the existing sortFilter before each transition.
     transitionService.onBefore({ to: stateGlob }, (trans) => {
       const toParams = trans.params();
       Object.assign(filterModel.sortFilter, FilterModelService.mapRouterParamsToSortFilter(filterModel, toParams));

package/src/filterModel/IFilterModel.ts

@@ -8,6 +8,10 @@ export interface IFilterConfig {
   displayOption?: boolean;
   defaultValue?: string;
   array?: boolean;
+  normalizeParamValue?: (
+    paramValue: any,
+    context: { valueIfNil: any; rawValue: any; params: Record<string, any> },
+  ) => any;
 }
 
 export interface ITrueKeyModel {

package/src/filterModel/filter.model.service.spec.js

@@ -1,29 +1,31 @@
 'use strict';
+import { hashLocationPlugin, servicesPlugin, UIRouterReact } from '@uirouter/react';
+
 import { FilterModelService } from './FilterModelService';
-import { REACT_MODULE, ReactInjector } from '../reactShims';
 import { StateConfigProvider } from '../navigation';
+import { getDirectRouter, setDirectRouter } from '../navigation/directRouter';
 
 describe('Service: FilterModelService', function () {
   var filterModel;
   var filterModelConfig;
-  var $uiRouter;
-  var $rootScope;
+  var router;
 
   function configure() {
     FilterModelService.configureFilterModel(filterModel, filterModelConfig);
     filterModel.activate();
   }
 
-  beforeEach(window.module('ui.router', REACT_MODULE));
+  beforeEach(function () {
+    filterModel = {};
+    filterModelConfig = [];
+    router = new UIRouterReact();
+    router.plugin(servicesPlugin);
+    router.plugin(hashLocationPlugin);
+  });
 
-  beforeEach(
-    window.inject(function (_$uiRouter_, _$rootScope_) {
-      filterModel = {};
-      filterModelConfig = [];
-      $uiRouter = _$uiRouter_;
-      $rootScope = _$rootScope_;
-    }),
-  );
+  afterEach(function () {
+    router.dispose();
+  });
 
   describe('isFilterable', function () {
     it('returns true if there are any properties with a value of true', function () {
@@ -368,56 +370,63 @@ describe('Service: FilterModelService', function () {
   });
 
   describe('parameter router hooks', function () {
-    function go(state, params) {
-      $uiRouter.stateService.go(state, params);
-      $rootScope.$digest();
+    let testRouter;
+
+    async function go(state, params) {
+      await router.stateService.go(state, params);
     }
 
     beforeEach(function () {
+      testRouter = getDirectRouter();
+      setDirectRouter(router);
       filterModelConfig = [
         { model: 'region', type: 'string' },
         { model: 'account', type: 'string' },
       ];
       configure();
 
-      $uiRouter.stateRegistry.register({ name: 'other' });
-      $uiRouter.stateRegistry.register({ name: 'application', url: '/applications/:application' });
-      $uiRouter.stateRegistry.register({
+      router.stateRegistry.register({ name: 'other' });
+      router.stateRegistry.register({ name: 'application', url: '/applications/:application' });
+      router.stateRegistry.register({
         name: 'application.filtered',
         url: '/filter?region&account',
         params: new StateConfigProvider().buildDynamicParams(filterModelConfig),
       });
-      $uiRouter.stateRegistry.register({ name: 'application.otherchild' });
+      router.stateRegistry.register({ name: 'application.otherchild' });
 
       FilterModelService.registerRouterHooks(filterModel, 'application.filtered');
     });
 
-    it('should restore the latest filters when reactivating a filter state in the same application', function () {
-      go('application.filtered', { application: 'myapp', region: 'west', account: 'prod' });
-      expect($uiRouter.globals.params.region).toBe('west');
-      expect($uiRouter.globals.params.account).toBe('prod');
+    afterEach(function () {
+      setDirectRouter(testRouter);
+    });
+
+    it('should restore the latest filters when reactivating a filter state in the same application', async function () {
+      await go('application.filtered', { application: 'myapp', region: 'west', account: 'prod' });
+      expect(router.globals.params.region).toBe('west');
+      expect(router.globals.params.account).toBe('prod');
 
-      go('application.otherchild');
-      expect($uiRouter.globals.params.region).toBe(undefined);
-      expect($uiRouter.globals.params.account).toBe(undefined);
+      await go('application.otherchild');
+      expect(router.globals.params.region).toBe(undefined);
+      expect(router.globals.params.account).toBe(undefined);
 
-      go('application.filtered');
-      expect($uiRouter.globals.params.region).toBe('west');
-      expect($uiRouter.globals.params.account).toBe('prod');
+      await go('application.filtered');
+      expect(router.globals.params.region).toBe('west');
+      expect(router.globals.params.account).toBe('prod');
     });
 
-    it('should not restore the latest filters when switching apps', function () {
-      go('application.filtered', { application: 'foo', region: 'west', account: 'prod' });
-      expect($uiRouter.globals.params.region).toBe('west');
-      expect($uiRouter.globals.params.account).toBe('prod');
+    it('should not restore the latest filters when switching apps', async function () {
+      await go('application.filtered', { application: 'foo', region: 'west', account: 'prod' });
+      expect(router.globals.params.region).toBe('west');
+      expect(router.globals.params.account).toBe('prod');
 
-      go('application.otherchild');
-      expect($uiRouter.globals.params.region).toBe(undefined);
-      expect($uiRouter.globals.params.account).toBe(undefined);
+      await go('application.otherchild');
+      expect(router.globals.params.region).toBe(undefined);
+      expect(router.globals.params.account).toBe(undefined);
 
-      go('application.filtered', { application: 'otherapp' });
-      expect($uiRouter.globals.params.region).toBe(undefined);
-      expect($uiRouter.globals.params.account).toBe(undefined);
+      await go('application.filtered', { application: 'otherapp' });
+      expect(router.globals.params.region).toBe(undefined);
+      expect(router.globals.params.account).toBe(undefined);
     });
   });
 
@@ -473,7 +482,9 @@ describe('Service: FilterModelService', function () {
 
     describe('applyParamsToUrl', function () {
       it('should start a transition with params for all configured fields', function () {
-        const spy = spyOn(ReactInjector.$state, 'go');
+        const previousRouter = getDirectRouter();
+        setDirectRouter(router);
+        const spy = spyOn(router.stateService, 'go');
         filterModelConfig = [
           { model: 'showInstances', type: 'boolean', displayOption: true },
           { model: 'search', type: 'string', param: 'q' },
@@ -483,6 +494,7 @@ describe('Service: FilterModelService', function () {
         filterModel.sortFilter.showInstances = true;
         filterModel.applyParamsToUrl();
         expect(spy).toHaveBeenCalledWith('.', { q: 'deck', showInstances: true }, jasmine.anything());
+        setDirectRouter(previousRouter);
       });
     });
   });

package/src/forms/mapEditor/MapPair.tsx

@@ -32,6 +32,7 @@ export const MapPair = (props: {
         )}
         <td>
           <input
+            aria-label={keyLabel}
             className="form-control input input-sm"
             type="text"
             value={pair.key}
@@ -53,6 +54,7 @@ export const MapPair = (props: {
             />
           ) : (
             <input
+              aria-label={valueLabel}
               className="form-control input input-sm"
               type="text"
               value={pair.value}
@@ -62,10 +64,10 @@ export const MapPair = (props: {
         </td>
         <td>
           <div className="form-control-static">
-            <a className="clickable button" onClick={onDelete}>
+            <button aria-label="Remove field" className="clickable button" onClick={onDelete} type="button">
               <span className="glyphicon glyphicon-trash" />
               <span className="sr-only">Remove field</span>
-            </a>
+            </button>
           </div>
         </td>
       </tr>

package/src/function/CreateFunctionButton.tsx

@@ -1,6 +1,7 @@
 import React from 'react';
 
 import type { Application } from '../application';
+import { DeckRuntimeContext } from '../bootstrap/DeckRuntimeContext';
 import { CloudProviderRegistry, ProviderSelectionService } from '../cloudProvider';
 import type { IFunction } from '../domain';
 import type { IFunctionUpsertCommand } from './function.write.service';
@@ -27,6 +28,9 @@ export interface ICreateFunctionButtonState {
 }
 
 export class CreateFunctionButton extends React.Component<ICreateFunctionButtonProps, ICreateFunctionButtonState> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   constructor(props: ICreateFunctionButtonProps) {
     super(props);
 
@@ -44,13 +48,16 @@ export class CreateFunctionButton extends React.Component<ICreateFunctionButtonP
 
     ProviderSelectionService.selectProvider(app, 'function').then((selectedProvider) => {
       const provider = CloudProviderRegistry.getValue(selectedProvider, 'function');
-      provider.CreateFunctionModal.show({
-        app: app,
-        application: app,
-        forPipelineConfig: false,
-        function: null,
-        isNew: true,
-      });
+      provider.CreateFunctionModal.show(
+        {
+          app: app,
+          application: app,
+          forPipelineConfig: false,
+          function: null,
+          isNew: true,
+        },
+        this.context.services,
+      );
     });
   };
 

package/src/function/Functions.tsx

@@ -39,9 +39,7 @@ export class Functions extends React.Component<IFunctionsProps, IFunctionsState>
 
     this.groupsUpdatedListener = FunctionState.filterService.groupsUpdatedStream.subscribe(() => this.groupsUpdated());
     FunctionState.filterModel.asFilterModel.activate();
-    this.functionsRefreshUnsubscribe = app
-      .getDataSource('functions')
-      .onRefresh(null, () => this.updateFunctionGroups());
+    this.functionsRefreshUnsubscribe = app.getDataSource('functions').onRefresh(() => this.updateFunctionGroups());
     app.setActiveState(app.loadBalancers);
     this.updateFunctionGroups();
   }

package/src/function/filter/FunctionFilterService.ts

@@ -49,7 +49,7 @@ export class FunctionFilterService {
   }
 
   public sortGroupsByHeading(): void {
-    // sort groups in place so Angular doesn't try to update the world
+    // Preserve the groups array identity for existing subscribers.
     FunctionState.filterModel.asFilterModel.groups.sort((a, b) => {
       return a.heading.localeCompare(b.heading);
     });

package/src/function/filter/FunctionFilters.tsx

@@ -1,5 +1,4 @@
 import { chain, compact, debounce, map, uniq } from 'lodash';
-import { $rootScope } from 'ngimport';
 import React from 'react';
 import type { Subscription } from 'rxjs';
 
@@ -8,6 +7,8 @@ import { FilterSearch } from '../../cluster/filter/FilterSearch';
 import { FilterSection } from '../../cluster/filter/FilterSection';
 import type { ISortFilter } from '../../filterModel';
 import { digestDependentFilters, FilterCheckbox } from '../../filterModel';
+import type { IRouterInjectedProps } from '../../navigation/routerContext';
+import { locationChangeSuccess$, withRouter } from '../../navigation/routerContext';
 import { FunctionState } from '../../state';
 
 const poolValueCoordinates = [
@@ -45,13 +46,16 @@ export interface IFunctionFiltersState {
   regionHeadings: string[];
 }
 
-export class FunctionFilters extends React.Component<IFunctionFiltersProps, IFunctionFiltersState> {
+class FunctionFiltersComponent extends React.Component<
+  IFunctionFiltersProps & IRouterInjectedProps,
+  IFunctionFiltersState
+> {
   private debouncedUpdateFunctionGroups: () => void;
   private groupsUpdatedSubscription: Subscription;
   private functionsRefreshUnsubscribe: () => void;
   private locationChangeUnsubscribe: () => void;
 
-  constructor(props: IFunctionFiltersProps) {
+  constructor(props: IFunctionFiltersProps & IRouterInjectedProps) {
     super(props);
     this.state = {
       sortFilter: FunctionState.filterModel.asFilterModel.sortFilter,
@@ -75,12 +79,13 @@ export class FunctionFilters extends React.Component<IFunctionFiltersProps, IFun
       this.updateFunctionGroups();
     }
 
-    this.functionsRefreshUnsubscribe = app.functions.onRefresh(null, () => this.updateFunctionGroups());
+    this.functionsRefreshUnsubscribe = app.functions.onRefresh(() => this.updateFunctionGroups());
 
-    this.locationChangeUnsubscribe = $rootScope.$on('$locationChangeSuccess', () => {
+    const locationChangeSubscription = locationChangeSuccess$(this.props.router).subscribe(() => {
       FunctionState.filterModel.asFilterModel.activate();
       FunctionState.filterService.updateFunctionGroups(app);
     });
+    this.locationChangeUnsubscribe = () => locationChangeSubscription.unsubscribe();
   }
 
   public componentWillUnmount(): void {
@@ -184,3 +189,6 @@ export class FunctionFilters extends React.Component<IFunctionFiltersProps, IFun
     );
   }
 }
+
+export const FunctionFilters = withRouter(FunctionFiltersComponent);
+FunctionFilters.displayName = 'FunctionFilters';

package/src/function/function.dataSource.ts

@@ -1,51 +1,81 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
 import type { Application } from '../application/application.model';
 import { INFRASTRUCTURE_KEY } from '../application/nav/defaultCategories';
 import { ApplicationDataSourceRegistry } from '../application/service/ApplicationDataSourceRegistry';
+import type { ProviderServiceDelegate } from '../cloudProvider/providerService.delegate';
 import { SETTINGS } from '../config/settings';
-import type { IFunction } from '../domain';
+import type { IFunction, IFunctionSourceData } from '../domain';
 import { EntityTagsReader } from '../entityTag/EntityTagsReader';
+import { FunctionReader } from './function.read.service';
+import type { IFunctionTransformer } from './function.transformer';
 
-import type { FunctionReader } from './function.read.service';
-import { FUNCTION_READ_SERVICE } from './function.read.service';
+export function createDirectFunctionReader(providerServiceDelegate: ProviderServiceDelegate): FunctionReader {
+  const functionTransformer: IFunctionTransformer = {
+    normalizeFunction: (functionDef: IFunctionSourceData) =>
+      providerServiceDelegate
+        .getDelegate<IFunctionTransformer>(functionDef.provider ? functionDef.provider : 'aws', 'function.transformer')
+        .normalizeFunction(functionDef),
+    normalizeFunctionSet: (functions: IFunctionSourceData[]) => {
+      const setTransformers = functions
+        .filter((fn) =>
+          providerServiceDelegate.hasDelegate(fn.provider ? fn.provider : 'aws', 'function.setTransformer'),
+        )
+        .map((fn) =>
+          providerServiceDelegate.getDelegate<IFunctionTransformer>(
+            fn.provider ? fn.provider : 'aws',
+            'function.setTransformer',
+          ),
+        )
+        .filter(
+          (transformer, index, transformers) =>
+            transformers.findIndex(
+              (candidate) => candidate.normalizeFunctionSet === transformer.normalizeFunctionSet,
+            ) === index,
+        );
 
-export const FUNCTION_DATA_SOURCE = 'spinnaker.core.functions.dataSource';
-module(FUNCTION_DATA_SOURCE, [FUNCTION_READ_SERVICE]).run([
-  '$q',
-  'functionReader',
-  ($q: IQService, functionReader: FunctionReader) => {
-    if (!SETTINGS.feature.functions) {
-      return;
-    }
-    const functions = (application: Application) => {
-      return functionReader.loadFunctions(application.name);
-    };
+      return setTransformers.reduce(
+        (result, transformer) => transformer.normalizeFunctionSet.call(transformer, result),
+        functions,
+      );
+    },
+  };
 
-    const addFunctions = (_application: Application, functionList: IFunction[]) => {
-      return $q.when(functionList);
-    };
+  return new FunctionReader(functionTransformer);
+}
 
-    const addTags = (application: Application) => {
-      EntityTagsReader.addTagsToFunctions(application);
-    };
+export function registerFunctionDataSource(functionReader: FunctionReader): void {
+  if (
+    !SETTINGS.feature.functions ||
+    ApplicationDataSourceRegistry.getDataSources().some((source) => source.key === 'functions')
+  ) {
+    return;
+  }
+  const functions = (application: Application) => {
+    return functionReader.loadFunctions(application.name);
+  };
 
-    ApplicationDataSourceRegistry.registerDataSource({
-      key: 'functions',
-      label: 'functions',
-      sref: '.insight.functions',
-      category: INFRASTRUCTURE_KEY,
-      optional: true,
-      icon: 'fa fa-xs fa-fw fa-asterisk',
-      iconName: 'spMenuFunctions',
-      loader: functions,
-      onLoad: addFunctions,
-      afterLoad: addTags,
-      providerField: 'cloudProvider',
-      credentialsField: 'account',
-      regionField: 'region',
-      description: 'Serverless Compute Service.',
-      defaultData: [],
-    });
-  },
-]);
+  const addFunctions = (_application: Application, functionList: IFunction[]) => {
+    return Promise.resolve(functionList);
+  };
+
+  const addTags = (application: Application) => {
+    EntityTagsReader.addTagsToFunctions(application);
+  };
+
+  ApplicationDataSourceRegistry.registerDataSource({
+    key: 'functions',
+    label: 'functions',
+    sref: '.insight.functions',
+    category: INFRASTRUCTURE_KEY,
+    optional: true,
+    icon: 'fa fa-xs fa-fw fa-asterisk',
+    iconName: 'spMenuFunctions',
+    loader: functions,
+    onLoad: addFunctions,
+    afterLoad: addTags,
+    providerField: 'cloudProvider',
+    credentialsField: 'account',
+    regionField: 'region',
+    description: 'Serverless Compute Service.',
+    defaultData: [],
+  });
+}

package/src/function/function.read.service.ts

@@ -1,9 +1,6 @@
-import { module } from 'angular';
-
 import { REST } from '../api/ApiService';
 import type { IFunctionSourceData } from '../domain';
 import type { IFunctionTransformer } from './function.transformer';
-import { CORE_FUNCTION_FUNCTION_TRANSFORMER } from './function.transformer';
 
 export interface IFunctionByAccount {
   name: string;
@@ -17,11 +14,9 @@ export interface IFunctionByAccount {
 }
 
 export class FunctionReader {
-  public static $inject = ['functionTransformer'];
-
   public constructor(private functionTransformer: IFunctionTransformer) {}
 
-  public loadFunctions(applicationName: string): PromiseLike<IFunctionSourceData[]> {
+  public loadFunctions(applicationName: string): Promise<IFunctionSourceData[]> {
     return REST('/applications')
       .path(applicationName, 'functions')
       .get()
@@ -36,7 +31,7 @@ export class FunctionReader {
     account: string,
     region: string,
     name: string,
-  ): PromiseLike<IFunctionSourceData[]> {
+  ): Promise<IFunctionSourceData[]> {
     return REST('/functions')
       .query({ provider: cloudProvider, functionName: name, region: region, account: account })
       .get()
@@ -46,7 +41,7 @@ export class FunctionReader {
       });
   }
 
-  public listFunctions(cloudProvider: string): PromiseLike<IFunctionByAccount[]> {
+  public listFunctions(cloudProvider: string): Promise<IFunctionByAccount[]> {
     return REST('/functions').query({ provider: cloudProvider }).get();
   }
 
@@ -56,7 +51,3 @@ export class FunctionReader {
     return fn;
   }
 }
-
-export const FUNCTION_READ_SERVICE = 'spinnaker.core.function.read.service';
-
-module(FUNCTION_READ_SERVICE, [CORE_FUNCTION_FUNCTION_TRANSFORMER]).service('functionReader', FunctionReader);

package/src/function/function.states.ts

@@ -1,18 +1,15 @@
-import type { StateParams } from '@uirouter/angularjs';
-import { module } from 'angular';
+import type { RawParams } from '@uirouter/core';
 
 import { FunctionDetails } from './FunctionDetails';
 import { Functions } from './Functions';
 import type { ApplicationStateProvider } from '../application';
-import { APPLICATION_STATE_PROVIDER } from '../application';
+import { registerApplicationState } from '../application';
 import { SETTINGS } from '../config/settings';
 import { filterModelConfig } from './filter/FunctionFilterModel';
 import { FunctionFilters } from './filter/FunctionFilters';
 import type { INestedState, StateConfigProvider } from '../navigation';
-export const FUNCTION_STATES = 'spinnaker.core.functions.states';
-module(FUNCTION_STATES, [APPLICATION_STATE_PROVIDER]).config([
-  'applicationStateProvider',
-  'stateConfigProvider',
+
+registerApplicationState(
   (applicationStateProvider: ApplicationStateProvider, stateConfigProvider: StateConfigProvider) => {
     if (!SETTINGS.feature.functions) {
       return;
@@ -27,10 +24,10 @@ module(FUNCTION_STATES, [APPLICATION_STATE_PROVIDER]).config([
         },
       },
       resolve: {
-        accountId: ['$stateParams', ($stateParams: StateParams) => $stateParams.account],
+        accountId: ['$stateParams', ($stateParams: RawParams) => $stateParams.account],
         functionObj: [
           '$stateParams',
-          ($stateParams: StateParams) => {
+          ($stateParams: RawParams) => {
             return {
               functionName: $stateParams.functionName,
               account: $stateParams.account,
@@ -70,4 +67,4 @@ module(FUNCTION_STATES, [APPLICATION_STATE_PROVIDER]).config([
     applicationStateProvider.addInsightState(functions);
     applicationStateProvider.addInsightDetailState(functionDetails);
   },
-]);
+);