@taon-dev/session 21.0.216 → 21.0.240

package/websql/types/session-websql.d.ts

@@ -1,11 +1,213 @@
 // @ts-nocheck
-import * as rxjs from 'rxjs';
-import { Observable, BehaviorSubject } from 'rxjs';
-import * as taon_websql from 'taon/websql';
-import { TaonBaseAngularService, TaonBaseProvider, TaonBaseKvRepository, TaonBaseAbstractEntity, TaonBaseRepository, TaonBaseController, Taon, TaonBaseMiddleware, TaonServerMiddlewareInterceptOptions, TaonAdditionalMiddlewareMethodInfo } from 'taon/websql';
 import * as i0 from '@angular/core';
-import express from 'express';
+import { AfterViewInit, OnInit, OnDestroy, OnChanges, EventEmitter, SimpleChanges } from '@angular/core';
+import { Translation } from '@taon-dev/i18n/websql';
+import * as taon_websql from 'taon/websql';
+import { TaonBaseAbstractEntity, TaonBaseRepository, TaonBaseMigration, TaonBaseAngularService, TaonBaseCrudController, Taon, TaonBaseMiddleware, TaonBaseProvider, TaonBaseSubscriberForEntity, TaonBaseEntity, TaonBaseCustomRepository, Models, TaonPaginationQuery, TaonBaseClass, TaonBaseController, TaonBaseKvRepository, TaonServerMiddlewareInterceptOptions, TaonBaseStorageController, TaonUploadedFile, ExpressRequest, ExpressResponse, TaonStorageObject } from 'taon/websql';
+import { QueryRunner, EntityManager } from 'taon-typeorm/websql';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription, BehaviorSubject } from 'rxjs';
+import * as express from 'express';
+import express__default from 'express';
+import { Routes, UrlTree, ResolveFn } from '@angular/router';
+import * as session_websql from 'session/websql';
+import { MtxGridColumn } from '@ng-matero/extensions/grid';
+import { CoreModels, TaonStateMachine } from 'tnp-core/websql';
+import { FormGroup, FormControl, ValidatorFn } from '@angular/forms';
+import { MatDialogRef, MatDialog } from '@angular/material/dialog';
+import { TaonSlideContentComponent } from 'taon-ui/websql';
+import { TaonServerMiddlewareInterceptOptions as TaonServerMiddlewareInterceptOptions$1 } from 'ng2-rest/websql';
+
+declare enum TaonSessionUserState {
+    Active = "active",
+    Inactive = "inactive"
+}
+declare enum TaonSessionIdentityProvider {
+    PASSWORD = "PASSWORD",
+    GOOGLE = "GOOGLE",
+    MICROSOFT = "MICROSOFT",
+    APPLE = "APPLE",
+    FACEBOOK = "FACEBOOK",
+    GITHUB = "GITHUB"
+}
+
+declare class TaonSessionEntity extends TaonBaseAbstractEntity<TaonSessionEntity> {
+    userId: number;
+    identityId?: number;
+    authenticationProvider?: TaonSessionIdentityProvider;
+    user: TaonSessionUserEntity;
+    /**
+     * Store HASH of session token, not raw token.
+     */
+    tokenHash: string;
+    userAgent?: string;
+    ip?: string;
+    deviceName?: string;
+    lastActivityAt?: Date;
+    expiresAt: Date;
+    revokedAt?: Date;
+    revokeReason?: string;
+    createdAt: Date;
+}
+
+declare class TaonGroupRoleEntity extends TaonBaseAbstractEntity<TaonGroupRoleEntity> {
+    groupId: number;
+    roleId: number;
+    group: TaonGroupEntity;
+    role: TaonRoleEntity;
+}
+
+declare class TaonGroupEntity extends TaonBaseAbstractEntity<TaonGroupEntity> {
+    name: string;
+    code: string;
+    description?: string;
+    userGroups: TaonSessionUserGroupEntity[];
+    groupRoles: TaonGroupRoleEntity[];
+}
+
+declare class TaonSessionUserGroupEntity extends TaonBaseAbstractEntity<TaonSessionUserGroupEntity> {
+    userId: number;
+    groupId: number;
+    user: TaonSessionUserEntity;
+    group: TaonGroupEntity;
+    createdAt: Date;
+}
+
+declare class TaonSessionUserIdentityEntity extends TaonBaseAbstractEntity<TaonSessionUserIdentityEntity> {
+    userId: number;
+    user: TaonSessionUserEntity;
+    /**
+     * PASSWORD / GOOGLE / MICROSOFT / APPLE / FACEBOOK
+     */
+    provider: TaonSessionIdentityProvider;
+    /**
+     * PASSWORD:
+     *   normalized email
+     *
+     * GOOGLE:
+     *   Google's stable `sub`, NOT email
+     *
+     * Other OAuth providers:
+     *   stable provider-specific account id
+     */
+    providerUserId: string;
+    /**
+     * Convenience/contact email reported by this identity.
+     *
+     * Do NOT use this as the primary OAuth identity key.
+     */
+    email?: string;
+    /**
+     * Only PASSWORD identities have this.
+     *
+     * Never store plaintext here.
+     */
+    passwordHash?: string;
+    isEmailVerified: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+declare class TaonSessionUserEntity extends TaonBaseAbstractEntity<TaonSessionUserEntity> {
+    username?: string;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    sessions: TaonSessionEntity[];
+    identities: TaonSessionUserIdentityEntity[];
+    userGroups: TaonSessionUserGroupEntity[];
+    userRoles: TaonSessionUserRoleEntity[];
+}
+
+declare class TaonSessionUserRoleEntity extends TaonBaseAbstractEntity<TaonSessionUserRoleEntity> {
+    userId: number;
+    roleId: number;
+    user: TaonSessionUserEntity;
+    role: TaonRoleEntity;
+    createdAt: Date;
+}
+
+declare class TaonPermissionEntity extends TaonBaseAbstractEntity<TaonPermissionEntity> {
+    /**
+     * Examples:
+     *
+     * user.read
+     * user.write
+     * project.deploy
+     * billing.invoice.read
+     */
+    name: string;
+    code: string;
+    description?: string;
+    rolePermissions: TaonRolePermissionEntity[];
+}
 
+declare class TaonRolePermissionEntity extends TaonBaseAbstractEntity<TaonRolePermissionEntity> {
+    roleId: number;
+    permissionId: number;
+    role: TaonRoleEntity;
+    permission: TaonPermissionEntity;
+}
+
+declare class TaonRoleEntity extends TaonBaseAbstractEntity<TaonRoleEntity> {
+    /**
+     * Example:
+     * admin
+     * editor
+     * billing-manager
+     */
+    name: string;
+    code: string;
+    description?: string;
+    userRoles: TaonSessionUserRoleEntity[];
+    groupRoles: TaonGroupRoleEntity[];
+    rolePermissions: TaonRolePermissionEntity[];
+}
+
+declare class TaonGroupRoleRepository extends TaonBaseRepository<TaonGroupRoleEntity> {
+    entityClassResolveFn: () => typeof TaonGroupRoleEntity;
+    /**
+     * TODO remove this demo example method
+     */
+    countEntitesWithEvenId(): Promise<number>;
+    getRolesForGroupId(groupId: number): Promise<TaonRoleEntity[]>;
+    assignRoleToGroup(groupId: number, roleId: number): Promise<TaonGroupRoleEntity>;
+    unassignRoleFromGroup(groupId: number, roleId: number): Promise<void>;
+}
+
+declare class TaonRolePermissionRepository extends TaonBaseRepository<TaonRolePermissionEntity> {
+    entityClassResolveFn: () => typeof TaonRolePermissionEntity;
+    /**
+     * TODO remove this demo example method
+     */
+    countEntitesWithEvenId(): Promise<number>;
+    getPermissionsForRoleId(roleId: number): Promise<TaonPermissionEntity[]>;
+    assignPermissionToRole(roleId: number, permissionId: number): Promise<TaonRolePermissionEntity>;
+    unassignPermissionFromRole(roleId: number, permissionId: number): Promise<void>;
+}
+
+declare class SessionContext_1790328479283_initial extends TaonBaseMigration {
+    groupRepo: TaonGroupRepository;
+    roleRepo: TaonRoleRepository;
+    permissionRepo: TaonPermissionRepository;
+    groupRoleRepo: TaonGroupRoleRepository;
+    rolePermissionRepo: TaonRolePermissionRepository;
+    up(queryRunner: QueryRunner): Promise<void>;
+    private getOrCreatePermission;
+    private getOrCreateRole;
+    private getOrCreateGroup;
+    private assignPermission;
+    private assignRole;
+    down(queryRunner: QueryRunner): Promise<void>;
+}
+
+declare const MIGRATIONS_CLASSES_FOR_SessionContext: {
+    SessionContext_1790328479283_initial: typeof SessionContext_1790328479283_initial;
+};
+
+declare const ENV_ANGULAR_NODE_APP_CONFIG_SUPER_USERS: () => Promise<string>;
+declare const ENV_ANGULAR_NODE_APP_CONFIG_GOOGLE_SECRET: () => Promise<string>;
+declare const ENV_ANGULAR_NODE_APP_CONFIG_GOOGLE_CLIENT_ID = "289576612173-2mh31b67pmq2qdes5jedno9tr1m542es.apps.googleusercontent.com";
 declare const ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND = "#fdebed";
 declare const ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME = "lds-default";
 declare const ENV_ANGULAR_NODE_APP_WEBSITE_DOMAIN = "session.example.domain.com";
@@ -13,6 +215,7 @@ declare const ENV_ANGULAR_NODE_APP_WEBSITE_TITLE = "Session";
 declare const ENV_ANGULAR_NODE_APP_WEBSITE_USE_DOMAIN = true;
 declare const ENV_ANGULAR_NODE_APP_RELEASE_TARGET_ARTIFACT = "angular-node-app";
 declare const ENV_ANGULAR_NODE_APP_RELEASE_ENV_NAME = "__";
+declare const ENV_ANGULAR_NODE_APP_FINISH_CALLBACK: () => Promise<string>;
 declare const ENV_ANGULAR_NODE_APP_CONTAINER_ONLY: any;
 declare const ENV_ANGULAR_NODE_APP_CONTAINER_END: any;
 declare const ENV_ANGULAR_NODE_APP_CONTAINER_START: any;
@@ -74,6 +277,9 @@ declare const ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER: any;
 declare const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER: any;
 declare const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB: any;
 
+declare const ENV_DOCS_WEBAPP_CONFIG_SUPER_USERS: () => Promise<string>;
+declare const ENV_DOCS_WEBAPP_CONFIG_GOOGLE_SECRET: () => Promise<string>;
+declare const ENV_DOCS_WEBAPP_CONFIG_GOOGLE_CLIENT_ID = "289576612173-2mh31b67pmq2qdes5jedno9tr1m542es.apps.googleusercontent.com";
 declare const ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND = "#fdebed";
 declare const ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME = "lds-default";
 declare const ENV_DOCS_WEBAPP_WEBSITE_DOMAIN = "session.example.domain.com";
@@ -81,6 +287,7 @@ declare const ENV_DOCS_WEBAPP_WEBSITE_TITLE = "Session";
 declare const ENV_DOCS_WEBAPP_WEBSITE_USE_DOMAIN = true;
 declare const ENV_DOCS_WEBAPP_RELEASE_TARGET_ARTIFACT = "docs-webapp";
 declare const ENV_DOCS_WEBAPP_RELEASE_ENV_NAME = "__";
+declare const ENV_DOCS_WEBAPP_FINISH_CALLBACK: () => Promise<string>;
 declare const ENV_DOCS_WEBAPP_CONTAINER_ONLY: any;
 declare const ENV_DOCS_WEBAPP_CONTAINER_END: any;
 declare const ENV_DOCS_WEBAPP_CONTAINER_START: any;
@@ -142,6 +349,9 @@ declare const ENV_DOCS_WEBAPP_DOCKER_ADDITIONAL_CONTAINER: any;
 declare const ENV_DOCS_WEBAPP_DOCKER_SKIP_START_IN_ORDER: any;
 declare const ENV_DOCS_WEBAPP_DOCKER_SKIP_USING_MYSQL_DB: any;
 
+declare const ENV_ELECTRON_APP_CONFIG_SUPER_USERS: () => Promise<string>;
+declare const ENV_ELECTRON_APP_CONFIG_GOOGLE_SECRET: () => Promise<string>;
+declare const ENV_ELECTRON_APP_CONFIG_GOOGLE_CLIENT_ID = "289576612173-2mh31b67pmq2qdes5jedno9tr1m542es.apps.googleusercontent.com";
 declare const ENV_ELECTRON_APP_BUILD_SSR = false;
 declare const ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND = "#fdebed";
 declare const ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME = "lds-default";
@@ -150,6 +360,7 @@ declare const ENV_ELECTRON_APP_WEBSITE_TITLE = "Session";
 declare const ENV_ELECTRON_APP_WEBSITE_USE_DOMAIN = true;
 declare const ENV_ELECTRON_APP_RELEASE_TARGET_ARTIFACT = "electron-app";
 declare const ENV_ELECTRON_APP_RELEASE_ENV_NAME = "__";
+declare const ENV_ELECTRON_APP_FINISH_CALLBACK: () => Promise<string>;
 declare const ENV_ELECTRON_APP_CONTAINER_ONLY: any;
 declare const ENV_ELECTRON_APP_CONTAINER_END: any;
 declare const ENV_ELECTRON_APP_CONTAINER_START: any;
@@ -210,6 +421,9 @@ declare const ENV_ELECTRON_APP_DOCKER_ADDITIONAL_CONTAINER: any;
 declare const ENV_ELECTRON_APP_DOCKER_SKIP_START_IN_ORDER: any;
 declare const ENV_ELECTRON_APP_DOCKER_SKIP_USING_MYSQL_DB: any;
 
+declare const ENV_MOBILE_APP_CONFIG_SUPER_USERS: () => Promise<string>;
+declare const ENV_MOBILE_APP_CONFIG_GOOGLE_SECRET: () => Promise<string>;
+declare const ENV_MOBILE_APP_CONFIG_GOOGLE_CLIENT_ID = "289576612173-2mh31b67pmq2qdes5jedno9tr1m542es.apps.googleusercontent.com";
 declare const ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND = "#fdebed";
 declare const ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME = "lds-default";
 declare const ENV_MOBILE_APP_WEBSITE_DOMAIN = "session.example.domain.com";
@@ -217,6 +431,7 @@ declare const ENV_MOBILE_APP_WEBSITE_TITLE = "Session";
 declare const ENV_MOBILE_APP_WEBSITE_USE_DOMAIN = true;
 declare const ENV_MOBILE_APP_RELEASE_TARGET_ARTIFACT = "mobile-app";
 declare const ENV_MOBILE_APP_RELEASE_ENV_NAME = "__";
+declare const ENV_MOBILE_APP_FINISH_CALLBACK: () => Promise<string>;
 declare const ENV_MOBILE_APP_CONTAINER_ONLY: any;
 declare const ENV_MOBILE_APP_CONTAINER_END: any;
 declare const ENV_MOBILE_APP_CONTAINER_START: any;
@@ -278,6 +493,9 @@ declare const ENV_MOBILE_APP_DOCKER_ADDITIONAL_CONTAINER: any;
 declare const ENV_MOBILE_APP_DOCKER_SKIP_START_IN_ORDER: any;
 declare const ENV_MOBILE_APP_DOCKER_SKIP_USING_MYSQL_DB: any;
 
+declare const ENV_NPM_LIB_AND_CLI_TOOL_CONFIG_SUPER_USERS: () => Promise<string>;
+declare const ENV_NPM_LIB_AND_CLI_TOOL_CONFIG_GOOGLE_SECRET: () => Promise<string>;
+declare const ENV_NPM_LIB_AND_CLI_TOOL_CONFIG_GOOGLE_CLIENT_ID = "289576612173-2mh31b67pmq2qdes5jedno9tr1m542es.apps.googleusercontent.com";
 declare const ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND = "#fdebed";
 declare const ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME = "lds-default";
 declare const ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_DOMAIN = "session.example.domain.com";
@@ -285,6 +503,7 @@ declare const ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_TITLE = "Session";
 declare const ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_USE_DOMAIN = true;
 declare const ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_TARGET_ARTIFACT = "npm-lib-and-cli-tool";
 declare const ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_ENV_NAME = "__";
+declare const ENV_NPM_LIB_AND_CLI_TOOL_FINISH_CALLBACK: () => Promise<string>;
 declare const ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_ONLY: any;
 declare const ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_END: any;
 declare const ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_START: any;
@@ -346,6 +565,9 @@ declare const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_ADDITIONAL_CONTAINER: any;
 declare const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_START_IN_ORDER: any;
 declare const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_USING_MYSQL_DB: any;
 
+declare const ENV_VSCODE_PLUGIN_CONFIG_SUPER_USERS: () => Promise<string>;
+declare const ENV_VSCODE_PLUGIN_CONFIG_GOOGLE_SECRET: () => Promise<string>;
+declare const ENV_VSCODE_PLUGIN_CONFIG_GOOGLE_CLIENT_ID = "289576612173-2mh31b67pmq2qdes5jedno9tr1m542es.apps.googleusercontent.com";
 declare const ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND = "#fdebed";
 declare const ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME = "lds-default";
 declare const ENV_VSCODE_PLUGIN_WEBSITE_DOMAIN = "session.example.domain.com";
@@ -353,6 +575,7 @@ declare const ENV_VSCODE_PLUGIN_WEBSITE_TITLE = "Session";
 declare const ENV_VSCODE_PLUGIN_WEBSITE_USE_DOMAIN = true;
 declare const ENV_VSCODE_PLUGIN_RELEASE_TARGET_ARTIFACT = "vscode-plugin";
 declare const ENV_VSCODE_PLUGIN_RELEASE_ENV_NAME = "__";
+declare const ENV_VSCODE_PLUGIN_FINISH_CALLBACK: () => Promise<string>;
 declare const ENV_VSCODE_PLUGIN_CONTAINER_ONLY: any;
 declare const ENV_VSCODE_PLUGIN_CONTAINER_END: any;
 declare const ENV_VSCODE_PLUGIN_CONTAINER_START: any;
@@ -437,7 +660,10 @@ declare const CURRENT_PACKAGE_TAON_VERSION = "v21";
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-declare const CURRENT_PACKAGE_VERSION = "21.0.216";
+declare const CURRENT_PACKAGE_VERSION = "21.0.240";
+declare namespace TAON_CLOUDFLARE_WORKERS_URLS {
+    const CwCustomSeoni4B382 = "https://cw-custom-seoni-4b382.darekf77.workers.dev";
+}
 
 declare function myOrgProj(): void;
 
@@ -448,50 +674,725 @@ declare function myOrgProj(): void;
  */
 declare function startCli(argsv: string[], filename: string): Promise<void>;
 
+declare class TaonAuditEventsEntity extends TaonBaseAbstractEntity<TaonAuditEventsEntity> {
+    type: string;
+    /**
+     * Who performed the action.
+     */
+    actorUserId?: number;
+    /**
+     * Who/what was affected.
+     */
+    targetType?: string;
+    targetId?: string;
+    sessionId?: number;
+    ip?: string;
+    userAgent?: string;
+    data?: Record<string, any>;
+    createdAt: Date;
+}
+
+declare class TaonAuditEventsApiService extends TaonBaseAngularService {
+    private taonAuditEventsController;
+    get allMyEntities$(): Observable<TaonAuditEventsEntity[]>;
+    helloWorld(user: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAuditEventsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonAuditEventsApiService>;
+}
+
+declare const TaonAuditEventsContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+declare const TaonAuditEventsDefaultsValues: Partial<TaonAuditEventsEntity>;
+
+declare class TaonAuditEventsRepository extends TaonBaseRepository<TaonAuditEventsEntity> {
+    entityClassResolveFn: () => typeof TaonAuditEventsEntity;
+    /**
+     * TODO remove this demo example method
+     */
+    countEntitesWithEvenId(): Promise<number>;
+}
+
+declare class TaonAuditEventsController extends TaonBaseCrudController<TaonAuditEventsEntity> {
+    entityClassResolveFn: () => typeof TaonAuditEventsEntity;
+    taonAuditEventsRepository: TaonAuditEventsRepository;
+    /**
+     * TODO remove this demo example method
+     */
+    helloWord(yourName: string): Taon.Response<string>;
+}
+
+declare class TaonAuditEventsMiddleware extends TaonBaseMiddleware {
+}
+
+declare enum TaonAuditEventsState {
+    Active = "active",
+    Inactive = "inactive"
+}
+
+declare class TaonAuditEventsProvider extends TaonBaseProvider {
+}
+
+declare class TaonAuditEventsSubscriber extends TaonBaseSubscriberForEntity {
+    taonAuditEventsProvider: TaonAuditEventsProvider;
+    listenTo(): typeof TaonAuditEventsEntity;
+}
+
+declare namespace TaonAuditEventsUtils {
+    function isActive(state: string): state is TaonAuditEventsState;
+}
+
+declare const TaonAuthContextContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+interface TaonAuthorizationSchema {
+    group: string;
+    role: string;
+    permission: string;
+}
+declare class TaonAuthContextEntity<AUTH extends TaonAuthorizationSchema = {
+    group: string;
+    role: string;
+    permission: string;
+}> extends TaonBaseEntity<TaonAuthContextEntity> {
+    user: TaonSessionUserEntity;
+    isSuperUser: boolean;
+    isLocalhostBackend: boolean;
+    session: TaonSessionEntity;
+    groups: AUTH['group'][];
+    roles: AUTH['role'][];
+    permissions: AUTH['permission'][];
+    hasPermission(permission: AUTH['permission']): boolean;
+    hasRole(role: AUTH['role']): boolean;
+    isInGroup(group: AUTH['group']): boolean;
+}
+
+type EnumLike<T extends string> = Record<string, T>;
+type RelationSelection<T extends string> = '*' | T[];
+type GroupAndRolesTree<GROUP extends string, ROLE extends string> = Partial<Record<GROUP, RelationSelection<ROLE>>>;
+type RolesAndPermissionsTree<ROLE extends string, PERMISSION extends string> = Partial<Record<ROLE, RelationSelection<PERMISSION>>>;
+interface PersistAuthorizationTreeOptions<GROUP extends string, ROLE extends string, PERMISSION extends string> {
+    enums: {
+        groups: EnumLike<GROUP>;
+        roles: EnumLike<ROLE>;
+        permissions: EnumLike<PERMISSION>;
+    };
+    tree: {
+        groupAndRoles?: GroupAndRolesTree<GROUP, ROLE>;
+        rolesAndPermissions?: RolesAndPermissionsTree<ROLE, PERMISSION>;
+    };
+}
+declare class TaonAuthContextRepository<AUTH extends TaonAuthorizationSchema> extends TaonBaseCustomRepository {
+    private readonly taonSessionUserRepository;
+    private readonly taonSessionRepository;
+    private readonly taonGroupRoleRepository;
+    private readonly taonRolePermissionRepository;
+    private readonly taonGroupRepository;
+    private readonly taonPermissionRepository;
+    private readonly taonSessionProvider;
+    private readonly taonRoleRepository;
+    getContext(userId?: number | string): Promise<TaonAuthContextEntity<AUTH>>;
+    clearRolesGroupPermissions(): Promise<void>;
+    persistTree(options: PersistAuthorizationTreeOptions<AUTH['group'], AUTH['role'], AUTH['permission']>): Promise<void>;
+    private getOrCreateGroup;
+    private getOrCreateRole;
+    private getOrCreatePermission;
+    private assignRole;
+    private assignPermission;
+}
+
+declare class TaonAuthorizationBackofficeComponent {
+    componentLoaded: boolean;
+    onRouteActivate(component: any): void;
+    onRouteDeactivate(component: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAuthorizationBackofficeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonAuthorizationBackofficeComponent, "app-taon-authorization-backoffice", never, {}, {}, never, never, true, never>;
+}
+
+declare namespace TaonAuthorizationBackofficeModels { }
+
+declare const TaonAuthorizationBackofficeRoutes: Routes;
+
+declare class TaonSessionUserController extends TaonBaseCrudController<TaonSessionUserEntity, {}, TaonSessionUserController> {
+    entityClassResolveFn: () => typeof TaonSessionUserEntity;
+    private readonly taonSessionRepository;
+    beforeEachRequest({ req, res, methodConfig, classConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionUserController>): Promise<void>;
+    getBy(id: number | string): Models.Http.Response<TaonSessionUserEntity>;
+    protected paginationQueryMethods(): (keyof TaonSessionUserController)[];
+    paginationQuery(queryJson?: TaonPaginationQuery<any>): Models.Http.Response<TaonSessionUserEntity[]>;
+    protected customPaginationQuery(query: TaonPaginationQuery<TaonSessionUserController>): Promise<[TaonSessionUserEntity[], number]>;
+}
+
+declare class TaonGroupRepository extends TaonBaseRepository<TaonGroupEntity> {
+    entityClassResolveFn: () => typeof TaonGroupEntity;
+    getGroupsForUserId(userId: number | string): Promise<TaonGroupEntity[]>;
+}
+
+declare class TaonGroupController extends TaonBaseCrudController<TaonGroupEntity, {}, TaonGroupController> {
+    entityClassResolveFn: () => typeof TaonGroupEntity;
+    taonGroupRepository: TaonGroupRepository;
+    private readonly taonGroupRoleRepository;
+    private readonly taonSessionUserGroupRepository;
+    private readonly taonSessionRepository;
+    protected beforeEachRequest({ req, res, methodConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionUserController>): Promise<void>;
+    getGroupsForUser(userId: number): Taon.Response<TaonGroupEntity[]>;
+    assignGroupToUser(userId: number, groupId: number): Taon.Response<void>;
+    unassignGroupFromUser(userId: number, groupId: number): Taon.Response<void>;
+    getRolesForGroup(groupId: number): Taon.Response<TaonRoleEntity[]>;
+    assignRoleToGroup(groupId: number, roleId: number): Taon.Response<void>;
+    unassignRoleFromGroup(groupId: number, roleId: number): Taon.Response<void>;
+}
+
+declare class TaonGroupApiService extends TaonBaseAngularService {
+    taonGroupController: TaonGroupController;
+    get allMyEntities$(): Observable<TaonGroupEntity[]>;
+    getAllGroups(): Promise<TaonGroupEntity[]>;
+    getGroupsForUser(userId: number): Promise<TaonGroupEntity[]>;
+    assignGroupToUser(userId: number, groupId: number): Promise<void>;
+    unassignGroupFromUser(userId: number, groupId: number): Promise<void>;
+    getRolesForGroup(groupId: number): Promise<TaonRoleEntity[]>;
+    assignRoleToGroup(groupId: number, roleId: number): Promise<void>;
+    unassignRoleFromGroup(groupId: number, roleId: number): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonGroupApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonGroupApiService>;
+}
+
+declare const TaonGroupContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+declare const TaonGroupDefaultsValues: Partial<TaonGroupEntity>;
+
+declare class TaonGroupMiddleware extends TaonBaseMiddleware {
+}
+
+declare class TaonGroupProvider extends TaonBaseProvider {
+}
+
+declare class TaonNotificationRecipientEntity extends TaonBaseAbstractEntity<TaonNotificationRecipientEntity> {
+    notificationId: number;
+    userId: number;
+    notification: TaonNotificationEntity;
+    user: TaonSessionUserEntity;
+    readAt?: Date;
+    dismissedAt?: Date;
+    deliveredAt?: Date;
+}
+
+declare class TaonNotificationEntity extends TaonBaseAbstractEntity<TaonNotificationEntity> {
+    /**
+     * Stable machine-readable code.
+     *
+     * video.processing.finished
+     * auth.session.revoked
+     * payment.success
+     */
+    type: string;
+    title: string;
+    message?: string;
+    /**
+     * Optional route/action.
+     *
+     * /projects/123
+     * /videos/abc
+     */
+    actionUrl?: string;
+    /**
+     * Arbitrary strongly-typed-by-your-code payload.
+     */
+    data?: Record<string, any>;
+    createdByUserId?: number;
+    createdAt: Date;
+    expiresAt?: Date;
+    recipients: TaonNotificationRecipientEntity[];
+}
+
+declare class TaonNotificationApiService extends TaonBaseAngularService {
+    private taonNotificationController;
+    get allMyEntities$(): Observable<TaonNotificationEntity[]>;
+    helloWorld(user: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonNotificationApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonNotificationApiService>;
+}
+
+declare const TaonNotificationContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+declare const TaonNotificationDefaultsValues: Partial<TaonNotificationEntity>;
+
+declare class TaonNotificationRepository extends TaonBaseRepository<TaonNotificationEntity> {
+    entityClassResolveFn: () => typeof TaonNotificationEntity;
+    /**
+     * TODO remove this demo example method
+     */
+    countEntitesWithEvenId(): Promise<number>;
+}
+
+declare class TaonNotificationController extends TaonBaseCrudController<TaonNotificationEntity> {
+    entityClassResolveFn: () => typeof TaonNotificationEntity;
+    taonNotificationRepository: TaonNotificationRepository;
+    /**
+     * TODO remove this demo example method
+     */
+    helloWord(yourName: string): Taon.Response<string>;
+}
+
+declare class TaonNotificationMiddleware extends TaonBaseMiddleware {
+}
+
+declare enum TaonNotificationState {
+    Active = "active",
+    Inactive = "inactive"
+}
+
+declare class TaonNotificationProvider extends TaonBaseProvider {
+}
+
+declare class TaonNotificationSubscriber extends TaonBaseSubscriberForEntity {
+    taonNotificationProvider: TaonNotificationProvider;
+    listenTo(): typeof TaonNotificationEntity;
+}
+
+declare namespace TaonNotificationUtils {
+    function isActive(state: string): state is TaonNotificationState;
+}
+
+declare class TaonPermissionRepository extends TaonBaseRepository<TaonPermissionEntity> {
+    entityClassResolveFn: () => typeof TaonPermissionEntity;
+    getPermissionsForUserId(userId: number | string): Promise<TaonPermissionEntity[]>;
+    updateDescription(permissionId: number, description: string): Promise<TaonPermissionEntity>;
+}
+
+declare class TaonPermissionController extends TaonBaseCrudController<TaonPermissionEntity> {
+    entityClassResolveFn: () => typeof TaonPermissionEntity;
+    taonPermissionRepository: TaonPermissionRepository;
+    private readonly taonSessionRepository;
+    beforeEachRequest({ req, res, methodConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionUserController>): Promise<void>;
+    updateDescription(permissionId: number, description: string): Taon.Response<TaonPermissionEntity>;
+}
+
+declare class TaonPermissionApiService extends TaonBaseAngularService {
+    taonPermissionController: TaonPermissionController;
+    get allMyEntities$(): Observable<TaonPermissionEntity[]>;
+    getAllPermissions(): Promise<TaonPermissionEntity[]>;
+    updateDescription(permissionId: number, description: string): Promise<TaonPermissionEntity>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonPermissionApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonPermissionApiService>;
+}
+
+declare const TaonPermissionContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+declare const TaonPermissionDefaultsValues: Partial<TaonPermissionEntity>;
+
+declare class TaonPermissionMiddleware extends TaonBaseMiddleware {
+}
+
+declare enum TaonPermissionState {
+    Active = "active",
+    Inactive = "inactive"
+}
+
+declare class TaonPermissionProvider extends TaonBaseProvider {
+}
+
+declare class TaonPermissionSubscriber extends TaonBaseSubscriberForEntity {
+    taonPermissionProvider: TaonPermissionProvider;
+    listenTo(): typeof TaonPermissionEntity;
+}
+
+declare namespace TaonPermissionUtils {
+    function isActive(state: string): state is TaonPermissionState;
+}
+
+declare class TaonRoleRepository extends TaonBaseRepository<TaonRoleEntity> {
+    entityClassResolveFn: () => typeof TaonRoleEntity;
+    getRolesForUserId(userId: number | string): Promise<TaonRoleEntity[]>;
+}
+
+declare class TaonRoleController extends TaonBaseCrudController<TaonRoleEntity> {
+    entityClassResolveFn: () => typeof TaonRoleEntity;
+    taonRoleRepository: TaonRoleRepository;
+    private readonly taonRolePermissionRepository;
+    private readonly taonSessionRepository;
+    beforeEachRequest({ req, res, methodConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionUserController>): Promise<void>;
+    getPermissionsForRole(roleId: number): Taon.Response<TaonPermissionEntity[]>;
+    assignPermissionToRole(roleId: number, permissionId: number): Taon.Response<void>;
+    unassignPermissionFromRole(roleId: number, permissionId: number): Taon.Response<void>;
+}
+
+declare class TaonRoleApiService extends TaonBaseAngularService {
+    taonRoleController: TaonRoleController;
+    get allMyEntities$(): Observable<TaonRoleEntity[]>;
+    getAllRoles(): Promise<TaonRoleEntity[]>;
+    getPermissionsForRole(roleId: number): Promise<TaonPermissionEntity[]>;
+    assignPermissionToRole(roleId: number, permissionId: number): Promise<void>;
+    unassignPermissionFromRole(roleId: number, permissionId: number): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonRoleApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonRoleApiService>;
+}
+
+declare const TaonRoleContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+declare const TaonRoleDefaultsValues: Partial<TaonRoleEntity>;
+
+declare enum TaonRoleState {
+    Active = "active",
+    Inactive = "inactive"
+}
+
+declare class TaonRoleProvider extends TaonBaseProvider {
+}
+
+declare const TaonSessionAbstractContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+interface TaonLoginData {
+    email?: string;
+    password?: string;
+    googleCode?: string;
+}
+interface GoogleCodeResponse {
+    code?: string;
+    error?: string;
+    error_description?: string;
+}
+declare enum TaonSessionState {
+    LOADING_INITIAL_AUTH_INFO = "LOADING_INITIAL_AUTH_INFO",
+    LOGIN_OR_REGISTER = "LOGIN_OR_REGISTER",
+    ENTER_PASSWORD = "ENTER_PASSWORD",
+    ENTER_REGISTRATION_PASSWORDS = "ENTER_REGISTRATION_PASSWORDS",
+    LOADING_AUTH = "LOADING_AUTH",
+    LOADING_CHECK_USER_EMAIL_EXISTS = "LOADING_CHECK_USER_EMAIL_EXISTS",
+    LOADING_CREATING_USER = "LOADING_CREATING_USER",
+    LOADING_LOGOUT_INFO = "LOADING_LOGOUT_INFO",
+    TWO_FA_EMAIL = "TWO_FA_EMAIL",
+    TWO_FA_SMS = "TWO_FA_SMS",
+    TWO_FA_AUTHENTICATOR = "TWO_FA_AUTHENTICATOR",
+    LOGIN_SUCCESS = "LOGIN_SUCCESS",
+    PROFILE_INFO = "PROFILE_INFO",
+    PASSWORD_CHANGE = "PASSWORD_CHANGE",
+    AVATAR_CHANGE = "AVATAR_CHANGE"
+}
+declare enum TaonLoginErrors {
+    INVALID_PASSWORD = "INVALID_PASSWORD",
+    INVALID_SOCIAL_LOGIN = "INVALID_SOCIAL_LOGIN",
+    PASSWORDS_DO_NOT_MATCH = "PASSWORDS_DO_NOT_MATCH"
+}
+declare const TaonErorsMap: Map<TaonLoginErrors, string>;
+
 declare class TaonSessionApiService extends TaonBaseAngularService {
     private taonSessionController;
-    login(email: string, password: string): Observable<boolean>;
+    usernameAvailable(username: string): Observable<boolean>;
+    changeUsername(username: string): Observable<boolean>;
+    connectPassword(email: string, password: string): Observable<boolean>;
+    login(data: TaonLoginData): Observable<boolean>;
     logout(): Observable<boolean>;
-    me(): Observable<string>;
+    connectIdentity(data: TaonLoginData): Observable<boolean>;
+    disconnectIdentity(provider: TaonSessionIdentityProvider): Observable<boolean>;
+    context(): Observable<TaonAuthContextEntity>;
+    emptyContext(): Observable<TaonAuthContextEntity>;
+    getCurrentUserId(): Observable<number>;
+    userExists(email: string, opt: {
+        goToPreviouseState: () => void;
+    }): Observable<boolean>;
+    createUser(email: string, password: string): Observable<TaonSessionUserEntity | undefined>;
     refresh(): Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionApiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TaonSessionApiService>;
 }
 
-declare class TaonSessionProvider extends TaonBaseProvider {
+declare class TaonSessionCookiesConfig extends TaonBaseClass {
     ACCESS_TOKEN_SECRET: string;
     REFRESH_TOKEN_SECRET: string;
     ACCESS_TOKEN_EXPIRES: string;
     REFRESH_TOKEN_EXPIRES_SECONDS: number;
+    accessTokenCookieName: string;
+    refreshTokenCookieName: string;
+    sameSite: 'lax' | 'strict' | 'none';
+    secure: boolean;
+    httpOnly: boolean;
+    constructor();
+}
+declare class TaonSessionSocialLoginConfig extends TaonBaseClass {
+    google: {
+        enabled?: boolean;
+        googleClientId?: string;
+        googleSecret?: string;
+    };
+    facebook: {
+        enabled?: boolean;
+        facebookClientId?: string;
+    };
+    microsoft: {
+        enabled?: boolean;
+        microsoftClientId?: string;
+    };
+    apple: {
+        enabled?: boolean;
+        appleClientId?: string;
+    };
+    github: {
+        enabled?: boolean;
+        githubClientId?: string;
+    };
+    constructor();
+    get isAnySocialLoginEnabled(): boolean;
+}
+declare class TaonSessionPasswordRequirementsConfig {
+    minLength: number;
+    maxLength: number;
+    requireLowercase: boolean;
+    requireUppercase: boolean;
+    requireNumber: boolean;
+    requireSpecialCharacter: boolean;
+    specialCharacters: string;
+    constructor();
+}
+declare class TaonSessionRegistrationConfig {
+    /**
+     * ⌛ TODO in progress
+     */
+    enabled: boolean;
+    /**
+     * ⌛ TODO in progress
+     */
+    requireEmailConfirmation: boolean;
+    /**
+     * ⌛ TODO in progress
+     * Registration allowed only when user has
+     * invitation code / registration password.
+     */
+    requireRegistrationPassword: boolean;
+    /**
+     * ⌛ TODO in progress
+     */
+    allowDuplicateEmail: boolean;
+    constructor();
+}
+declare class TaonSessionLoginConfig extends TaonBaseClass {
+    diableLoginByEmail: boolean;
+    defaultEmail?: string;
+    defaultPassword?: string;
+    linkToDashboard: string;
+    displayDashboardButton: boolean;
+    /**
+     * TODO
+     * Whether FE may check whether email exists
+     * before showing password/register screen.
+     */
+    /**
+     * TODO
+     */
+    constructor();
+}
+declare class TaonSessionCheckIfHumanConfig {
+    duringLoginRegisterEmail: boolean;
+    duringRegistrationPassword: boolean;
+    duringLoginPassword: boolean;
+    duringPasswordReset: boolean;
+    constructor();
+}
+declare class TaonSessionSessionsConfig {
+    /**
+     * Multiple devices / browsers may stay logged in.
+     */
+    allowMultipleSessions: boolean;
+    /**
+     * 0 = unlimited
+     */
+    maxSessionsPerUser: number;
+    /**
+     * Update last activity timestamp.
+     */
+    trackActivity: boolean;
+    /**
+     * Optional idle timeout.
+     * 0 = disabled
+     */
+    idleTimeoutSeconds: number;
+    constructor();
+}
+declare class TaonSessionPasswordRecoveryConfig {
+    enabled: boolean;
+    tokenExpiresSeconds: number;
+    invalidateExistingSessionsAfterReset: boolean;
+    constructor();
+}
+declare class TaonSessionEmailConfirmationConfig {
+    enabled: boolean;
+    tokenExpiresSeconds: number;
+    allowResend: boolean;
+    resendCooldownSeconds: number;
+    constructor();
+}
+declare class TaonSessionSecurityConfig {
+    /**
+     * Logout all sessions after password change.
+     */
+    invalidateSessionsAfterPasswordChange: boolean;
+    /**
+     * Rotate refresh token after successful refresh.
+     */
+    rotateRefreshTokens: boolean;
+    /**
+     * Detect reuse of already rotated refresh tokens.
+     */
+    detectRefreshTokenReuse: boolean;
+    constructor();
+}
+declare class TaonSessionRateLimitConfig {
+    maxAttempts: number;
+    windowSeconds: number;
+    constructor(maxAttempts: number, windowSeconds: number);
+}
+declare class TaonSessionRateLimitsConfig {
+    loginAttempts: TaonSessionRateLimitConfig;
+    passwordReset: TaonSessionRateLimitConfig;
+    emailConfirmationResend: TaonSessionRateLimitConfig;
+    constructor();
+}
+type TaonSessionConfig = Omit<CoreModels.DeepPartial<TaonSessionProvider>, 'ctx' | '_' | 'getOriginalPrototype' | 'getOriginalConstructor' | '__endpoint_context__'>;
+declare class TaonSessionProvider extends TaonBaseProvider {
+    /**
+     * Production means here - it runs on real server
+     */
+    isProduction: boolean;
+    superUsersEmails: string[];
+    /**
+     * Resolve social accounts by verified email as well as provider identity.
+     */
+    linkSocialAccountEmail: boolean;
+    cookies: TaonSessionCookiesConfig;
+    login: TaonSessionLoginConfig;
+    socialLogin: TaonSessionSocialLoginConfig;
+    _(): Promise<void>;
+    clone(): TaonSessionConfig;
 }
 
-declare class TaonSessionKvRepository extends TaonBaseKvRepository {
-    taonSessionProvider: TaonSessionProvider;
-    createAccessToken(userId: string): string;
-    createRefreshToken(userId: string): string;
-    setAuthCookies(res: express.Response, accessToken: string, refreshToken: string): void;
-    clearAuthCookies(res: express.Response): void;
-    getTokenFromRequest(req: express.Request): string | null;
+declare class TaonSessionConfigService extends TaonBaseAngularService {
+    private taonSessionProvider;
+    clone(): TaonSessionConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonSessionConfigService>;
 }
 
-declare class TaonSessionUser extends TaonBaseAbstractEntity<TaonSessionUser> {
-    email?: string;
-    password?: string;
+declare class TaonSessionUserApiService extends TaonBaseAngularService {
+    taonSessionUserController: TaonSessionUserController;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionUserApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonSessionUserApiService>;
 }
 
-declare class TaonSessionUserRepository extends TaonBaseRepository<TaonSessionUser> {
-    entityClassResolveFn: () => typeof TaonSessionUser;
+declare class TaonSessionUserGroupRepository extends TaonBaseRepository<TaonSessionUserGroupEntity> {
+    entityClassResolveFn: () => typeof TaonSessionUserGroupEntity;
+    assignGroupToUser(userId: number, groupId: number): Promise<TaonSessionUserGroupEntity>;
+    unassignGroupFromUser(userId: number, groupId: number): Promise<void>;
 }
 
-declare const TaonSessionContext: {
+declare const TaonSessionUserContext: {
     readonly contextName: string;
+    readonly expressApp: express.Application;
     readonly appId: string;
-    cloneAsRemote: (cloneOpt?: {
-        overrideRemoteHost?: string;
-    }) => any;
-    cloneAsNormal: (cloneOpt?: {
-        overrideHost?: string;
-    }) => any;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
     __ref(): Promise<taon_websql.EndpointContext>;
     readonly __refSync: taon_websql.EndpointContext;
     getClassInstance<T>(ctor: new (...args: any[]) => T): T;
@@ -503,46 +1404,793 @@ declare const TaonSessionContext: {
     };
 };
 
-declare namespace TaonSession {
-    const DEFAULT_PASSWORD = "1234";
-    const DEFAULT_EMAIL = "test@test.com";
-    interface TaonLoginData {
-        email?: string;
-        password?: string;
-    }
+declare const TaonSessionUserDefaultsValues: Partial<TaonSessionUserEntity>;
+
+declare class TaonSessionUserMiddleware extends TaonBaseMiddleware {
+}
+
+declare class TaonSessionUserProvider extends TaonBaseProvider {
+}
+
+declare class TaonSessionUserRepository extends TaonBaseRepository<TaonSessionUserEntity> {
+    entityClassResolveFn: () => typeof TaonSessionUserEntity;
+    createUser(): Promise<TaonSessionUserEntity>;
+    normalizeUsername(username: string): string;
+    isUsernameAvailable(username: string, userId: number): Promise<boolean>;
+    changeUsername(userId: number, username: string): Promise<void>;
+    getUserById(userId: number | string): Promise<TaonSessionUserEntity | null>;
+}
+
+declare class TaonSessionUserSubscriber extends TaonBaseSubscriberForEntity {
+    taonSessionUserProvider: TaonSessionUserProvider;
+    listenTo(): typeof TaonSessionUserEntity;
+}
+
+declare namespace TaonSessionUserUtils {
+    function generateRandomUsername(): string;
 }
 
 declare class TaonSessionController extends TaonBaseController {
-    taonSessionKvRepository: TaonSessionKvRepository;
-    taonSessionProvider: TaonSessionProvider;
-    taonSessionUserRepository: TaonSessionUserRepository;
-    login(data: TaonSession.TaonLoginData): Taon.Response<boolean>;
+    private readonly taonSessionKvRepository;
+    private readonly taonSessionUserIdentityRepository;
+    private readonly taonSessionProvider;
+    private readonly taonSessionUserRepository;
+    private readonly taonAuthContextRepository;
+    private readonly taonSessionRepository;
+    createUser(email: string, password: string): Taon.Response<TaonSessionUserEntity | null>;
+    userExists(email: string): Taon.Response<boolean>;
+    private getGoogleIdentity;
+    connectIdentity(data: TaonLoginData): Taon.Response<boolean>;
+    usernameAvailable(username: string): Taon.Response<boolean>;
+    changeUsername(username: string): Taon.Response<boolean>;
+    disconnectIdentity(provider: TaonSessionIdentityProvider): Taon.Response<boolean>;
+    login(data: TaonLoginData): Taon.Response<boolean>;
     refresh(): Taon.Response<boolean>;
     logout(): Taon.Response<boolean>;
-    me(): Taon.Response<string>;
+    context(): Taon.Response<TaonAuthContextEntity>;
+    emptyContext(): Taon.Response<TaonAuthContextEntity>;
+    getCurrentUserId(): Taon.Response<number>;
 }
 
-declare class TaonSessionMiddleware extends TaonBaseMiddleware {
-    taonSessionKvRepository: TaonSessionKvRepository;
+declare class TaonSessionKvRepository extends TaonBaseKvRepository<Record<string, {
+    userId: number;
+    expiresAt: number;
+    sessionId?: number;
+}>> {
     taonSessionProvider: TaonSessionProvider;
-    interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType, }: TaonAdditionalMiddlewareMethodInfo): Promise<void> | void;
+    createAccessToken(userId: number, sessionId?: number): Promise<string>;
+    createRefreshToken(userId: number, sessionId?: number): Promise<string>;
+    setAuthCookies(res: express__default.Response, accessToken: string, refreshToken: string): void;
+    clearAuthCookies(res: express__default.Response): void;
+    getTokenFromRequest(req: express__default.Request): string | null;
 }
 
-declare namespace TaonSessionUtils { }
+declare class TaonSessionRepository extends TaonBaseRepository<TaonSessionEntity> {
+    entityClassResolveFn: () => typeof TaonSessionEntity;
+    private readonly taonSessionKvRepository;
+    private readonly taonSessionProvider;
+    createSession(partialSessino: Partial<TaonSessionEntity>): Promise<TaonSessionEntity>;
+    requireActiveSession(sessionId: number, userId: number): Promise<TaonSessionEntity>;
+    touchSession(sessionId: number, userId: number, refresh?: boolean): Promise<void>;
+    revokeSession(sessionId: number, userId: number): Promise<void>;
+    getSessionBy(userId: number | string): Promise<TaonSessionEntity>;
+    throwIfNotAuthenticated({ req, res, next, }: Pick<TaonServerMiddlewareInterceptOptions, 'req' | 'res'> & Partial<Pick<TaonServerMiddlewareInterceptOptions, 'next'>>): Promise<void>;
+}
+
+declare class TaonSessionMiddleware extends TaonBaseMiddleware {
+    taonSessionRepository: TaonSessionRepository;
+    interceptServerMethod(data: TaonServerMiddlewareInterceptOptions): Promise<void>;
+}
 
-declare class TaonSessionComponent {
-    taonSessionApiService: TaonSessionApiService;
-    refreshSrc: BehaviorSubject<any>;
-    email: string;
-    password: string;
-    userId: string;
-    userId$: rxjs.Observable<string>;
-    loading: boolean;
+declare class TaonSessionComponent implements AfterViewInit, OnInit, OnDestroy {
+    config: TaonSessionConfig;
+    private emailInput?;
+    private passwordInput?;
+    private registrationPasswordInput?;
+    protected slide: TaonSlideContentComponent;
+    protected readonly t: Translation;
+    protected readonly TaonSessionState: typeof TaonSessionState;
+    protected readonly TaonLoginErrors: typeof TaonLoginErrors;
+    protected readonly TaonErorsMap: Map<TaonLoginErrors, string>;
+    protected emailRegex: RegExp;
+    taonSessionStateService: TaonSessionStateService;
+    protected readonly taonSessionConfigService: TaonSessionConfigService;
+    protected form: FormGroup<{
+        email: FormControl<string>;
+        password: FormControl<string>;
+        passwordRepeat: FormControl<string>;
+        googleCode: FormControl<string>;
+        state: FormControl<TaonSessionState>;
+    }>;
+    protected readonly dialogRef: MatDialogRef<any, any>;
+    isLoggedIn$: rxjs.Observable<boolean>;
+    context$: rxjs.Observable<session_websql.TaonAuthContextEntity<{
+        group: string;
+        role: string;
+        permission: string;
+    }>>;
+    protected sub: Subscription;
+    protected googleButtonLoaded: boolean;
+    whenAllowedAnimationMap: Map<TaonSessionState, TaonSessionState[]>;
+    get isInsideDialog(): boolean;
+    get googleClientId(): string;
+    get microsoftClientId(): string;
+    get isAnySocialLoginEnabled(): boolean;
+    get diableLoginByEmail(): boolean;
     reloadMe(): void;
-    login(): void;
+    executeActionForState(): void;
+    goTo(action: TaonSessionState): void;
     logout(): void;
+    protected close(): void;
+    private focusMainInput;
+    private googleCodeClient?;
+    private initGoogleLogin;
+    loginWithGoogle(): void;
+    private loginWithGoogleCode;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    resetPasswordScreen(): void;
+    private updateValidatorsFor;
     static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionComponent, "app-taon-session", never, {}, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionComponent, "taon-session", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TaonSessionStateService extends TaonBaseProvider {
+    protected readonly taonSessionApiService: TaonSessionApiService;
+    /**
+     * Refreshes session/authentication information.
+     *
+     * This causes getCurrentUserId() to be called again.
+     */
+    protected readonly refreshSrc: BehaviorSubject<void>;
+    /**
+     * Refreshes authorization context without reloading
+     * the current session/user.
+     *
+     * Useful when roles/groups/permissions change while
+     * the currently authenticated user stays the same.
+     */
+    protected readonly contextRefreshSrc: BehaviorSubject<void>;
+    protected readonly userId: i0.WritableSignal<number>;
+    protected readonly currentSlide: i0.WritableSignal<TaonSessionState>;
+    private allowedStateMap;
+    state: TaonStateMachine<TaonSessionState>;
+    /**
+     * Current authenticated user.
+     *
+     * Shared because multiple consumers may depend on userId$,
+     * isLoggedIn$ and context$ at the same time.
+     *
+     * One refresh => one getCurrentUserId() request.
+     */
+    protected readonly userId$: Observable<number>;
+    /**
+     * Projection of userId$.
+     *
+     * Does NOT cause another getCurrentUserId() call because
+     * userId$ is shared.
+     */
+    readonly isLoggedIn$: Observable<boolean>;
+    /**
+     * Current authorization context.
+     *
+     * Reloaded when:
+     *
+     * 1. session/user changes
+     * 2. refreshContext() is explicitly called
+     *
+     * Multiple subscribers share the same context request.
+     */
+    readonly context$: Observable<TaonAuthContextEntity>;
+    executeActionForState(form: TaonSessionComponent['form']): void;
+    logout(successCallback?: () => void): void;
+    /**
+     * Reload complete authentication/session state.
+     *
+     * This causes:
+     *
+     * getCurrentUserId()
+     *   -> userId$
+     *   -> isLoggedIn$
+     *   -> context$
+     */
+    refresh(): void;
+    /**
+     * Reload authorization context only.
+     *
+     * Does NOT call getCurrentUserId().
+     */
+    refreshContext(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonSessionStateService>;
+}
+
+declare namespace TaonSessionUtils {
+    const getRequestMetadata: (req: TaonServerMiddlewareInterceptOptions$1["req"]) => {
+        userAgent?: string;
+        ip?: string;
+        deviceName?: string;
+    };
+    function verifyGoogleAuthorizationCode(GOOGLE_CLIENT_ID: string, GOOGLE_CLIENT_SECRET: string, code: string): Promise<{
+        sub: string;
+        email: string;
+        emailVerified: true;
+        name: string;
+        picture: string;
+    }>;
+}
+
+declare namespace TaonSessionValidator {
+    const passwordMatchValidator: ValidatorFn;
+}
+
+declare class TaonSessionUserIdentityRepository extends TaonBaseRepository<TaonSessionUserIdentityEntity> {
+    entityClassResolveFn: () => typeof TaonSessionUserIdentityEntity;
+    private readonly userRepository;
+    private readonly sessionProvider;
+    normalizeEmail(email: string): string;
+    findUserIdByEmail(email: string, manager?: EntityManager): Promise<number | undefined>;
+    resolveSocialIdentity(provider: TaonSessionIdentityProvider, providerUserId: string, email: string, isEmailVerified: boolean): Promise<TaonSessionUserIdentityEntity>;
+    registerPasswordUser(email: string, password: string): Promise<TaonSessionUserEntity | null>;
+    connectPasswordIdentity(userId: number, email: string, password: string): Promise<void>;
+    createPasswordIdentity(userId: number, email: string, password: string): Promise<TaonSessionUserIdentityEntity>;
+    private passwordIdentity;
+    findPasswordIdentity(email: string): Promise<TaonSessionUserIdentityEntity | null>;
+    verifyPassword(email: string, password: string): Promise<TaonSessionUserIdentityEntity | null>;
+    findSocialIdentity(provider: TaonSessionIdentityProvider, providerUserId: string): Promise<TaonSessionUserIdentityEntity | null>;
+    createSocialIdentity(userId: number, provider: TaonSessionIdentityProvider, providerUserId: string, email?: string, isEmailVerified?: boolean, manager?: EntityManager): Promise<TaonSessionUserIdentityEntity>;
+}
+
+type TaonBackofficeEntity = 'user' | 'group' | 'role' | 'permission' | 'session';
+declare class TaonBackofficeNavigationService {
+    private readonly router;
+    private readonly route;
+    detailsLink(entity: TaonBackofficeEntity, id: number | string): UrlTree;
+    openDetails(entity: TaonBackofficeEntity, id: number | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonBackofficeNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonBackofficeNavigationService>;
+}
+
+declare class TaonGroupBackofficeComponent {
+    readonly taonGroupApiService: TaonGroupApiService;
+    readonly navigation: TaonBackofficeNavigationService;
+    get crud(): session_websql.TaonGroupController;
+    readonly columns: MtxGridColumn[];
+    add(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonGroupBackofficeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonGroupBackofficeComponent, "app-taon-group-backoffice", never, {}, {}, never, never, true, never>;
+}
+
+declare namespace TaonGroupBackofficeModels {
+    type AssignedRoleRow = {
+        groupId: number;
+        roleId: number;
+        name: string;
+        code: string;
+        description?: string;
+    };
 }
 
-export { APP_ID, BUILD_BASE_HREF, BUILD_FRAMEWORK_CLI_NAME, CURRENT_PACKAGE_TAON_VERSION, CURRENT_PACKAGE_VERSION, ENV_ANGULAR_NODE_APP_BUILD_BASE_HREF, ENV_ANGULAR_NODE_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_ANGULAR_NODE_APP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_ANGULAR_NODE_APP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_ANGULAR_NODE_APP_BUILD_PROD, ENV_ANGULAR_NODE_APP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_ANGULAR_NODE_APP_BUILD_PWA_NAME, ENV_ANGULAR_NODE_APP_BUILD_PWA_SHORT_NAME, ENV_ANGULAR_NODE_APP_BUILD_PWA_START_URL, ENV_ANGULAR_NODE_APP_BUILD_SSR, ENV_ANGULAR_NODE_APP_BUILD_WATCH, ENV_ANGULAR_NODE_APP_BUILD_WEBSQL, ENV_ANGULAR_NODE_APP_CONTAINER_END, ENV_ANGULAR_NODE_APP_CONTAINER_ONLY, ENV_ANGULAR_NODE_APP_CONTAINER_SKIP, ENV_ANGULAR_NODE_APP_CONTAINER_SKIP_RELEASED, ENV_ANGULAR_NODE_APP_CONTAINER_START, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_SKIP, ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER, ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER, ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB, ENV_ANGULAR_NODE_APP_INIT_BRANDING, ENV_ANGULAR_NODE_APP_INIT_STRUCT, ENV_ANGULAR_NODE_APP_IS_CI_PROCESS, ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_ANGULAR_NODE_APP_PURPOSE, ENV_ANGULAR_NODE_APP_RECURSIVE_ACTION, ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_ANGULAR_NODE_APP_RELEASE_CLI_COMPRESS, ENV_ANGULAR_NODE_APP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_ANGULAR_NODE_APP_RELEASE_CLI_MINIFY, ENV_ANGULAR_NODE_APP_RELEASE_CLI_OBSCURE, ENV_ANGULAR_NODE_APP_RELEASE_CLI_UGLIFY, ENV_ANGULAR_NODE_APP_RELEASE_ENV_NAME, ENV_ANGULAR_NODE_APP_RELEASE_ENV_NUMBER, ENV_ANGULAR_NODE_APP_RELEASE_INSTALL_LOCALLY, ENV_ANGULAR_NODE_APP_RELEASE_LIB_COMPRESS, ENV_ANGULAR_NODE_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_ANGULAR_NODE_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_ANGULAR_NODE_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_ANGULAR_NODE_APP_RELEASE_LIB_REMOVE_DTS, ENV_ANGULAR_NODE_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_ANGULAR_NODE_APP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_ANGULAR_NODE_APP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_TYPE, ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_ANGULAR_NODE_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_ANGULAR_NODE_APP_RELEASE_RESOLVED_NEW_VERSION, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_CODE_CUTTING, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_DEPLOY, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_NPM_PUBLISH, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RELEASE_QUESTION, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_ANGULAR_NODE_APP_RELEASE_TAON_INSTANCE_IP, ENV_ANGULAR_NODE_APP_RELEASE_TARGET_ARTIFACT, ENV_ANGULAR_NODE_APP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_ANGULAR_NODE_APP_WEBSITE_DOMAIN, ENV_ANGULAR_NODE_APP_WEBSITE_TITLE, ENV_ANGULAR_NODE_APP_WEBSITE_USE_DOMAIN, ENV_DOCS_WEBAPP_BUILD_BASE_HREF, ENV_DOCS_WEBAPP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_DOCS_WEBAPP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_DOCS_WEBAPP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_DOCS_WEBAPP_BUILD_PROD, ENV_DOCS_WEBAPP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_DOCS_WEBAPP_BUILD_PWA_NAME, ENV_DOCS_WEBAPP_BUILD_PWA_SHORT_NAME, ENV_DOCS_WEBAPP_BUILD_PWA_START_URL, ENV_DOCS_WEBAPP_BUILD_SSR, ENV_DOCS_WEBAPP_BUILD_WATCH, ENV_DOCS_WEBAPP_BUILD_WEBSQL, ENV_DOCS_WEBAPP_CONTAINER_END, ENV_DOCS_WEBAPP_CONTAINER_ONLY, ENV_DOCS_WEBAPP_CONTAINER_SKIP, ENV_DOCS_WEBAPP_CONTAINER_SKIP_RELEASED, ENV_DOCS_WEBAPP_CONTAINER_START, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_SKIP, ENV_DOCS_WEBAPP_DOCKER_ADDITIONAL_CONTAINER, ENV_DOCS_WEBAPP_DOCKER_SKIP_START_IN_ORDER, ENV_DOCS_WEBAPP_DOCKER_SKIP_USING_MYSQL_DB, ENV_DOCS_WEBAPP_INIT_BRANDING, ENV_DOCS_WEBAPP_INIT_STRUCT, ENV_DOCS_WEBAPP_IS_CI_PROCESS, ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_DOCS_WEBAPP_PURPOSE, ENV_DOCS_WEBAPP_RECURSIVE_ACTION, ENV_DOCS_WEBAPP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_DOCS_WEBAPP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_DOCS_WEBAPP_RELEASE_CLI_COMPRESS, ENV_DOCS_WEBAPP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_DOCS_WEBAPP_RELEASE_CLI_MINIFY, ENV_DOCS_WEBAPP_RELEASE_CLI_OBSCURE, ENV_DOCS_WEBAPP_RELEASE_CLI_UGLIFY, ENV_DOCS_WEBAPP_RELEASE_ENV_NAME, ENV_DOCS_WEBAPP_RELEASE_ENV_NUMBER, ENV_DOCS_WEBAPP_RELEASE_INSTALL_LOCALLY, ENV_DOCS_WEBAPP_RELEASE_LIB_COMPRESS, ENV_DOCS_WEBAPP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_DOCS_WEBAPP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_DOCS_WEBAPP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_DOCS_WEBAPP_RELEASE_LIB_REMOVE_DTS, ENV_DOCS_WEBAPP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_DOCS_WEBAPP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_DOCS_WEBAPP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_DOCS_WEBAPP_RELEASE_RELEASE_TYPE, ENV_DOCS_WEBAPP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_DOCS_WEBAPP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_DOCS_WEBAPP_RELEASE_RESOLVED_NEW_VERSION, ENV_DOCS_WEBAPP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_DOCS_WEBAPP_RELEASE_SKIP_CODE_CUTTING, ENV_DOCS_WEBAPP_RELEASE_SKIP_DEPLOY, ENV_DOCS_WEBAPP_RELEASE_SKIP_NPM_PUBLISH, ENV_DOCS_WEBAPP_RELEASE_SKIP_RELEASE_QUESTION, ENV_DOCS_WEBAPP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_DOCS_WEBAPP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_DOCS_WEBAPP_RELEASE_TAON_INSTANCE_IP, ENV_DOCS_WEBAPP_RELEASE_TARGET_ARTIFACT, ENV_DOCS_WEBAPP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_DOCS_WEBAPP_WEBSITE_DOMAIN, ENV_DOCS_WEBAPP_WEBSITE_TITLE, ENV_DOCS_WEBAPP_WEBSITE_USE_DOMAIN, ENV_ELECTRON_APP_BUILD_BASE_HREF, ENV_ELECTRON_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_ELECTRON_APP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_ELECTRON_APP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_ELECTRON_APP_BUILD_PROD, ENV_ELECTRON_APP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_ELECTRON_APP_BUILD_PWA_NAME, ENV_ELECTRON_APP_BUILD_PWA_SHORT_NAME, ENV_ELECTRON_APP_BUILD_PWA_START_URL, ENV_ELECTRON_APP_BUILD_SSR, ENV_ELECTRON_APP_BUILD_WATCH, ENV_ELECTRON_APP_BUILD_WEBSQL, ENV_ELECTRON_APP_CONTAINER_END, ENV_ELECTRON_APP_CONTAINER_ONLY, ENV_ELECTRON_APP_CONTAINER_SKIP, ENV_ELECTRON_APP_CONTAINER_SKIP_RELEASED, ENV_ELECTRON_APP_CONTAINER_START, ENV_ELECTRON_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_ELECTRON_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_ELECTRON_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_ELECTRON_APP_COPY_TO_MANAGER_SKIP, ENV_ELECTRON_APP_DOCKER_ADDITIONAL_CONTAINER, ENV_ELECTRON_APP_DOCKER_SKIP_START_IN_ORDER, ENV_ELECTRON_APP_DOCKER_SKIP_USING_MYSQL_DB, ENV_ELECTRON_APP_INIT_BRANDING, ENV_ELECTRON_APP_INIT_STRUCT, ENV_ELECTRON_APP_IS_CI_PROCESS, ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_ELECTRON_APP_PURPOSE, ENV_ELECTRON_APP_RECURSIVE_ACTION, ENV_ELECTRON_APP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_ELECTRON_APP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_ELECTRON_APP_RELEASE_CLI_COMPRESS, ENV_ELECTRON_APP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_ELECTRON_APP_RELEASE_CLI_MINIFY, ENV_ELECTRON_APP_RELEASE_CLI_OBSCURE, ENV_ELECTRON_APP_RELEASE_CLI_UGLIFY, ENV_ELECTRON_APP_RELEASE_ENV_NAME, ENV_ELECTRON_APP_RELEASE_ENV_NUMBER, ENV_ELECTRON_APP_RELEASE_INSTALL_LOCALLY, ENV_ELECTRON_APP_RELEASE_LIB_COMPRESS, ENV_ELECTRON_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_ELECTRON_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_ELECTRON_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_ELECTRON_APP_RELEASE_LIB_REMOVE_DTS, ENV_ELECTRON_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_ELECTRON_APP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_ELECTRON_APP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_ELECTRON_APP_RELEASE_RELEASE_TYPE, ENV_ELECTRON_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_ELECTRON_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_ELECTRON_APP_RELEASE_RESOLVED_NEW_VERSION, ENV_ELECTRON_APP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_ELECTRON_APP_RELEASE_SKIP_CODE_CUTTING, ENV_ELECTRON_APP_RELEASE_SKIP_DEPLOY, ENV_ELECTRON_APP_RELEASE_SKIP_NPM_PUBLISH, ENV_ELECTRON_APP_RELEASE_SKIP_RELEASE_QUESTION, ENV_ELECTRON_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_ELECTRON_APP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_ELECTRON_APP_RELEASE_TAON_INSTANCE_IP, ENV_ELECTRON_APP_RELEASE_TARGET_ARTIFACT, ENV_ELECTRON_APP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_ELECTRON_APP_WEBSITE_DOMAIN, ENV_ELECTRON_APP_WEBSITE_TITLE, ENV_ELECTRON_APP_WEBSITE_USE_DOMAIN, ENV_MOBILE_APP_BUILD_BASE_HREF, ENV_MOBILE_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_MOBILE_APP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_MOBILE_APP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_MOBILE_APP_BUILD_PROD, ENV_MOBILE_APP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_MOBILE_APP_BUILD_PWA_NAME, ENV_MOBILE_APP_BUILD_PWA_SHORT_NAME, ENV_MOBILE_APP_BUILD_PWA_START_URL, ENV_MOBILE_APP_BUILD_SSR, ENV_MOBILE_APP_BUILD_WATCH, ENV_MOBILE_APP_BUILD_WEBSQL, ENV_MOBILE_APP_CONTAINER_END, ENV_MOBILE_APP_CONTAINER_ONLY, ENV_MOBILE_APP_CONTAINER_SKIP, ENV_MOBILE_APP_CONTAINER_SKIP_RELEASED, ENV_MOBILE_APP_CONTAINER_START, ENV_MOBILE_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_MOBILE_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_MOBILE_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_MOBILE_APP_COPY_TO_MANAGER_SKIP, ENV_MOBILE_APP_DOCKER_ADDITIONAL_CONTAINER, ENV_MOBILE_APP_DOCKER_SKIP_START_IN_ORDER, ENV_MOBILE_APP_DOCKER_SKIP_USING_MYSQL_DB, ENV_MOBILE_APP_INIT_BRANDING, ENV_MOBILE_APP_INIT_STRUCT, ENV_MOBILE_APP_IS_CI_PROCESS, ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_MOBILE_APP_PURPOSE, ENV_MOBILE_APP_RECURSIVE_ACTION, ENV_MOBILE_APP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_MOBILE_APP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_MOBILE_APP_RELEASE_CLI_COMPRESS, ENV_MOBILE_APP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_MOBILE_APP_RELEASE_CLI_MINIFY, ENV_MOBILE_APP_RELEASE_CLI_OBSCURE, ENV_MOBILE_APP_RELEASE_CLI_UGLIFY, ENV_MOBILE_APP_RELEASE_ENV_NAME, ENV_MOBILE_APP_RELEASE_ENV_NUMBER, ENV_MOBILE_APP_RELEASE_INSTALL_LOCALLY, ENV_MOBILE_APP_RELEASE_LIB_COMPRESS, ENV_MOBILE_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_MOBILE_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_MOBILE_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_MOBILE_APP_RELEASE_LIB_REMOVE_DTS, ENV_MOBILE_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_MOBILE_APP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_MOBILE_APP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_MOBILE_APP_RELEASE_RELEASE_TYPE, ENV_MOBILE_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_MOBILE_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_MOBILE_APP_RELEASE_RESOLVED_NEW_VERSION, ENV_MOBILE_APP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_MOBILE_APP_RELEASE_SKIP_CODE_CUTTING, ENV_MOBILE_APP_RELEASE_SKIP_DEPLOY, ENV_MOBILE_APP_RELEASE_SKIP_NPM_PUBLISH, ENV_MOBILE_APP_RELEASE_SKIP_RELEASE_QUESTION, ENV_MOBILE_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_MOBILE_APP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_MOBILE_APP_RELEASE_TAON_INSTANCE_IP, ENV_MOBILE_APP_RELEASE_TARGET_ARTIFACT, ENV_MOBILE_APP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_MOBILE_APP_WEBSITE_DOMAIN, ENV_MOBILE_APP_WEBSITE_TITLE, ENV_MOBILE_APP_WEBSITE_USE_DOMAIN, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_BASE_HREF, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_GEN_ONLY_CLIENT_CODE, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_OVERRIDE_OUTPUT_PATH, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PROD, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_NAME, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_SHORT_NAME, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_START_URL, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_SSR, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_WATCH, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_WEBSQL, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_END, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_ONLY, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_SKIP, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_SKIP_RELEASED, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_START, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_SKIP, ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_ADDITIONAL_CONTAINER, ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_START_IN_ORDER, ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_USING_MYSQL_DB, ENV_NPM_LIB_AND_CLI_TOOL_INIT_BRANDING, ENV_NPM_LIB_AND_CLI_TOOL_INIT_STRUCT, ENV_NPM_LIB_AND_CLI_TOOL_IS_CI_PROCESS, ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_NPM_LIB_AND_CLI_TOOL_PURPOSE, ENV_NPM_LIB_AND_CLI_TOOL_RECURSIVE_ACTION, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_COMPRESS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_MINIFY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_OBSCURE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_UGLIFY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_ENV_NAME, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_ENV_NUMBER, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_INSTALL_LOCALLY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_COMPRESS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_REMOVE_DTS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_RELEASE_TYPE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_RESOLVED_NEW_VERSION, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_CODE_CUTTING, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_DEPLOY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_NPM_PUBLISH, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_RELEASE_QUESTION, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_TAG_GIT_PUSH, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_TAON_INSTANCE_IP, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_TARGET_ARTIFACT, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_DOMAIN, ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_TITLE, ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_USE_DOMAIN, ENV_VSCODE_PLUGIN_BUILD_BASE_HREF, ENV_VSCODE_PLUGIN_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_VSCODE_PLUGIN_BUILD_GEN_ONLY_CLIENT_CODE, ENV_VSCODE_PLUGIN_BUILD_OVERRIDE_OUTPUT_PATH, ENV_VSCODE_PLUGIN_BUILD_PROD, ENV_VSCODE_PLUGIN_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_VSCODE_PLUGIN_BUILD_PWA_NAME, ENV_VSCODE_PLUGIN_BUILD_PWA_SHORT_NAME, ENV_VSCODE_PLUGIN_BUILD_PWA_START_URL, ENV_VSCODE_PLUGIN_BUILD_SSR, ENV_VSCODE_PLUGIN_BUILD_WATCH, ENV_VSCODE_PLUGIN_BUILD_WEBSQL, ENV_VSCODE_PLUGIN_CONTAINER_END, ENV_VSCODE_PLUGIN_CONTAINER_ONLY, ENV_VSCODE_PLUGIN_CONTAINER_SKIP, ENV_VSCODE_PLUGIN_CONTAINER_SKIP_RELEASED, ENV_VSCODE_PLUGIN_CONTAINER_START, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_SKIP, ENV_VSCODE_PLUGIN_DOCKER_ADDITIONAL_CONTAINER, ENV_VSCODE_PLUGIN_DOCKER_SKIP_START_IN_ORDER, ENV_VSCODE_PLUGIN_DOCKER_SKIP_USING_MYSQL_DB, ENV_VSCODE_PLUGIN_INIT_BRANDING, ENV_VSCODE_PLUGIN_INIT_STRUCT, ENV_VSCODE_PLUGIN_IS_CI_PROCESS, ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_VSCODE_PLUGIN_PURPOSE, ENV_VSCODE_PLUGIN_RECURSIVE_ACTION, ENV_VSCODE_PLUGIN_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_VSCODE_PLUGIN_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_VSCODE_PLUGIN_RELEASE_CLI_COMPRESS, ENV_VSCODE_PLUGIN_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_VSCODE_PLUGIN_RELEASE_CLI_MINIFY, ENV_VSCODE_PLUGIN_RELEASE_CLI_OBSCURE, ENV_VSCODE_PLUGIN_RELEASE_CLI_UGLIFY, ENV_VSCODE_PLUGIN_RELEASE_ENV_NAME, ENV_VSCODE_PLUGIN_RELEASE_ENV_NUMBER, ENV_VSCODE_PLUGIN_RELEASE_INSTALL_LOCALLY, ENV_VSCODE_PLUGIN_RELEASE_LIB_COMPRESS, ENV_VSCODE_PLUGIN_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_VSCODE_PLUGIN_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_VSCODE_PLUGIN_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_VSCODE_PLUGIN_RELEASE_LIB_REMOVE_DTS, ENV_VSCODE_PLUGIN_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_VSCODE_PLUGIN_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_VSCODE_PLUGIN_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_VSCODE_PLUGIN_RELEASE_RELEASE_TYPE, ENV_VSCODE_PLUGIN_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_VSCODE_PLUGIN_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_VSCODE_PLUGIN_RELEASE_RESOLVED_NEW_VERSION, ENV_VSCODE_PLUGIN_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_VSCODE_PLUGIN_RELEASE_SKIP_CODE_CUTTING, ENV_VSCODE_PLUGIN_RELEASE_SKIP_DEPLOY, ENV_VSCODE_PLUGIN_RELEASE_SKIP_NPM_PUBLISH, ENV_VSCODE_PLUGIN_RELEASE_SKIP_RELEASE_QUESTION, ENV_VSCODE_PLUGIN_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_VSCODE_PLUGIN_RELEASE_SKIP_TAG_GIT_PUSH, ENV_VSCODE_PLUGIN_RELEASE_TAON_INSTANCE_IP, ENV_VSCODE_PLUGIN_RELEASE_TARGET_ARTIFACT, ENV_VSCODE_PLUGIN_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_VSCODE_PLUGIN_WEBSITE_DOMAIN, ENV_VSCODE_PLUGIN_WEBSITE_TITLE, ENV_VSCODE_PLUGIN_WEBSITE_USE_DOMAIN, PROJECT_NPM_NAME, TaonSession, TaonSessionApiService, TaonSessionComponent, TaonSessionContext, TaonSessionController, TaonSessionKvRepository, TaonSessionMiddleware, TaonSessionProvider, TaonSessionUser, TaonSessionUserRepository, TaonSessionUtils, myOrgProj, startCli };
+declare const TaonGroupBackofficeRoutes: Routes;
+
+declare class TaonGroupDetailsComponent implements OnChanges {
+    group: TaonGroupEntity;
+    readonly navigation: TaonBackofficeNavigationService;
+    ngOnChanges(): void;
+    taonGroupApiService: TaonGroupApiService;
+    readonly roleRowsByGroupId: i0.WritableSignal<Record<number, TaonGroupBackofficeModels.AssignedRoleRow[]>>;
+    readonly roleChooserGroupId: i0.WritableSignal<number>;
+    /**
+     * Stable reference, so that nested datatables do not reload on every
+     * change detection cycle while roles are not loaded yet.
+     */
+    private readonly emptyRoleRows;
+    private readonly emptyIds;
+    private readonly assignedRoleIdsByGroupId;
+    roleColumns: MtxGridColumn[];
+    roleRowsFor(groupId: number): TaonGroupBackofficeModels.AssignedRoleRow[];
+    assignedRoleIds(groupId: number): number[];
+    openRoleChooser(groupId: number): void;
+    closeRoleChooser(): void;
+    roleAssigned(groupId: number): void;
+    loadRolesForGroup(groupId: number): Promise<void>;
+    unassignRole(row: TaonGroupBackofficeModels.AssignedRoleRow): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonGroupDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonGroupDetailsComponent, "taon-group-details", never, { "group": { "alias": "group"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TaonGroupChooserComponent {
+    private readonly taonGroupApiService;
+    userId: number;
+    excludedGroupIds: number[];
+    readonly assigned: EventEmitter<number>;
+    readonly cancelled: EventEmitter<void>;
+    readonly groups: i0.WritableSignal<TaonGroupEntity[]>;
+    readonly loading: i0.WritableSignal<boolean>;
+    readonly saving: i0.WritableSignal<boolean>;
+    selectedGroupId?: number;
+    constructor();
+    get availableGroups(): TaonGroupEntity[];
+    loadGroups(): Promise<void>;
+    assign(): Promise<void>;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonGroupChooserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonGroupChooserComponent, "taon-group-chooser", never, { "userId": { "alias": "userId"; "required": true; }; "excludedGroupIds": { "alias": "excludedGroupIds"; "required": false; }; }, { "assigned": "assigned"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class TaonPermissionBackofficeComponent {
+    readonly navigation: TaonBackofficeNavigationService;
+    taonPermissionApiService: TaonPermissionApiService;
+    get crud(): session_websql.TaonPermissionController;
+    columns: MtxGridColumn[];
+    add(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonPermissionBackofficeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonPermissionBackofficeComponent, "app-taon-permission-backoffice", never, {}, {}, never, never, true, never>;
+}
+
+declare namespace TaonPermissionBackofficeModels { }
+
+declare const TaonPermissionBackofficeRoutes: Routes;
+
+declare class TaonPermissionDetailsComponent {
+    permission: TaonPermissionEntity;
+    readonly navigation: TaonBackofficeNavigationService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonPermissionDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonPermissionDetailsComponent, "taon-permission-details", never, { "permission": { "alias": "permission"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TaonPermissionChooserComponent {
+    private readonly taonPermissionApiService;
+    private readonly taonRoleApiService;
+    roleId: number;
+    excludedPermissionIds: number[];
+    readonly assigned: EventEmitter<number>;
+    readonly cancelled: EventEmitter<void>;
+    readonly permissions: i0.WritableSignal<TaonPermissionEntity[]>;
+    readonly loading: i0.WritableSignal<boolean>;
+    readonly saving: i0.WritableSignal<boolean>;
+    selectedPermissionId?: number;
+    constructor();
+    get availablePermissions(): TaonPermissionEntity[];
+    loadPermissions(): Promise<void>;
+    assign(): Promise<void>;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonPermissionChooserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonPermissionChooserComponent, "taon-permission-chooser", never, { "roleId": { "alias": "roleId"; "required": true; }; "excludedPermissionIds": { "alias": "excludedPermissionIds"; "required": false; }; }, { "assigned": "assigned"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class TaonPermissionViewEditComponent {
+    private readonly taonPermissionApiService;
+    set permission(value: TaonPermissionEntity);
+    get permission(): TaonPermissionEntity;
+    readonly descriptionChanged: EventEmitter<string>;
+    private _permission;
+    readonly description: i0.WritableSignal<string>;
+    readonly draftDescription: i0.WritableSignal<string>;
+    readonly editMode: i0.WritableSignal<boolean>;
+    readonly saving: i0.WritableSignal<boolean>;
+    edit(): void;
+    cancel(): void;
+    save(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonPermissionViewEditComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonPermissionViewEditComponent, "taon-permission-view-edit", never, { "permission": { "alias": "permission"; "required": true; }; }, { "descriptionChanged": "descriptionChanged"; }, never, never, true, never>;
+}
+
+declare class TaonRoleBackofficeComponent {
+    readonly taonRoleApiService: TaonRoleApiService;
+    readonly navigation: TaonBackofficeNavigationService;
+    get crud(): session_websql.TaonRoleController;
+    readonly columns: MtxGridColumn[];
+    add(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonRoleBackofficeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonRoleBackofficeComponent, "app-taon-role-backoffice", never, {}, {}, never, never, true, never>;
+}
+
+declare namespace TaonRoleBackofficeModels {
+    type AssignedPermissionRow = {
+        roleId: number;
+        permissionId: number;
+        name: string;
+        code: string;
+        description?: string;
+    };
+}
+
+declare const TaonRoleBackofficeRoutes: Routes;
+
+declare class TaonRoleDetailsComponent implements OnChanges {
+    role: TaonRoleEntity;
+    readonly navigation: TaonBackofficeNavigationService;
+    ngOnChanges(): void;
+    taonRoleApiService: TaonRoleApiService;
+    readonly permissionRowsByRoleId: i0.WritableSignal<Record<number, TaonRoleBackofficeModels.AssignedPermissionRow[]>>;
+    readonly permissionChooserRoleId: i0.WritableSignal<number>;
+    /**
+     * Stable reference, so that nested datatables do not reload on every
+     * change detection cycle while permissions are not loaded yet.
+     */
+    private readonly emptyPermissionRows;
+    private readonly emptyIds;
+    private readonly assignedPermissionIdsByRoleId;
+    permissionColumns: MtxGridColumn[];
+    permissionRowsFor(roleId: number): TaonRoleBackofficeModels.AssignedPermissionRow[];
+    assignedPermissionIds(roleId: number): number[];
+    openPermissionChooser(roleId: number): void;
+    closePermissionChooser(): void;
+    permissionAssigned(roleId: number): void;
+    loadPermissionsForRole(roleId: number): Promise<void>;
+    unassignPermission(row: TaonRoleBackofficeModels.AssignedPermissionRow): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonRoleDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonRoleDetailsComponent, "taon-role-details", never, { "role": { "alias": "role"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TaonRoleChooserComponent {
+    private readonly taonRoleApiService;
+    private readonly taonGroupApiService;
+    groupId: number;
+    excludedRoleIds: number[];
+    readonly assigned: EventEmitter<number>;
+    readonly cancelled: EventEmitter<void>;
+    readonly roles: i0.WritableSignal<TaonRoleEntity[]>;
+    readonly loading: i0.WritableSignal<boolean>;
+    readonly saving: i0.WritableSignal<boolean>;
+    selectedRoleId?: number;
+    constructor();
+    get availableRoles(): TaonRoleEntity[];
+    loadRoles(): Promise<void>;
+    assign(): Promise<void>;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonRoleChooserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonRoleChooserComponent, "taon-role-chooser", never, { "groupId": { "alias": "groupId"; "required": true; }; "excludedRoleIds": { "alias": "excludedRoleIds"; "required": false; }; }, { "assigned": "assigned"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare const TaonProfileAbstractContext: {
+    readonly contextName: string;
+    readonly expressApp: express.Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<taon_websql.Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<taon_websql.Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => any;
+    __ref(): Promise<taon_websql.EndpointContext>;
+    readonly __refSync: taon_websql.EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: taon_websql.Models.TaonInitializeParams) => Promise<taon_websql.EndpointContext>;
+    readonly realtime: {
+        readonly client: taon_websql.RealtimeClient;
+        readonly server: taon_websql.RealtimeServer;
+    };
+};
+
+declare namespace TaonProfileModels {
+    const PROFILE_PICTURE_FILE_NAME = "profile-picture";
+    interface PictureQuery {
+        userId?: number;
+    }
+    function pictureKey(userId?: number | string): string;
+    const PROFILE_PICTURE_ACCEPT = "image/png,image/jpeg,image/webp,image/gif";
+}
+
+declare class TaonProfileController extends TaonBaseStorageController<TaonProfileModels.PictureQuery> {
+    private readonly taonSessionRepository;
+    private readonly authRepository;
+    private readonly userRepository;
+    beforeEachRequest({ req, res, methodConfig, classConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonProfileController>): Promise<void>;
+    protected handleUploadFiles(bodyFormDataFiles: TaonUploadedFile[], queryParams?: TaonProfileModels.PictureQuery, req?: ExpressRequest<any>, res?: ExpressResponse<any>): Promise<TaonStorageObject[]>;
+    afterFileUploadHook(fileObject?: TaonStorageObject, queryParams?: TaonProfileModels.PictureQuery): Promise<void>;
+    buildStorageDownloadUrl(options: {
+        req: any;
+        key: string;
+        private: boolean;
+        token?: string;
+    }): string;
+    createStorageDownloadToken(options: {
+        key: string;
+        expiresAt: number;
+    }): Promise<string>;
+}
+
+declare class TaonProfileApiService extends TaonBaseAngularService {
+    readonly taonProfileController: TaonProfileController;
+    hasProfilePicture(userId?: number | string): Promise<boolean>;
+    getProfilePictureBlob(userId?: number | string): Promise<Blob | undefined>;
+    uploadProfilePicture(file: File, userId?: number | string): Promise<void>;
+    deleteProfilePicture(userId?: number | string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonProfileApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonProfileApiService>;
+}
+
+declare class TaonTaonProfileConfig extends TaonBaseClass {
+    name: string;
+}
+declare class TaonProfileProvider extends TaonBaseProvider {
+    enabledTaonProfileOption: boolean;
+    config: TaonTaonProfileConfig;
+    clone(): {
+        enabledTaonProfileOption: boolean;
+        config: any;
+    };
+}
+
+declare class TaonProfileConfigService extends TaonBaseAngularService {
+    private taonProfileProvider;
+    clone(): Partial<TaonProfileProvider>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonProfileConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonProfileConfigService>;
+}
+
+declare class TaonProfileEntity extends TaonBaseAbstractEntity<TaonProfileEntity> {
+    description?: string;
+}
+
+declare const TaonProfileDefaultsValues: Partial<TaonProfileEntity>;
+declare enum TaonProfileErrors {
+    INVALID_PASSWORD_EXAMPLE_ERROR = "INVALID_PASSWORD_EXAMPLE_ERROR"
+}
+declare const TaonProfileTranslationErorsMap: Map<TaonProfileErrors, string>;
+
+declare class TaonProfileKvRepository extends TaonBaseKvRepository<{
+    usersToNotify: TaonProfileEntity[];
+}> {
+    notifyUsers(users: TaonProfileEntity[]): Promise<void>;
+}
+
+declare namespace TaonSessionBackofficeModels {
+    type SessionRow = Pick<TaonSessionEntity, 'id' | 'userId' | 'deviceName' | 'ip'>;
+    type SessionDetails = SessionRow & Pick<TaonSessionEntity, 'identityId' | 'authenticationProvider' | 'userAgent' | 'createdAt' | 'lastActivityAt' | 'expiresAt' | 'revokedAt' | 'revokeReason'> & {
+        user: Pick<TaonSessionUserEntity, 'id' | 'username'> | null;
+        identity: Pick<TaonSessionUserIdentityEntity, 'id' | 'email' | 'provider'> | null;
+    };
+}
+
+type TaonBackofficeDetail = {
+    kind: 'user';
+    entity: TaonSessionUserEntity;
+} | {
+    kind: 'group';
+    entity: TaonGroupEntity;
+} | {
+    kind: 'role';
+    entity: TaonRoleEntity;
+} | {
+    kind: 'permission';
+    entity: TaonPermissionEntity;
+} | {
+    kind: 'session';
+    entity: TaonSessionBackofficeModels.SessionDetails;
+};
+declare const taonBackofficeDetailsResolver: ResolveFn<TaonBackofficeDetail>;
+
+declare class TaonBackofficeDetailsPageComponent {
+    readonly detail$: rxjs.Observable<TaonBackofficeDetail>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonBackofficeDetailsPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonBackofficeDetailsPageComponent, "taon-backoffice-details-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class TaonSessionBackofficeController extends TaonBaseCrudController<TaonSessionBackofficeModels.SessionRow, {}, TaonSessionBackofficeController> {
+    entityClassResolveFn: () => typeof TaonSessionEntity;
+    private readonly taonSessionRepository;
+    private readonly taonAuthContextRepository;
+    private readonly taonSessionUserRepository;
+    private readonly taonSessionUserIdentityRepository;
+    beforeEachRequest({ req, res, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionBackofficeController>): Promise<void>;
+    protected defaultPaginationQuery(query: TaonPaginationQuery<TaonSessionBackofficeController>): Promise<[TaonSessionBackofficeModels.SessionRow[], number]>;
+    getBy(id: number | string): Taon.Response<TaonSessionBackofficeModels.SessionDetails>;
+}
+
+declare class TaonSessionBackofficeApiService extends TaonBaseAngularService {
+    readonly taonSessionBackofficeController: TaonSessionBackofficeController;
+    getSessionDetails(id: number): Promise<TaonSessionBackofficeModels.SessionDetails>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionBackofficeApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonSessionBackofficeApiService>;
+}
+
+declare class TaonSessionBackofficeComponent {
+    readonly t: Translation;
+    readonly taonSessionBackofficeApiService: TaonSessionBackofficeApiService;
+    readonly taonBackofficeNavigationService: TaonBackofficeNavigationService;
+    get crud(): session_websql.TaonSessionBackofficeController;
+    readonly columns: MtxGridColumn[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionBackofficeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionBackofficeComponent, "app-taon-session-backoffice", never, {}, {}, never, never, true, never>;
+}
+
+declare const TaonSessionBackofficeRoutes: Routes;
+
+declare class TaonSessionDetailsComponent implements OnChanges {
+    readonly t: Translation;
+    sessionId: number;
+    detail?: TaonSessionBackofficeModels.SessionDetails;
+    readonly taonBackofficeNavigationService: TaonBackofficeNavigationService;
+    private readonly taonSessionBackofficeApiService;
+    readonly session: i0.WritableSignal<TaonSessionBackofficeModels.SessionDetails>;
+    readonly loading: i0.WritableSignal<boolean>;
+    readonly error: i0.WritableSignal<string>;
+    private requestId;
+    ngOnChanges(): void;
+    private loadDetails;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionDetailsComponent, "taon-session-details", never, { "sessionId": { "alias": "sessionId"; "required": true; }; "detail": { "alias": "detail"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TaonSessionButtonComponent implements OnInit {
+    protected readonly taonSessionStateService: TaonSessionStateService;
+    protected readonly taonSessionConfigService: TaonSessionConfigService;
+    config: TaonSessionConfig;
+    private readonly dialog;
+    private readonly router;
+    constructor();
+    openLogin(): void;
+    goDashboard(): void;
+    profile(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionButtonComponent, "taon-session-button", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TaonSessionBackofficeUsersComponent {
+    readonly userApiService: TaonSessionUserApiService;
+    readonly navigation: TaonBackofficeNavigationService;
+    get crud(): session_websql.TaonSessionUserController;
+    readonly columns: MtxGridColumn[];
+    add(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionBackofficeUsersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionBackofficeUsersComponent, "app-taon-session-backoffice-users", never, {}, {}, never, never, true, never>;
+}
+
+declare namespace TaonSessionBackofficeUsersModels {
+    type AssignedGroupRoleRow = {
+        roleId: number;
+        name: string;
+    };
+    type AssignedGroupRow = {
+        userId: number;
+        groupId: number;
+        name: string;
+        code: string;
+        description?: string;
+        roles: AssignedGroupRoleRow[];
+    };
+}
+
+declare const TaonSessionBackofficeUsersRoutes: Routes;
+
+declare class TaonSessionUserDetailsComponent implements OnChanges {
+    user: TaonSessionUserEntity;
+    readonly navigation: TaonBackofficeNavigationService;
+    readonly taonSessionApiService: TaonSessionApiService;
+    context$: rxjs.Observable<session_websql.TaonAuthContextEntity<{
+        group: string;
+        role: string;
+        permission: string;
+    }>>;
+    ngOnChanges(): void;
+    private readonly taonGroupApiService;
+    readonly groupRowsByUserId: i0.WritableSignal<Record<number, TaonSessionBackofficeUsersModels.AssignedGroupRow[]>>;
+    readonly groupChooserUserId: i0.WritableSignal<number>;
+    /**
+     * Stable reference, so that nested datatables do not reload on every
+     * change detection cycle while groups are not loaded yet.
+     */
+    private readonly emptyGroupRows;
+    private readonly emptyIds;
+    private readonly assignedGroupIdsByUserId;
+    identityColumns: MtxGridColumn[];
+    groupColumns: MtxGridColumn[];
+    groupRowsFor(userId: number): TaonSessionBackofficeUsersModels.AssignedGroupRow[];
+    assignedGroupIds(userId: number): number[];
+    openGroupChooser(userId: number): void;
+    closeGroupChooser(): void;
+    groupAssigned(userId: number): void;
+    loadGroupsForUser(userId: number): Promise<void>;
+    unassignGroup(row: TaonSessionBackofficeUsersModels.AssignedGroupRow): Promise<void>;
+    private roleRowsFromGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionUserDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionUserDetailsComponent, "taon-session-user-details", never, { "user": { "alias": "user"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TaonProfilePictureComponent implements OnDestroy, OnInit, OnChanges {
+    hideButtons: boolean;
+    userId?: number | string;
+    readOnly: boolean;
+    readonly t: Translation;
+    private readonly taonProfileApiService;
+    readonly pictureUrl: i0.WritableSignal<string>;
+    readonly loading: i0.WritableSignal<boolean>;
+    readonly uploading: i0.WritableSignal<boolean>;
+    readonly accept = "image/png,image/jpeg,image/webp,image/gif";
+    private objectUrl?;
+    private destroyed;
+    private loadVersion;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    loadProfilePicture(): Promise<void>;
+    fileSelected(event: Event): Promise<void>;
+    removePicture(): Promise<void>;
+    private setPictureBlob;
+    private clearPictureUrl;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonProfilePictureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonProfilePictureComponent, "taon-profile-picture", never, { "hideButtons": { "alias": "hideButtons"; "required": false; }; "userId": { "alias": "userId"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare namespace TaonProfilePictureModels { }
+
+declare const TaonProfilePictureRoutes: Routes;
+
+declare class GoogleLoginRegisterButtonComponent {
+    t: Translation;
+    googleSignIn: EventEmitter<void>;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleLoginRegisterButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GoogleLoginRegisterButtonComponent, "google-login-register-button", never, {}, { "googleSignIn": "googleSignIn"; }, never, never, true, never>;
+}
+
+declare class TaonSessionProfileComponent {
+    t: Translation;
+    TaonSessionIdentityProvider: typeof TaonSessionIdentityProvider;
+    config: TaonSessionConfig;
+    protected readonly taonSessionApiService: TaonSessionApiService;
+    readonly taonSessionStateService: TaonSessionStateService;
+    readonly context$: rxjs.Observable<session_websql.TaonAuthContextEntity<{
+        group: string;
+        role: string;
+        permission: string;
+    }>>;
+    readonly usernameForm: FormGroup<{
+        username: FormControl<string>;
+    }>;
+    readonly passwordForm: FormGroup<{
+        email: FormControl<string>;
+        password: FormControl<string>;
+        passwordRepeat: FormControl<string>;
+    }>;
+    readonly savingUsername: i0.WritableSignal<boolean>;
+    readonly usernameError: i0.WritableSignal<string>;
+    readonly usernameSaved: i0.WritableSignal<boolean>;
+    readonly showPasswordForm: i0.WritableSignal<boolean>;
+    readonly savingPassword: i0.WritableSignal<boolean>;
+    readonly passwordError: i0.WritableSignal<string>;
+    get isVisibleGoogle(): boolean;
+    get isVisibleApple(): boolean;
+    get isVisibleMicrosoft(): boolean;
+    get isVisibleFacebook(): boolean;
+    get isVisibleGithub(): boolean;
+    /**
+     * Email/password can be connected only when the user currently
+     * has no PASSWORD identity.
+     *
+     * In practice this means an account created purely through
+     * social authentication.
+     */
+    readonly canConnectEmail$: rxjs.Observable<boolean>;
+    readonly canConnectGoogle$: rxjs.Observable<boolean>;
+    readonly canConnectGithub$: rxjs.Observable<boolean>;
+    readonly canConnectApple$: rxjs.Observable<boolean>;
+    readonly canConnectMicrosoft$: rxjs.Observable<boolean>;
+    readonly canConnectFacebook$: rxjs.Observable<boolean>;
+    readonly logout: EventEmitter<void>;
+    readonly dialog: MatDialog;
+    onLogout(): void;
+    disconnect(provider: TaonSessionIdentityProvider): void;
+    connectEmail(user?: TaonSessionUserEntity | null): void;
+    savePassword(): Promise<void>;
+    saveUsername(): Promise<void>;
+    private googleCodeClient?;
+    connectGoogle(): void;
+    private initGoogleLogin;
+    private connectGoogleIdenitty;
+    connectApple(): void;
+    connectMicrosoft(): void;
+    connectFacebook(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonSessionProfileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonSessionProfileComponent, "taon-session-profile", never, { "config": { "alias": "config"; "required": false; }; }, { "logout": "logout"; }, never, never, true, never>;
+}
+
+declare namespace TaonSessionProfileModels { }
+
+declare const DEFAULT_SESSION_PASSWORD = "ddd";
+declare const DEFAULT_SESSION_EMAIL = "test@test.com";
+
+export { APP_ID, BUILD_BASE_HREF, BUILD_FRAMEWORK_CLI_NAME, CURRENT_PACKAGE_TAON_VERSION, CURRENT_PACKAGE_VERSION, DEFAULT_SESSION_EMAIL, DEFAULT_SESSION_PASSWORD, ENV_ANGULAR_NODE_APP_BUILD_BASE_HREF, ENV_ANGULAR_NODE_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_ANGULAR_NODE_APP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_ANGULAR_NODE_APP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_ANGULAR_NODE_APP_BUILD_PROD, ENV_ANGULAR_NODE_APP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_ANGULAR_NODE_APP_BUILD_PWA_NAME, ENV_ANGULAR_NODE_APP_BUILD_PWA_SHORT_NAME, ENV_ANGULAR_NODE_APP_BUILD_PWA_START_URL, ENV_ANGULAR_NODE_APP_BUILD_SSR, ENV_ANGULAR_NODE_APP_BUILD_WATCH, ENV_ANGULAR_NODE_APP_BUILD_WEBSQL, ENV_ANGULAR_NODE_APP_CONFIG_GOOGLE_CLIENT_ID, ENV_ANGULAR_NODE_APP_CONFIG_GOOGLE_SECRET, ENV_ANGULAR_NODE_APP_CONFIG_SUPER_USERS, ENV_ANGULAR_NODE_APP_CONTAINER_END, ENV_ANGULAR_NODE_APP_CONTAINER_ONLY, ENV_ANGULAR_NODE_APP_CONTAINER_SKIP, ENV_ANGULAR_NODE_APP_CONTAINER_SKIP_RELEASED, ENV_ANGULAR_NODE_APP_CONTAINER_START, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_SKIP, ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER, ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER, ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB, ENV_ANGULAR_NODE_APP_FINISH_CALLBACK, ENV_ANGULAR_NODE_APP_INIT_BRANDING, ENV_ANGULAR_NODE_APP_INIT_STRUCT, ENV_ANGULAR_NODE_APP_IS_CI_PROCESS, ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_ANGULAR_NODE_APP_PURPOSE, ENV_ANGULAR_NODE_APP_RECURSIVE_ACTION, ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_ANGULAR_NODE_APP_RELEASE_CLI_COMPRESS, ENV_ANGULAR_NODE_APP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_ANGULAR_NODE_APP_RELEASE_CLI_MINIFY, ENV_ANGULAR_NODE_APP_RELEASE_CLI_OBSCURE, ENV_ANGULAR_NODE_APP_RELEASE_CLI_UGLIFY, ENV_ANGULAR_NODE_APP_RELEASE_ENV_NAME, ENV_ANGULAR_NODE_APP_RELEASE_ENV_NUMBER, ENV_ANGULAR_NODE_APP_RELEASE_INSTALL_LOCALLY, ENV_ANGULAR_NODE_APP_RELEASE_LIB_COMPRESS, ENV_ANGULAR_NODE_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_ANGULAR_NODE_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_ANGULAR_NODE_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_ANGULAR_NODE_APP_RELEASE_LIB_REMOVE_DTS, ENV_ANGULAR_NODE_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_ANGULAR_NODE_APP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_ANGULAR_NODE_APP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_TYPE, ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_ANGULAR_NODE_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_ANGULAR_NODE_APP_RELEASE_RESOLVED_NEW_VERSION, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_CODE_CUTTING, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_DEPLOY, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_NPM_PUBLISH, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RELEASE_QUESTION, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_ANGULAR_NODE_APP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_ANGULAR_NODE_APP_RELEASE_TAON_INSTANCE_IP, ENV_ANGULAR_NODE_APP_RELEASE_TARGET_ARTIFACT, ENV_ANGULAR_NODE_APP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_ANGULAR_NODE_APP_WEBSITE_DOMAIN, ENV_ANGULAR_NODE_APP_WEBSITE_TITLE, ENV_ANGULAR_NODE_APP_WEBSITE_USE_DOMAIN, ENV_DOCS_WEBAPP_BUILD_BASE_HREF, ENV_DOCS_WEBAPP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_DOCS_WEBAPP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_DOCS_WEBAPP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_DOCS_WEBAPP_BUILD_PROD, ENV_DOCS_WEBAPP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_DOCS_WEBAPP_BUILD_PWA_NAME, ENV_DOCS_WEBAPP_BUILD_PWA_SHORT_NAME, ENV_DOCS_WEBAPP_BUILD_PWA_START_URL, ENV_DOCS_WEBAPP_BUILD_SSR, ENV_DOCS_WEBAPP_BUILD_WATCH, ENV_DOCS_WEBAPP_BUILD_WEBSQL, ENV_DOCS_WEBAPP_CONFIG_GOOGLE_CLIENT_ID, ENV_DOCS_WEBAPP_CONFIG_GOOGLE_SECRET, ENV_DOCS_WEBAPP_CONFIG_SUPER_USERS, ENV_DOCS_WEBAPP_CONTAINER_END, ENV_DOCS_WEBAPP_CONTAINER_ONLY, ENV_DOCS_WEBAPP_CONTAINER_SKIP, ENV_DOCS_WEBAPP_CONTAINER_SKIP_RELEASED, ENV_DOCS_WEBAPP_CONTAINER_START, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_DOCS_WEBAPP_COPY_TO_MANAGER_SKIP, ENV_DOCS_WEBAPP_DOCKER_ADDITIONAL_CONTAINER, ENV_DOCS_WEBAPP_DOCKER_SKIP_START_IN_ORDER, ENV_DOCS_WEBAPP_DOCKER_SKIP_USING_MYSQL_DB, ENV_DOCS_WEBAPP_FINISH_CALLBACK, ENV_DOCS_WEBAPP_INIT_BRANDING, ENV_DOCS_WEBAPP_INIT_STRUCT, ENV_DOCS_WEBAPP_IS_CI_PROCESS, ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_DOCS_WEBAPP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_DOCS_WEBAPP_PURPOSE, ENV_DOCS_WEBAPP_RECURSIVE_ACTION, ENV_DOCS_WEBAPP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_DOCS_WEBAPP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_DOCS_WEBAPP_RELEASE_CLI_COMPRESS, ENV_DOCS_WEBAPP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_DOCS_WEBAPP_RELEASE_CLI_MINIFY, ENV_DOCS_WEBAPP_RELEASE_CLI_OBSCURE, ENV_DOCS_WEBAPP_RELEASE_CLI_UGLIFY, ENV_DOCS_WEBAPP_RELEASE_ENV_NAME, ENV_DOCS_WEBAPP_RELEASE_ENV_NUMBER, ENV_DOCS_WEBAPP_RELEASE_INSTALL_LOCALLY, ENV_DOCS_WEBAPP_RELEASE_LIB_COMPRESS, ENV_DOCS_WEBAPP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_DOCS_WEBAPP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_DOCS_WEBAPP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_DOCS_WEBAPP_RELEASE_LIB_REMOVE_DTS, ENV_DOCS_WEBAPP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_DOCS_WEBAPP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_DOCS_WEBAPP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_DOCS_WEBAPP_RELEASE_RELEASE_TYPE, ENV_DOCS_WEBAPP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_DOCS_WEBAPP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_DOCS_WEBAPP_RELEASE_RESOLVED_NEW_VERSION, ENV_DOCS_WEBAPP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_DOCS_WEBAPP_RELEASE_SKIP_CODE_CUTTING, ENV_DOCS_WEBAPP_RELEASE_SKIP_DEPLOY, ENV_DOCS_WEBAPP_RELEASE_SKIP_NPM_PUBLISH, ENV_DOCS_WEBAPP_RELEASE_SKIP_RELEASE_QUESTION, ENV_DOCS_WEBAPP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_DOCS_WEBAPP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_DOCS_WEBAPP_RELEASE_TAON_INSTANCE_IP, ENV_DOCS_WEBAPP_RELEASE_TARGET_ARTIFACT, ENV_DOCS_WEBAPP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_DOCS_WEBAPP_WEBSITE_DOMAIN, ENV_DOCS_WEBAPP_WEBSITE_TITLE, ENV_DOCS_WEBAPP_WEBSITE_USE_DOMAIN, ENV_ELECTRON_APP_BUILD_BASE_HREF, ENV_ELECTRON_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_ELECTRON_APP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_ELECTRON_APP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_ELECTRON_APP_BUILD_PROD, ENV_ELECTRON_APP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_ELECTRON_APP_BUILD_PWA_NAME, ENV_ELECTRON_APP_BUILD_PWA_SHORT_NAME, ENV_ELECTRON_APP_BUILD_PWA_START_URL, ENV_ELECTRON_APP_BUILD_SSR, ENV_ELECTRON_APP_BUILD_WATCH, ENV_ELECTRON_APP_BUILD_WEBSQL, ENV_ELECTRON_APP_CONFIG_GOOGLE_CLIENT_ID, ENV_ELECTRON_APP_CONFIG_GOOGLE_SECRET, ENV_ELECTRON_APP_CONFIG_SUPER_USERS, ENV_ELECTRON_APP_CONTAINER_END, ENV_ELECTRON_APP_CONTAINER_ONLY, ENV_ELECTRON_APP_CONTAINER_SKIP, ENV_ELECTRON_APP_CONTAINER_SKIP_RELEASED, ENV_ELECTRON_APP_CONTAINER_START, ENV_ELECTRON_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_ELECTRON_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_ELECTRON_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_ELECTRON_APP_COPY_TO_MANAGER_SKIP, ENV_ELECTRON_APP_DOCKER_ADDITIONAL_CONTAINER, ENV_ELECTRON_APP_DOCKER_SKIP_START_IN_ORDER, ENV_ELECTRON_APP_DOCKER_SKIP_USING_MYSQL_DB, ENV_ELECTRON_APP_FINISH_CALLBACK, ENV_ELECTRON_APP_INIT_BRANDING, ENV_ELECTRON_APP_INIT_STRUCT, ENV_ELECTRON_APP_IS_CI_PROCESS, ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_ELECTRON_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_ELECTRON_APP_PURPOSE, ENV_ELECTRON_APP_RECURSIVE_ACTION, ENV_ELECTRON_APP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_ELECTRON_APP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_ELECTRON_APP_RELEASE_CLI_COMPRESS, ENV_ELECTRON_APP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_ELECTRON_APP_RELEASE_CLI_MINIFY, ENV_ELECTRON_APP_RELEASE_CLI_OBSCURE, ENV_ELECTRON_APP_RELEASE_CLI_UGLIFY, ENV_ELECTRON_APP_RELEASE_ENV_NAME, ENV_ELECTRON_APP_RELEASE_ENV_NUMBER, ENV_ELECTRON_APP_RELEASE_INSTALL_LOCALLY, ENV_ELECTRON_APP_RELEASE_LIB_COMPRESS, ENV_ELECTRON_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_ELECTRON_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_ELECTRON_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_ELECTRON_APP_RELEASE_LIB_REMOVE_DTS, ENV_ELECTRON_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_ELECTRON_APP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_ELECTRON_APP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_ELECTRON_APP_RELEASE_RELEASE_TYPE, ENV_ELECTRON_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_ELECTRON_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_ELECTRON_APP_RELEASE_RESOLVED_NEW_VERSION, ENV_ELECTRON_APP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_ELECTRON_APP_RELEASE_SKIP_CODE_CUTTING, ENV_ELECTRON_APP_RELEASE_SKIP_DEPLOY, ENV_ELECTRON_APP_RELEASE_SKIP_NPM_PUBLISH, ENV_ELECTRON_APP_RELEASE_SKIP_RELEASE_QUESTION, ENV_ELECTRON_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_ELECTRON_APP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_ELECTRON_APP_RELEASE_TAON_INSTANCE_IP, ENV_ELECTRON_APP_RELEASE_TARGET_ARTIFACT, ENV_ELECTRON_APP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_ELECTRON_APP_WEBSITE_DOMAIN, ENV_ELECTRON_APP_WEBSITE_TITLE, ENV_ELECTRON_APP_WEBSITE_USE_DOMAIN, ENV_MOBILE_APP_BUILD_BASE_HREF, ENV_MOBILE_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_MOBILE_APP_BUILD_GEN_ONLY_CLIENT_CODE, ENV_MOBILE_APP_BUILD_OVERRIDE_OUTPUT_PATH, ENV_MOBILE_APP_BUILD_PROD, ENV_MOBILE_APP_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_MOBILE_APP_BUILD_PWA_NAME, ENV_MOBILE_APP_BUILD_PWA_SHORT_NAME, ENV_MOBILE_APP_BUILD_PWA_START_URL, ENV_MOBILE_APP_BUILD_SSR, ENV_MOBILE_APP_BUILD_WATCH, ENV_MOBILE_APP_BUILD_WEBSQL, ENV_MOBILE_APP_CONFIG_GOOGLE_CLIENT_ID, ENV_MOBILE_APP_CONFIG_GOOGLE_SECRET, ENV_MOBILE_APP_CONFIG_SUPER_USERS, ENV_MOBILE_APP_CONTAINER_END, ENV_MOBILE_APP_CONTAINER_ONLY, ENV_MOBILE_APP_CONTAINER_SKIP, ENV_MOBILE_APP_CONTAINER_SKIP_RELEASED, ENV_MOBILE_APP_CONTAINER_START, ENV_MOBILE_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_MOBILE_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_MOBILE_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_MOBILE_APP_COPY_TO_MANAGER_SKIP, ENV_MOBILE_APP_DOCKER_ADDITIONAL_CONTAINER, ENV_MOBILE_APP_DOCKER_SKIP_START_IN_ORDER, ENV_MOBILE_APP_DOCKER_SKIP_USING_MYSQL_DB, ENV_MOBILE_APP_FINISH_CALLBACK, ENV_MOBILE_APP_INIT_BRANDING, ENV_MOBILE_APP_INIT_STRUCT, ENV_MOBILE_APP_IS_CI_PROCESS, ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_MOBILE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_MOBILE_APP_PURPOSE, ENV_MOBILE_APP_RECURSIVE_ACTION, ENV_MOBILE_APP_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_MOBILE_APP_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_MOBILE_APP_RELEASE_CLI_COMPRESS, ENV_MOBILE_APP_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_MOBILE_APP_RELEASE_CLI_MINIFY, ENV_MOBILE_APP_RELEASE_CLI_OBSCURE, ENV_MOBILE_APP_RELEASE_CLI_UGLIFY, ENV_MOBILE_APP_RELEASE_ENV_NAME, ENV_MOBILE_APP_RELEASE_ENV_NUMBER, ENV_MOBILE_APP_RELEASE_INSTALL_LOCALLY, ENV_MOBILE_APP_RELEASE_LIB_COMPRESS, ENV_MOBILE_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_MOBILE_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_MOBILE_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_MOBILE_APP_RELEASE_LIB_REMOVE_DTS, ENV_MOBILE_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_MOBILE_APP_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_MOBILE_APP_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_MOBILE_APP_RELEASE_RELEASE_TYPE, ENV_MOBILE_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_MOBILE_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_MOBILE_APP_RELEASE_RESOLVED_NEW_VERSION, ENV_MOBILE_APP_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_MOBILE_APP_RELEASE_SKIP_CODE_CUTTING, ENV_MOBILE_APP_RELEASE_SKIP_DEPLOY, ENV_MOBILE_APP_RELEASE_SKIP_NPM_PUBLISH, ENV_MOBILE_APP_RELEASE_SKIP_RELEASE_QUESTION, ENV_MOBILE_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_MOBILE_APP_RELEASE_SKIP_TAG_GIT_PUSH, ENV_MOBILE_APP_RELEASE_TAON_INSTANCE_IP, ENV_MOBILE_APP_RELEASE_TARGET_ARTIFACT, ENV_MOBILE_APP_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_MOBILE_APP_WEBSITE_DOMAIN, ENV_MOBILE_APP_WEBSITE_TITLE, ENV_MOBILE_APP_WEBSITE_USE_DOMAIN, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_BASE_HREF, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_GEN_ONLY_CLIENT_CODE, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_OVERRIDE_OUTPUT_PATH, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PROD, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_NAME, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_SHORT_NAME, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_PWA_START_URL, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_SSR, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_WATCH, ENV_NPM_LIB_AND_CLI_TOOL_BUILD_WEBSQL, ENV_NPM_LIB_AND_CLI_TOOL_CONFIG_GOOGLE_CLIENT_ID, ENV_NPM_LIB_AND_CLI_TOOL_CONFIG_GOOGLE_SECRET, ENV_NPM_LIB_AND_CLI_TOOL_CONFIG_SUPER_USERS, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_END, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_ONLY, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_SKIP, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_SKIP_RELEASED, ENV_NPM_LIB_AND_CLI_TOOL_CONTAINER_START, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_NPM_LIB_AND_CLI_TOOL_COPY_TO_MANAGER_SKIP, ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_ADDITIONAL_CONTAINER, ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_START_IN_ORDER, ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_USING_MYSQL_DB, ENV_NPM_LIB_AND_CLI_TOOL_FINISH_CALLBACK, ENV_NPM_LIB_AND_CLI_TOOL_INIT_BRANDING, ENV_NPM_LIB_AND_CLI_TOOL_INIT_STRUCT, ENV_NPM_LIB_AND_CLI_TOOL_IS_CI_PROCESS, ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_NPM_LIB_AND_CLI_TOOL_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_NPM_LIB_AND_CLI_TOOL_PURPOSE, ENV_NPM_LIB_AND_CLI_TOOL_RECURSIVE_ACTION, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_COMPRESS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_MINIFY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_OBSCURE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_CLI_UGLIFY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_ENV_NAME, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_ENV_NUMBER, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_INSTALL_LOCALLY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_COMPRESS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_REMOVE_DTS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_RELEASE_TYPE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_RESOLVED_NEW_VERSION, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_CODE_CUTTING, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_DEPLOY, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_NPM_PUBLISH, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_RELEASE_QUESTION, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_SKIP_TAG_GIT_PUSH, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_TAON_INSTANCE_IP, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_TARGET_ARTIFACT, ENV_NPM_LIB_AND_CLI_TOOL_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_DOMAIN, ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_TITLE, ENV_NPM_LIB_AND_CLI_TOOL_WEBSITE_USE_DOMAIN, ENV_VSCODE_PLUGIN_BUILD_BASE_HREF, ENV_VSCODE_PLUGIN_BUILD_ELECTRON_SHOW_DEV_TOOLS, ENV_VSCODE_PLUGIN_BUILD_GEN_ONLY_CLIENT_CODE, ENV_VSCODE_PLUGIN_BUILD_OVERRIDE_OUTPUT_PATH, ENV_VSCODE_PLUGIN_BUILD_PROD, ENV_VSCODE_PLUGIN_BUILD_PWA_DISABLE_SERVICE_WORKER, ENV_VSCODE_PLUGIN_BUILD_PWA_NAME, ENV_VSCODE_PLUGIN_BUILD_PWA_SHORT_NAME, ENV_VSCODE_PLUGIN_BUILD_PWA_START_URL, ENV_VSCODE_PLUGIN_BUILD_SSR, ENV_VSCODE_PLUGIN_BUILD_WATCH, ENV_VSCODE_PLUGIN_BUILD_WEBSQL, ENV_VSCODE_PLUGIN_CONFIG_GOOGLE_CLIENT_ID, ENV_VSCODE_PLUGIN_CONFIG_GOOGLE_SECRET, ENV_VSCODE_PLUGIN_CONFIG_SUPER_USERS, ENV_VSCODE_PLUGIN_CONTAINER_END, ENV_VSCODE_PLUGIN_CONTAINER_ONLY, ENV_VSCODE_PLUGIN_CONTAINER_SKIP, ENV_VSCODE_PLUGIN_CONTAINER_SKIP_RELEASED, ENV_VSCODE_PLUGIN_CONTAINER_START, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_BEFORE_COPY_HOOK, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_COPY_TO_LOCATIONS, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_COPY_TO_PROJECTS, ENV_VSCODE_PLUGIN_COPY_TO_MANAGER_SKIP, ENV_VSCODE_PLUGIN_DOCKER_ADDITIONAL_CONTAINER, ENV_VSCODE_PLUGIN_DOCKER_SKIP_START_IN_ORDER, ENV_VSCODE_PLUGIN_DOCKER_SKIP_USING_MYSQL_DB, ENV_VSCODE_PLUGIN_FINISH_CALLBACK, ENV_VSCODE_PLUGIN_INIT_BRANDING, ENV_VSCODE_PLUGIN_INIT_STRUCT, ENV_VSCODE_PLUGIN_IS_CI_PROCESS, ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND, ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER, ENV_VSCODE_PLUGIN_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER_NAME, ENV_VSCODE_PLUGIN_PURPOSE, ENV_VSCODE_PLUGIN_RECURSIVE_ACTION, ENV_VSCODE_PLUGIN_RELEASE_AUTO_RELEASE_TASK_NAME, ENV_VSCODE_PLUGIN_RELEASE_AUTO_RELEASE_USING_CONFIG, ENV_VSCODE_PLUGIN_RELEASE_CLI_COMPRESS, ENV_VSCODE_PLUGIN_RELEASE_CLI_INCLUDE_NODE_MODULES, ENV_VSCODE_PLUGIN_RELEASE_CLI_MINIFY, ENV_VSCODE_PLUGIN_RELEASE_CLI_OBSCURE, ENV_VSCODE_PLUGIN_RELEASE_CLI_UGLIFY, ENV_VSCODE_PLUGIN_RELEASE_ENV_NAME, ENV_VSCODE_PLUGIN_RELEASE_ENV_NUMBER, ENV_VSCODE_PLUGIN_RELEASE_INSTALL_LOCALLY, ENV_VSCODE_PLUGIN_RELEASE_LIB_COMPRESS, ENV_VSCODE_PLUGIN_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES, ENV_VSCODE_PLUGIN_RELEASE_LIB_INCLUDE_SOURCE_MAPS, ENV_VSCODE_PLUGIN_RELEASE_LIB_OBSCURE_FILE_BY_FILE, ENV_VSCODE_PLUGIN_RELEASE_LIB_REMOVE_DTS, ENV_VSCODE_PLUGIN_RELEASE_LIB_UGLIFY_FILE_BY_FILE, ENV_VSCODE_PLUGIN_RELEASE_NODE_BACKEND_APP_MINIFY, ENV_VSCODE_PLUGIN_RELEASE_PUSH_TO_ALL_ORIGINS_WHEN_LOCAL_RELEASE_BRANCH, ENV_VSCODE_PLUGIN_RELEASE_RELEASE_TYPE, ENV_VSCODE_PLUGIN_RELEASE_RELEASE_VERSION_BUMP_TYPE, ENV_VSCODE_PLUGIN_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL, ENV_VSCODE_PLUGIN_RELEASE_RESOLVED_NEW_VERSION, ENV_VSCODE_PLUGIN_RELEASE_SKIP_BUILDING_ARTIFACTS, ENV_VSCODE_PLUGIN_RELEASE_SKIP_CODE_CUTTING, ENV_VSCODE_PLUGIN_RELEASE_SKIP_DEPLOY, ENV_VSCODE_PLUGIN_RELEASE_SKIP_NPM_PUBLISH, ENV_VSCODE_PLUGIN_RELEASE_SKIP_RELEASE_QUESTION, ENV_VSCODE_PLUGIN_RELEASE_SKIP_RESOLVING_GIT_CHANGES, ENV_VSCODE_PLUGIN_RELEASE_SKIP_TAG_GIT_PUSH, ENV_VSCODE_PLUGIN_RELEASE_TAON_INSTANCE_IP, ENV_VSCODE_PLUGIN_RELEASE_TARGET_ARTIFACT, ENV_VSCODE_PLUGIN_RELEASE_USE_LOCAL_RELEASE_BRANCH, ENV_VSCODE_PLUGIN_WEBSITE_DOMAIN, ENV_VSCODE_PLUGIN_WEBSITE_TITLE, ENV_VSCODE_PLUGIN_WEBSITE_USE_DOMAIN, GoogleLoginRegisterButtonComponent, MIGRATIONS_CLASSES_FOR_SessionContext, PROJECT_NPM_NAME, TAON_CLOUDFLARE_WORKERS_URLS, TaonAuditEventsApiService, TaonAuditEventsContext, TaonAuditEventsController, TaonAuditEventsDefaultsValues, TaonAuditEventsEntity, TaonAuditEventsMiddleware, TaonAuditEventsProvider, TaonAuditEventsRepository, TaonAuditEventsState, TaonAuditEventsSubscriber, TaonAuditEventsUtils, TaonAuthContextContext, TaonAuthContextEntity, TaonAuthContextRepository, TaonAuthorizationBackofficeComponent, TaonAuthorizationBackofficeModels, TaonAuthorizationBackofficeRoutes, TaonBackofficeDetailsPageComponent, TaonBackofficeNavigationService, TaonErorsMap, TaonGroupApiService, TaonGroupBackofficeComponent, TaonGroupBackofficeModels, TaonGroupBackofficeRoutes, TaonGroupChooserComponent, TaonGroupContext, TaonGroupController, TaonGroupDefaultsValues, TaonGroupDetailsComponent, TaonGroupEntity, TaonGroupMiddleware, TaonGroupProvider, TaonGroupRepository, TaonGroupRoleEntity, TaonGroupRoleRepository, TaonLoginErrors, TaonNotificationApiService, TaonNotificationContext, TaonNotificationController, TaonNotificationDefaultsValues, TaonNotificationEntity, TaonNotificationMiddleware, TaonNotificationProvider, TaonNotificationRecipientEntity, TaonNotificationRepository, TaonNotificationState, TaonNotificationSubscriber, TaonNotificationUtils, TaonPermissionApiService, TaonPermissionBackofficeComponent, TaonPermissionBackofficeModels, TaonPermissionBackofficeRoutes, TaonPermissionChooserComponent, TaonPermissionContext, TaonPermissionController, TaonPermissionDefaultsValues, TaonPermissionDetailsComponent, TaonPermissionEntity, TaonPermissionMiddleware, TaonPermissionProvider, TaonPermissionRepository, TaonPermissionState, TaonPermissionSubscriber, TaonPermissionUtils, TaonPermissionViewEditComponent, TaonProfileAbstractContext, TaonProfileApiService, TaonProfileConfigService, TaonProfileController, TaonProfileDefaultsValues, TaonProfileEntity, TaonProfileErrors, TaonProfileKvRepository, TaonProfileModels, TaonProfilePictureComponent, TaonProfilePictureModels, TaonProfilePictureRoutes, TaonProfileProvider, TaonProfileTranslationErorsMap, TaonRoleApiService, TaonRoleBackofficeComponent, TaonRoleBackofficeModels, TaonRoleBackofficeRoutes, TaonRoleChooserComponent, TaonRoleContext, TaonRoleController, TaonRoleDefaultsValues, TaonRoleDetailsComponent, TaonRoleEntity, TaonRolePermissionEntity, TaonRolePermissionRepository, TaonRoleProvider, TaonRoleRepository, TaonRoleState, TaonSessionAbstractContext, TaonSessionApiService, TaonSessionBackofficeApiService, TaonSessionBackofficeComponent, TaonSessionBackofficeController, TaonSessionBackofficeModels, TaonSessionBackofficeRoutes, TaonSessionBackofficeUsersComponent, TaonSessionBackofficeUsersModels, TaonSessionBackofficeUsersRoutes, TaonSessionButtonComponent, TaonSessionCheckIfHumanConfig, TaonSessionComponent, TaonSessionConfigService, TaonSessionController, TaonSessionCookiesConfig, TaonSessionDetailsComponent, TaonSessionEmailConfirmationConfig, TaonSessionEntity, TaonSessionIdentityProvider, TaonSessionKvRepository, TaonSessionLoginConfig, TaonSessionMiddleware, TaonSessionPasswordRecoveryConfig, TaonSessionPasswordRequirementsConfig, TaonSessionProfileComponent, TaonSessionProfileModels, TaonSessionProvider, TaonSessionRateLimitConfig, TaonSessionRateLimitsConfig, TaonSessionRegistrationConfig, TaonSessionRepository, TaonSessionSecurityConfig, TaonSessionSessionsConfig, TaonSessionSocialLoginConfig, TaonSessionState, TaonSessionStateService, TaonSessionUserApiService, TaonSessionUserContext, TaonSessionUserController, TaonSessionUserDefaultsValues, TaonSessionUserDetailsComponent, TaonSessionUserEntity, TaonSessionUserGroupEntity, TaonSessionUserGroupRepository, TaonSessionUserIdentityEntity, TaonSessionUserIdentityRepository, TaonSessionUserMiddleware, TaonSessionUserProvider, TaonSessionUserRepository, TaonSessionUserRoleEntity, TaonSessionUserState, TaonSessionUserSubscriber, TaonSessionUserUtils, TaonSessionUtils, TaonSessionValidator, TaonTaonProfileConfig, myOrgProj, startCli, taonBackofficeDetailsResolver };
+export type { GoogleCodeResponse, PersistAuthorizationTreeOptions, TaonAuthorizationSchema, TaonBackofficeDetail, TaonBackofficeEntity, TaonLoginData, TaonSessionConfig };