function detectorOptionsTest() {
    var options = {
        // order and from where user language should be detected
        order: [/*'path', 'session', */ 'querystring', 'cookie', 'header'],

        // keys or params to lookup language from
        lookupQuerystring: 'lng',
        lookupCookie: 'i18next',
        lookupSession: 'lng',
        lookupFromPathIndex: 0,

        // cache user language
        caches: false, // ['cookie']

        // optional expire and domain for set cookie
        cookieExpirationDate: new Date(),
        cookieDomain: 'myDomain'
    };

    i18next
        .use(middleware.LanguageDetector)
        .init({
            detection: options
        });

    var lngDetector = new middleware.LanguageDetector(null, options);
    lngDetector.init(options);
}

  static enableFor (app: express.Express) {
    i18next
      .use(Backend)
      .use(postProcessor)
      .use(middleware.LanguageDetector)
      .init({
        backend: {
          loadPath: path.join(__dirname, '../../locales/{{lng}}/{{ns}}.po')
        },
        detection: {
          order: ['querystring', 'cookie'],
          lookupQuerystring: 'lang',
          lookupCookie: 'lang',
          caches: ['cookie']
        },
        interpolation: {
          escapeValue: false // Escaping is already handled by Nunjucks
        },
        whitelist: ['en', 'cy'],
        fallbackLng: 'en',
        nsSeparator: false,
        keySeparator: false
      })

    app.use(middleware.handle(i18next))
    return i18next
  }

 return new Promise((resolve, reject) => {
   // See https://github.com/i18next/ng-i18next
   i18use(XHR);
   i18init(
     {
       initImmediate: true,
       debug: $DIM_FLAVOR === 'dev',
       lng: defaultLanguage(),
       fallbackLng: 'en',
       lowerCaseLng: true,
       load: 'currentOnly',
       interpolation: {
         escapeValue: false,
         format(val, format) {
           if (format === 'pct') {
             return percent(parseFloat(val));
           } else if (format === 'humanBytes') {
             return humanBytes(parseInt(val, 10));
           }
           return val;
         }
       },
       backend: {
         loadPath(lng) {
           const path = {
             en,
             it,
             de,
             fr,
             es,
             'es-mx': esMX,
             ja,
             'pt-br': ptBR,
             pl,
             ru,
             ko,
             'zh-cht': zhCHT,
             'zh-chs': zhCHS
           }[lng];
           if (!path) {
             throw new Error(`unsupported language ${lng}`);
           }
           return path;
         }
       },
       returnObjects: true
     },
     (error) => {
       if (error) {
         reject(error);
       } else {
         resolve();
       }
     }
   );
 });

import * as i18next from 'i18next';
import * as XHR from 'i18next-xhr-backend';

const i18n = i18next
  .use(XHR)
  .init({
    fallbackLng: 'ja',
    ns: ['scenario'],
    defaultNS: 'scenario',
    interpolation: {
      escapeValue: false, // not needed for react!!
    },

    backend: {
      loadPath: '/lang/{{lng}}/{{ns}}.json',
    },
    react: {
      wait: true,
    },
  });

export default i18n;

function initTest() {
    const i18nextOptions = {};
    i18next
      .use(sprintfA)
      .use(sprintfB)
      .init(i18nextOptions);
      i18next
        .init({ overloadTranslationOptionHandler: sprintfA.overloadTranslationOptionHandler });
      i18next
        .init({ overloadTranslationOptionHandler: sprintfB.overloadTranslationOptionHandler });
}

function requestObjectTest() {
    var i18nextOptions = {};
    i18next
        .use(middleware.LanguageDetector)
        .init(i18nextOptions);

    var app = express();
    app.use(middleware.handle(i18next, {
        ignoreRoutes: ["/foo"],
        removeLngFromUrl: false
    }));
}

// Initialize the application
function initApp() {
  // Initialize the internationalization
  I18n.use(I18nXhrBackend)
    .use(I18nLanguageDetector)
    .init({
        ns: ['admiral', 'kubernetes', 'base'],
        defaultNS: 'admiral',
        fallbackLng: 'en',
        backend: {
            loadPath: 'assets/i18n/{{ns}}.{{lng}}.json'
        }
    }, () => {
      // Load configuration
      var xhr = new XMLHttpRequest();

      xhr.onreadystatechange = function () {
        if (xhr.readyState == XMLHttpRequest.DONE) {
          let properties = JSON.parse(xhr.responseText).documents;

          var configurationProperties = {};
          for (var prop in properties) {
            if (properties.hasOwnProperty(prop)) {

              configurationProperties[properties[prop].key] = properties[prop].value;
            }
          }

          Utils.initializeConfigurationProperties(configurationProperties);
          platformBrowserDynamic().bootstrapModule(AppModule);
        }
      };

      let configPropsUrl = Links.CONFIG_PROPS;
      if (window['getBaseServiceUrl']) {
        configPropsUrl = window['getBaseServiceUrl'](configPropsUrl);
      }

      xhr.open('GET', configPropsUrl + '?expand=true&documentType=true', true);
      xhr.setRequestHeader('Accept', 'application/json');
      xhr.send(null);
  });
}

    // cache user language on
    caches: ['localStorage', 'cookie'],

    // optional expire and domain for set cookie
    cookieMinutes: 10,
    cookieDomain: 'myDomain'
};
var myDetector = {
    name: 'myDetectorsName',

    lookup(options: Object) {
        // options -> are passed in options
        return 'en';
    },

    cacheUserLanguage(lng: string, options: Object) {
        // options -> are passed in options
        // lng -> current language, will be called after init and on changeLanguage

        // store it
    }
};

i18next.use(LngDetector).init({
    detection: options
});

const lngDetector = new LngDetector(null, options);
lngDetector.init(options);
lngDetector.addDetector(myDetector);

/* Allow chai assertions which don't end in a function call, e.g. expect(thing).to.be.undefined */
/* tslint:disable:no-unused-expression */

import * as i18next from 'i18next'
import * as postProcessor from 'i18next-sprintf-postprocessor'
i18next.use(postProcessor).init()

import { expect } from 'chai'
import * as moment from 'moment'
import { Validator } from '@hmcts/class-validator'

import { expectValidationError } from 'test/app/forms/models/validationUtils'

import { DatePaid } from 'paid-in-full/form/models/datePaid'
import { ValidationErrors } from 'forms/validation/validationErrors'
import { LocalDate, ValidationErrors as LocalDateValidationErrors } from 'forms/models/localDate'

describe('DatePaid', () => {
  describe('form object deserialization', () => {
    it('should return undefined when value is undefined', () => {
      expect(DatePaid.fromObject(undefined)).to.be.undefined
    })

    it('should return null when value is null', () => {
      expect(DatePaid.fromObject(null)).to.be.equal(null)
    })

    it('should deserialize all fields', () => {
      expect(DatePaid.fromObject({
        date: {
          year: 2017,

import * as i18n from "i18next";
import * as LanguageDetector from "i18next-browser-languagedetector";
import * as XHR from "i18next-xhr-backend";

i18n.use(XHR);
i18n.use(LanguageDetector);
i18n.init({
  defaultNS: "dashboard",
  fallbackLng: "en",
  interpolation: {
    escapeValue: false
  },
  keySeparator: false,
  ns: ["dashboard"],
  nsSeparator: false
});

export default i18n;