dh-auth-library 1.1.0 → 1.2.1

package/dist/constants/index.d.ts

@@ -1,3 +1,3 @@
 export * from './loginHandler';
-export * from './accountTypes';
+export * from './testProfile';
 export * from './authTypes';

package/dist/constants/{accountTypes.d.ts → testProfile.d.ts}

@@ -1,4 +1,5 @@
 import { AuthType } from './authTypes';
+import { Account } from 'nl-portal-playwright-libraries';
 /**
  * Interface for TestProfiles
  * accountId should be used for identifying the account
@@ -8,5 +9,5 @@ import { AuthType } from './authTypes';
 export interface TestProfile {
     accountId: string;
     authType: AuthType;
-    id: string;
+    account: Account;
 }

package/dist/index.cjs.js

@@ -0,0 +1,562 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let nl_portal_playwright_libraries = require("nl-portal-playwright-libraries");
+let node_process = require("node:process");
+node_process = __toESM(node_process);
+let _playwright_test = require("@playwright/test");
+let totp_generator = require("totp-generator");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+//#region src/auth/loginhandlers/localhostLoginHandler.ts
+var LocalhostLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new nl_portal_playwright_libraries.LocalLoginPage(page).loginAndCreateNewSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/pages/loginOverzichtPage.ts
+var LoginOverzichtPage = class extends nl_portal_playwright_libraries.BasePage {
+	digidLoginKnop;
+	digidMachtigenLoginKnop;
+	eHerkenningLoginKnop;
+	eHerkenningMachtigingLoginKnop;
+	constructor(page) {
+		super(page);
+		this.digidLoginKnop = page.locator("#oidc-digid");
+		this.digidMachtigenLoginKnop = page.locator("#digid-machtigen");
+		this.eHerkenningLoginKnop = page.locator("#oidc-eHerkenning");
+		this.eHerkenningMachtigingLoginKnop = page.locator("#eherkenning-bewindvoering");
+	}
+	async klikOpDigidLoginOptie() {
+		await this.digidLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		await this.digidLoginKnop.click();
+	}
+	async klikOpDigidMachtigenLoginOptie() {
+		await this.digidMachtigenLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		await this.digidMachtigenLoginKnop.click();
+	}
+	async klikOpEHerkenningLoginOptie() {
+		await this.eHerkenningLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		try {
+			await this.eHerkenningLoginKnop.click();
+		} catch (_error) {
+			await this.reloadPage();
+			await this.eHerkenningLoginKnop.waitFor();
+			await this.page.waitForTimeout(2e3);
+			await this.eHerkenningLoginKnop.click();
+		}
+	}
+	async klikOpProfessioneelBewindvoerderLoginOptie() {
+		await this.eHerkenningMachtigingLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		try {
+			await this.eHerkenningMachtigingLoginKnop.click();
+		} catch (_error) {
+			await this.reloadPage();
+			await this.eHerkenningMachtigingLoginKnop.waitFor();
+			await this.page.waitForTimeout(2e3);
+			await this.eHerkenningMachtigingLoginKnop.click();
+		}
+	}
+	async valideerDatHetLoginOverzichtZichtbaarIs() {
+		await (0, _playwright_test.expect)(this.page.getByRole("heading", { name: "Inloggen voor mijzelf" })).toBeVisible();
+	}
+	async accepteerCookies() {
+		try {
+			await this.page.locator("#ppms_cm_agree-to-all").click();
+		} catch (_ignore) {}
+	}
+	async reloadPage() {
+		try {
+			await this.page.reload();
+		} catch (_error) {}
+	}
+};
+//#endregion
+//#region src/auth/pages/digidLoginPage.ts
+var DigidLoginPage = class extends LoginOverzichtPage {
+	constructor(page) {
+		super(page);
+	}
+	async loginAndCreateNewSession(account, fileName) {
+		await this.openPage();
+		await this.handleAnySpecialADLoginScreen();
+		try {
+			await this.klikOpDigidLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.handleAnySpecialADLoginScreen();
+			await this.klikOpDigidLoginOptie();
+		}
+		if (!this.page.url().match(/authn/)) {
+			await this.loginWithDigid(account);
+			await this.accepteerCookies();
+		}
+		await this.page.context().storageState({ path: fileName });
+	}
+	async loginAndCreateNewGemachtigdeSession(account, fileName) {
+		await this.openPage();
+		await this.handleAnySpecialADLoginScreen();
+		try {
+			await this.klikOpDigidMachtigenLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.klikOpDigidMachtigenLoginOptie();
+		}
+		await this.loginWithDigid(account, true);
+		await this.accepteerCookies();
+		await this.page.context().storageState({ path: fileName });
+	}
+	/**
+	* Indien er al een AD sessie is maar voor de verkeerde omgeving
+	* Je krijgt dan een speciaal scherm waar je moet bevestigen voordat je door kan
+	*/
+	async handleAnySpecialADLoginScreen() {
+		try {
+			await this.page.locator(`//div[contains(@data-test-id,'${node_process.default.env.AD_USER}')]`).first().waitFor({ timeout: 1e3 });
+			await this.page.locator(`//div[contains(@data-test-id,'${node_process.default.env.AD_USER}')]`).first().click();
+		} catch (_error) {}
+	}
+	async loginWithDigid(account, gemachtigde) {
+		await this.page.getByLabel("Inlogoptie 5 van 5: Inloggen").click();
+		await this.page.getByLabel("Testen betrouwbaarheidsniveau").selectOption("25");
+		await this.page.getByLabel("DigiD gebruikersnaam").fill(account.username);
+		await this.page.getByLabel("Wachtwoord", { exact: true }).fill(account.password);
+		const responsePromise = this.page.waitForResponse(/callback/, { timeout: 6e4 });
+		await this.page.getByRole("button", { name: "Inloggen" }).click();
+		if (gemachtigde) await this.page.getByRole("button", { name: "Kies" }).click();
+		return await responsePromise;
+	}
+	async loginAlsDigidGemachtigde() {
+		const gemachtigde = {
+			username: `${node_process.default.env.DIGID_GEMACHTIGDE_USER}`,
+			password: `${node_process.default.env.DIGID_GEMACHTIGDE_PASSWORD}`
+		};
+		await this.klikOpDigidMachtigenLoginOptie();
+		await this.loginWithDigid(gemachtigde, true);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/digidLoginHandler.ts
+var DigidLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new DigidLoginPage(page).loginAndCreateNewSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/pages/eHerkenningLoginPage.ts
+var EHerkenningLoginPage = class extends LoginOverzichtPage {
+	dropdownSelectIdentityProvider;
+	buttonConfirmIdentityProviderSelection;
+	textfieldUsername;
+	textfieldPassword;
+	inloggenKnop;
+	verderKnop;
+	verderLink;
+	inputBsn;
+	buttonZoek;
+	constructor(page) {
+		super(page);
+		this.dropdownSelectIdentityProvider = page.locator("#identity_provider");
+		this.buttonConfirmIdentityProviderSelection = page.locator("//*[@name='commit']");
+		this.textfieldUsername = page.locator("#account_username");
+		this.textfieldPassword = page.locator("#account_password");
+		this.inloggenKnop = page.getByRole("button", { name: /Inloggen|Log in/ });
+		this.verderKnop = page.getByRole("button", { name: /Verder|Continue|Ga verder/ });
+		this.inputBsn = page.locator("#bsn-input");
+		this.buttonZoek = page.locator("#search-submit");
+		this.verderLink = page.getByRole("link", { name: /Verder|Continue|Ga verder/ });
+	}
+	async probeerInTeLoggenMetEHerkenning(account) {
+		await this.dropdownSelectIdentityProvider.selectOption("Digidentity AD 1.13 (preproduction)");
+		await this.page.locator("#remember").click();
+		await this.buttonConfirmIdentityProviderSelection.click();
+		await this.textfieldUsername.fill(account.username);
+		await this.verderKnop.click();
+		await this.textfieldPassword.fill(account.password);
+		await this.inloggenKnop.click();
+	}
+	async loginWithEHerkenningAndCreateSession(fileName, account) {
+		await this.openPage();
+		try {
+			await this.klikOpEHerkenningLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.klikOpEHerkenningLoginOptie();
+		}
+		await this.loginWithEHerkenning(account);
+		await this.page.context().storageState({ path: fileName });
+	}
+	async loginWithEHerkenning(account) {
+		await this.probeerInTeLoggenMetEHerkenning(account);
+		await this.page.waitForTimeout(2e3);
+		if (await this.verderKnop.isVisible()) await this.verderKnop.click();
+		await this.accepteerCookies();
+	}
+	async loginWithEHerkenningVestigingAndCreateSession(fileName, account) {
+		await this.openPage();
+		try {
+			await this.klikOpEHerkenningLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.klikOpEHerkenningLoginOptie();
+		}
+		await this.loginWithEHerkenningVestiging(account);
+		await this.page.context().storageState({ path: fileName });
+	}
+	async loginWithEHerkenningVestiging(account) {
+		await this.probeerInTeLoggenMetEHerkenning(account);
+		await this.page.waitForTimeout(2e3);
+		if (await this.verderKnop.isVisible()) await this.verderKnop.click();
+		await this.accepteerCookies();
+	}
+	async loginAlsProfessioneelBewindvoerder(gemachtigde, file) {
+		await this.openPage();
+		await this.klikOpProfessioneelBewindvoerderLoginOptie();
+		try {
+			await this.probeerInTeLoggenMetEHerkenning(gemachtigde);
+		} catch (_error) {
+			await this.openPage();
+			await this.probeerInTeLoggenMetEHerkenning(gemachtigde);
+		}
+		if (gemachtigde.bsn != null) {
+			await this.verderLink.click();
+			await this.inputBsn.fill(gemachtigde.bsn);
+		}
+		await this.buttonZoek.click();
+		await this.verderLink.click();
+		await this.accepteerCookies();
+		if (file) await this.page.context().storageState({ path: file });
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/eHerkenningLoginHandler.ts
+var EHerkenningLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new EHerkenningLoginPage(page).loginWithEHerkenningVestigingAndCreateSession(file, account);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/digidGemachtigdeLoginHandler.ts
+var DigidGemachtigdeLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new DigidLoginPage(page).loginAndCreateNewGemachtigdeSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/eHerkenningBewindvoerderLoginHandler.ts
+var EHerkenningBewindvoerderLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new EHerkenningLoginPage(page).loginAlsProfessioneelBewindvoerder(account, file);
+	}
+};
+//#endregion
+//#region src/auth/pages/adLoginPage.ts
+var gzacUrlProd = "https://alg-zgw.denhaag.nl";
+var gzacUrlAcp = "https://alg-zgw.acc.denhaag.nl";
+var gzacUrlTest = "https://alg-zgw.test.denhaag.nl";
+var ADLoginPage = class ADLoginPage extends nl_portal_playwright_libraries.BasePage {
+	gebruikersnaamInput;
+	wachtwoordInput;
+	volgendeInput;
+	aanmeldenInput;
+	kanAuthAppNietGebruikenLink;
+	gebruikVerificatieCode;
+	codeInput;
+	verifierenInput;
+	constructor(page) {
+		super(page);
+		this.gebruikersnaamInput = page.locator("//input[@type='email']");
+		this.wachtwoordInput = page.locator("//input[@name='passwd']");
+		this.volgendeInput = page.locator("//input[@type='submit']");
+		this.aanmeldenInput = page.locator("//input[@type='submit']");
+		this.kanAuthAppNietGebruikenLink = page.locator("//*[@id='signInAnotherWay']");
+		this.gebruikVerificatieCode = page.locator("//div[@id='idDiv_SAOTCS_Proofs']//div[contains(@role,'listitem')][2]");
+		this.codeInput = page.locator("//input[@name='otc']");
+		this.verifierenInput = page.locator("//input[@type='submit']");
+	}
+	async openPage(path) {
+		await this.page.goto(path);
+	}
+	/**
+	* Login with the AD account so we can get behind the firewall
+	*
+	* @param account
+	* @param fileName
+	*/
+	async loginWithADAccountAndCreateSession(account, fileName) {
+		const adLoginPage = new ADLoginPage(this.page);
+		await this.page.goto(this.getGzacUrl());
+		await adLoginPage.gebruikersnaamInput.waitFor();
+		await adLoginPage.gebruikersnaamInput.fill(account.username);
+		await adLoginPage.volgendeInput.click();
+		await adLoginPage.wachtwoordInput.fill(account.password);
+		await adLoginPage.aanmeldenInput.click();
+		await this.page.waitForTimeout(1e3);
+		try {
+			if (await this.page.getByText("Uw account is niet geverifieerd. Probeer het opnieuw").isVisible()) await this.tryAgainUntilSuccesful();
+		} catch (_error) {}
+		await adLoginPage.kanAuthAppNietGebruikenLink.click();
+		await adLoginPage.gebruikVerificatieCode.click();
+		const token = await totp_generator.TOTP.generate(`${process.env.AD_SECRET}`);
+		await adLoginPage.codeInput.fill(token.otp);
+		await adLoginPage.verifierenInput.click();
+		await adLoginPage.page.waitForTimeout(5e3);
+		adLoginPage.page.on("domcontentloaded", () => {});
+		await adLoginPage.page.context().storageState({ path: fileName });
+	}
+	async tryAgainUntilSuccesful() {
+		let maxNumberOfTries = 6;
+		let foutMeldingIsSHowing = true;
+		while (foutMeldingIsSHowing) {
+			await this.page.waitForTimeout(1e4);
+			maxNumberOfTries--;
+			if (maxNumberOfTries == 0) return;
+			try {
+				await this.page.goBack();
+				await this.page.waitForTimeout(1e3);
+				await this.page.locator("//div[contains(@role,'listitem')]").first().click();
+				await this.page.waitForTimeout(1e3);
+				foutMeldingIsSHowing = await this.page.getByText("Uw account is niet geverifieerd. Probeer het opnieuw").isVisible();
+			} catch (_error) {}
+		}
+	}
+	getGzacUrl() {
+		const baseUrl = this.getBaseUrl();
+		if (/klantportaal-zgw.denhaag.nl./.exec(baseUrl)) return gzacUrlProd;
+		if (/.acc./.exec(baseUrl)) return gzacUrlAcp;
+		if (/.test./.exec(baseUrl)) return gzacUrlTest;
+		else throw new Error("Cannot find current environment for baseUrl: " + baseUrl);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/adLoginHandler.ts
+var ADLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new ADLoginPage(page).loginWithADAccountAndCreateSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/getLoginHandler.ts
+function getLoginHandler(authType) {
+	switch (authType) {
+		case "digid": return (0, nl_portal_playwright_libraries.isRunningOnLocalhost)() ? new LocalhostLoginHandler() : new DigidLoginHandler();
+		case "digid_gemachtigde": return new DigidGemachtigdeLoginHandler();
+		case "eherkenning": return (0, nl_portal_playwright_libraries.isRunningOnLocalhost)() ? new LocalhostLoginHandler() : new EHerkenningLoginHandler();
+		case "eherkenning_vestiging": return new EHerkenningLoginHandler();
+		case "eherkenning_bewindvoerder": return new EHerkenningBewindvoerderLoginHandler();
+		case "ad-session": return new ADLoginHandler();
+		default: throw new Error(`Unsupported auth type: ${authType}. If needed please create a new LoginHandler and register it here in getLoginHandler().`);
+	}
+}
+//#endregion
+//#region src/auth/utils/sessionFileHelper.ts
+var sessionsDir = node_process.env.SESSIONS_DIR ?? node_path.resolve(node_process.cwd(), "sessions");
+var environment = node_process.env.ENV ?? "test";
+/**
+* Easy way to create the filenames for the sessions
+*/
+var SessionFileHelper = class {
+	static getLocalhostFileName(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-${environment}-${account.username}.json`);
+	}
+	static getLocalhostFileNameBedrijf(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-${environment}-${account.username}.json`);
+	}
+	static getDigidFileName(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-digid-${environment}-${account.username}.json`);
+	}
+	static getDigidGemachtigdeFileName(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-digid-gemachtigde-${environment}-${account.username}.json`);
+	}
+	static getEHerkenningFileName(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-eherkenning-${environment}-${account.username}.json`);
+	}
+	static getEHerkenningVestigingFileName(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-eherkenning-vestiging-${environment}-${account.username}.json`);
+	}
+	static getEHerkenningBewindvoerderFileName(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-eherkenning-bewindvoerder-${environment}-${account.username}.json`);
+	}
+	static getADFileName(browser, account) {
+		return node_path.join(sessionsDir, `${browser.browserType().name()}-ad-${environment}-${account.username}.json`);
+	}
+};
+//#endregion
+//#region src/auth/sessionHandler.ts
+var MAX_SESSION_TIME_IN_MINUTES = 10;
+/**
+* This class creates the correct SessionHandler
+* It will also perform the process of setting op the session
+*
+* @param authType type of login
+* @param account with login details
+* @param loginHandler that will handle the login itself
+*/
+function createSessionHandler(authType, account, loginHandler) {
+	return {
+		getFile: (browser) => {
+			switch (authType) {
+				case "digid": return SessionFileHelper.getDigidFileName(browser, account);
+				case "digid_gemachtigde": return SessionFileHelper.getDigidGemachtigdeFileName(browser, account);
+				case "eherkenning": return SessionFileHelper.getEHerkenningFileName(browser, account);
+				case "eherkenning_vestiging": return SessionFileHelper.getEHerkenningVestigingFileName(browser, account);
+				case "eherkenning_bewindvoerder": return SessionFileHelper.getEHerkenningBewindvoerderFileName(browser, account);
+				case "ad-session": return SessionFileHelper.getADFileName(browser, account);
+				default: throw new Error(`Unsupported auth type: ${authType}`);
+			}
+		},
+		/**
+		* Setup the new session
+		* If needed the AD Session if used (Needed outside the firewall)
+		*
+		* @param browser
+		* @param file
+		*/
+		setupSession: async (browser, file) => {
+			const useADSession = process.env.WITH_AD_SESSION === "true";
+			const page = await browser.newPage({
+				ignoreHTTPSErrors: true,
+				storageState: useADSession && authType !== "ad-session" ? SessionFileHelper.getADFileName(browser, {
+					username: `${process.env.AD_USER}`,
+					password: `${process.env.AD_PASSWORD}`
+				}) : void 0
+			});
+			console.log(`New session will be created: ${file}`);
+			try {
+				await loginHandler.loginAndCreateSessionStorage(page, account, file);
+			} finally {
+				await page.close();
+			}
+		},
+		/**
+		* Refresh the current session by opening a page and storing that session
+		* The UI should have refreshed the session meanwhile
+		*
+		* This is being called from the nl-portal-base-library
+		*
+		* @param browser
+		* @param file
+		*/
+		refreshSession: async (browser, file) => {
+			const page = await browser.newPage({
+				ignoreHTTPSErrors: true,
+				storageState: file
+			});
+			console.log(`Refresh of session started for : ${file}`);
+			await page.goto((0, nl_portal_playwright_libraries.getUrl)(nl_portal_playwright_libraries.Url.PortalBaseUrl));
+			await page.waitForLoadState("networkidle");
+			if (page.url().match(/authn/)) {
+				console.log(`New session will be created as the current one is no longer valid: ${file}`);
+				try {
+					await loginHandler.loginAndCreateSessionStorage(page, account, file);
+				} catch (_error) {
+					console.error(_error);
+				}
+			} else {
+				console.log(`Current session was still valid and will be refreshed now: ${file}`);
+				await page.context().storageState({ path: file });
+			}
+			await page.close();
+		}
+	};
+}
+//#endregion
+//#region src/auth/api/apiTokenHelper.ts
+/**
+* The token is often being refreshed so the easiest is to open a browser using the current session
+* The UI will automatically refresh the token and that is the token we will return
+*
+* That token can be used to perform some api requests for a short time
+* Per specfile it is not problem but this should be done in every specfile to assure a valid token
+*
+* @param baseTest
+* @param handler
+*/
+function getApiTokenFromSession(baseTest, handler) {
+	return baseTest.extend({
+		urls: async ({}, use) => {
+			await use(nl_portal_playwright_libraries.urls);
+		},
+		token: async ({ browser }, use) => {
+			const storageState = await nl_portal_playwright_libraries.SessionManager.getOrCreateSession(browser, handler);
+			const context = await browser.newContext(storageState ? { storageState } : {});
+			const page = await context.newPage();
+			try {
+				await page.goto("/");
+				await page.waitForFunction(() => {
+					const key = Object.keys(sessionStorage).find((k) => k.startsWith("oidc"));
+					if (!key) return false;
+					const raw = sessionStorage.getItem(key);
+					if (!raw) return false;
+					try {
+						return !!JSON.parse(raw)?.access_token;
+					} catch {
+						return false;
+					}
+				});
+				const token = await page.evaluate(() => {
+					const key = Object.keys(sessionStorage).find((k) => k.startsWith("oidc"));
+					if (!key) return null;
+					const raw = sessionStorage.getItem(key);
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw)?.access_token ?? null;
+					} catch {
+						return null;
+					}
+				});
+				if (!token) throw new Error("❌ Token not found in sessionStorage");
+				await use(token);
+			} finally {
+				await context.close();
+			}
+		}
+	});
+}
+//#endregion
+//#region src/auth/api/sessionHandlerResolvers.ts
+function getSessionHandler(authType, account) {
+	return createSessionHandler(authType, account, getLoginHandler(authType));
+}
+//#endregion
+exports.ADLoginHandler = ADLoginHandler;
+exports.ADLoginPage = ADLoginPage;
+exports.DigidGemachtigdeLoginHandler = DigidGemachtigdeLoginHandler;
+exports.DigidLoginHandler = DigidLoginHandler;
+exports.DigidLoginPage = DigidLoginPage;
+exports.EHerkenningBewindvoerderLoginHandler = EHerkenningBewindvoerderLoginHandler;
+exports.EHerkenningLoginHandler = EHerkenningLoginHandler;
+exports.EHerkenningLoginPage = EHerkenningLoginPage;
+exports.LocalhostLoginHandler = LocalhostLoginHandler;
+exports.LoginOverzichtPage = LoginOverzichtPage;
+exports.MAX_SESSION_TIME_IN_MINUTES = MAX_SESSION_TIME_IN_MINUTES;
+exports.SessionFileHelper = SessionFileHelper;
+exports.createSessionHandler = createSessionHandler;
+exports.getApiTokenFromSession = getApiTokenFromSession;
+exports.getLoginHandler = getLoginHandler;
+exports.getSessionHandler = getSessionHandler;