function setAccountsData(state: any, action : IAccountsResponse) : any {
    return _.merge({}, state, { data: action.response.data })
}

 return editedFile.apply().then(() => {
   options.dasherizedName = 'trap-queen';
   options.component = 'TrapQueenComponent';
   return nru.applyChanges(
     nru.addPathToRoutes(routesFile, _.merge({route: 'home/trap-queen'}, options)));
 })

 expect(() => nru.addPathToRoutes(routesFile, _.merge({route: 'about/details'}, options)))

 PerusteProjektiService.mergeProjekti($scope.projekti, tuoPohja).then(function(peruste, projekti) {
     _.merge($scope.projekti, projekti);
     $scope.peruste = peruste;
 });

export const construct = (config: ServerConfig): {
  rootAppConfig: RootAppConfig,
  cmsConfig: CmsServerConfig,
  graphqlConfig: GqlifyConfig,
  authConfig: AuthConfig,
} => {
  // merge common config with default config
  const authMountPath = defaultConfig.authMountPath;
  const hostname = get(config, 'common.hostname');

  // cookieKeys will override auth & cms cookie config
  const cookieKeys = defaultTo(get(config, 'common.cookieKeys'), defaultConfig.cookieKeys);

  // Whether this cms is public access or not
  const publicAuth = defaultTo(get(config, 'common.public'), defaultConfig.public);

  // oidc clientId & clientSecret are shared between cms & auth services
  const clientId = defaultTo(get(config, 'common.clientId'), defaultConfig.clientId);
  const clientSecret = defaultTo(get(config, 'common.clientSecret'), defaultConfig.clientSecret);

  // oidc issuer
  const discoveryUrlFromHost = `${hostname}${authMountPath}/.well-known/openid-configuration`;
  const discoveryUrl = defaultTo(get(config, 'common.discoveryUrl'), discoveryUrlFromHost);
  const issuerConfig = get(config, 'common.issuerConfig');

  // graphql endpoint
  const graphqlEndpoint = `${hostname}/graphql`;

  // construct config for cms service
  const cmsConfig: CmsServerConfig = merge({
    cookieKeys,
    hostname,
    oidc: {
      discoveryUrl,
      clientId,
      clientSecret,
    },
    logger: jsonLogger,
  }, config.cms);

  // config for gqlify service
  const graphqlConfig: GqlifyConfig = {
    logger: jsonLogger,
    oidc: {
      discoveryUrl,
      issuerConfig,
    },
    ...config.graphql,
  };

  // config for auth service
  let authConfig: AuthConfig = {
    mountPath: defaultConfig.authMountPath,
    issuer: hostname,
    cookies: {
      long: { signed: true, maxAge: (1 * 24 * 60 * 60) * 1000 }, // 1 day in ms
      short: { signed: true },
      keys: cookieKeys,
    },
    redirectUris: [`${hostname}/auth/callback`],
    postLogoutRedirectUris: [`${hostname}/`],
    clientId,
    clientSecret,
    logger: jsonLogger,
    ...config.auth,
  };

  const rootAppConfig = {
    graphqlEndpoint,
    cookieKeys,
  };

  // if publicAuth is true, we make this cms public
  // mark cmsConfig.oidc as null to tell cmsServer we do not need oidc
  // mark graphqlConfig.oidc as null to tell graphql server we do not need auth
  // mark authConfig to null, so auth service won't start
  if (publicAuth) {
    cmsConfig.oidc = null;
    graphqlConfig.oidc = null;
    authConfig = null;
  }

  return {
    rootAppConfig,
    cmsConfig,
    graphqlConfig,
    authConfig,
  };
};

    // -----------------------------------------------------------------------------------------------------
    // @ Accessors
    // -----------------------------------------------------------------------------------------------------

    /**
     * Perfect Scrollbar options
     *
     * @param value
     */
    @Input()
    set fusePerfectScrollbarOptions(value)
    {
        // Merge the options
        this._options = _.merge({}, this._options, value);
    }

export function replace<T>(o: T): T {
    return _.merge(o, {__replace: true});
}

export const setup = (changes) => {
    _.merge(config, changes);
};

   state.checkList[index].isPassed = payload.canWorkSoundMeter
 },
 setCanHearVideoSound (state, payload): void {
   state.checkList[
     Constants.ENV_CHECK_LIST_ID.CAN_HEAR_VIDEO_SOUND - 1
   ].isPassed =
     payload.canHearVideoSound
 },
 setIsChecking (state, payload): void {
   state.checkList[payload.index].isChecking = payload.isChecking
 },
 setIsLoading (state, payload): void {
   state.checkList[payload.index].isLoading = payload.isLoading
 },
 setElements (state, payload): void {
   state.elements = _.merge(state.elements, payload.elements)
 },
 setMicInputVolumeInterval (state, payload): void {
   state.micInputVolumeInterval = payload.micInputVolumeInterval
 },
 clearMicInputVolumeInterval (state): void {
   if (state.micInputVolumeInterval) {
     clearInterval(state.micInputVolumeInterval)
   }
 },
 setCurrentCheckId (state, payload): void {
   state.currentCheckId = payload.currentCheckId
 },
 setDevicePermissions (state, payload): void {
   state.devicePermissions.webcam = payload.devicePermissions.webcam
   state.devicePermissions.mic = payload.devicePermissions.mic