@acorex/connectivity 20.0.23 → 20.1.0

package/fesm2022/acorex-connectivity-api.mjs

@@ -1,16 +1,18 @@
-import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService } from '@acorex/platform/common';
+import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService, AXPRegionalService, AXPFileStorageService, AXPFileStorageStatus } from '@acorex/platform/common';
 import { AXPEntityResolver, AXPEntityStorageService } from '@acorex/platform/layout/entity';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpClient, HttpHeaders } from '@angular/common/http';
 import * as i0 from '@angular/core';
 import { inject, Injectable, NgModule } from '@angular/core';
 import { kebabCase } from 'lodash-es';
-import { firstValueFrom, map, BehaviorSubject, tap, filter, take, of, switchMap, delay } from 'rxjs';
+import { firstValueFrom, catchError, of, map, BehaviorSubject, tap, filter, take, switchMap, delay } from 'rxjs';
 import * as i2 from '@acorex/platform/auth';
-import { AXPSessionService, AXPAuthModule, AXP_TENANT_LOADER, AXP_APPLICATION_LOADER, AXP_PERMISSION_LOADER, AXP_FEATURE_LOADER } from '@acorex/platform/auth';
+import { AXPAuthStrategy, AXPSessionService, AXPAuthModule, AXP_TENANT_LOADER, AXP_APPLICATION_LOADER, AXP_PERMISSION_LOADER, AXP_FEATURE_LOADER } from '@acorex/platform/auth';
 import { STRATEGY_CONFIG_TOKEN } from '@acorex/platform/widgets';
 import * as i1$1 from 'angular-oauth2-oidc';
 import { OAuthService, OAuthModule } from 'angular-oauth2-oidc';
+import { AXUSLocaleProfile, AXIRLocaleProfile } from '@acorex/core/locale';
+import { AXTranslationService } from '@acorex/core/translation';
 import { AXM_AUTH_CONFIG_TOKEN } from '@acorex/modules/auth';
 
 class AXCApiEntityStorageService {
@@ -129,18 +131,404 @@ class AXCApiEntityStorageService {
             };
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXCApiEntityStorageService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXCApiEntityStorageService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiEntityStorageService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiEntityStorageService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXCApiEntityStorageService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiEntityStorageService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
+class AXCRegionalApiService extends AXPRegionalService {
+    constructor() {
+        super(...arguments);
+        this.http = inject(HttpClient);
+        this.languageService = inject(AXTranslationService);
+        //#region ----   API Endpoints   ----
+        this.baseUrl = '/api/regional';
+        //#endregion
+        //#region ----   Fallback Data   ----
+        this.fallbackCountries = [
+            {
+                code: 'US',
+                title: 'United States',
+                native: 'United States',
+                regional: 'en',
+                timezone: 'America/New_York'
+            },
+            {
+                code: 'CA',
+                title: 'Canada',
+                native: 'Canada',
+                regional: 'en',
+                timezone: 'America/Toronto'
+            },
+            {
+                code: 'GB',
+                title: 'United Kingdom',
+                native: 'United Kingdom',
+                regional: 'en',
+                timezone: 'Europe/London'
+            }
+        ];
+        this.fallbackProvinces = [
+            {
+                code: 'CA',
+                title: 'California',
+                native: 'California',
+                timezone: 'America/Los_Angeles'
+            },
+            {
+                code: 'NY',
+                title: 'New York',
+                native: 'New York',
+                timezone: 'America/New_York'
+            },
+            {
+                code: 'ON',
+                title: 'Ontario',
+                native: 'Ontario',
+                timezone: 'America/Toronto'
+            }
+        ];
+        this.fallbackCities = [
+            {
+                code: 'NYC',
+                title: 'New York City',
+                native: 'New York City',
+                timezone: 'America/New_York'
+            },
+            {
+                code: 'LA',
+                title: 'Los Angeles',
+                native: 'Los Angeles',
+                timezone: 'America/Los_Angeles'
+            },
+            {
+                code: 'TOR',
+                title: 'Toronto',
+                native: 'Toronto',
+                timezone: 'America/Toronto'
+            }
+        ];
+        this.fallbackCurrencies = [
+            {
+                code: 'USD',
+                title: 'United States Dollar',
+                symbol: '$',
+                format: '${amount}'
+            },
+            {
+                code: 'CAD',
+                title: 'Canadian Dollar',
+                symbol: 'CA$',
+                format: 'CA${amount}'
+            },
+            {
+                code: 'GBP',
+                title: 'British Pound',
+                symbol: '£',
+                format: '£{amount}'
+            }
+        ];
+        this.fallbackLocaleProfiles = [
+            {
+                ...AXUSLocaleProfile,
+                code: 'en-US',
+                title: 'English (United States)',
+                nativeTitle: 'English (United States)',
+            },
+            {
+                ...AXIRLocaleProfile,
+                code: 'fa-IR',
+                title: 'Persian (Iran)',
+                nativeTitle: 'فارسی (ایران)',
+            }
+        ];
+        this.fallbackLanguages = [
+            {
+                code: 'en',
+                title: 'English'
+            },
+            {
+                code: 'fa',
+                title: 'Persian'
+            },
+            {
+                code: 'es',
+                title: 'Spanish'
+            }
+        ];
+        this.fallbackTimeZones = [
+            {
+                code: 'America/New_York',
+                title: 'Eastern Time (US & Canada)',
+                offset: '-05:00',
+                iana: 'America/New_York',
+                abbr: 'EST'
+            },
+            {
+                code: 'America/Los_Angeles',
+                title: 'Pacific Time (US & Canada)',
+                offset: '-08:00',
+                iana: 'America/Los_Angeles',
+                abbr: 'PST'
+            },
+            {
+                code: 'Europe/London',
+                title: 'Greenwich Mean Time',
+                offset: '+00:00',
+                iana: 'Europe/London',
+                abbr: 'GMT'
+            }
+        ];
+    }
+    //#endregion
+    async getCountries() {
+        const lang = await firstValueFrom(this.languageService.langChanges$);
+        try {
+            const countries = await firstValueFrom(this.http.get(`${this.baseUrl}/countries`).pipe(catchError(() => of(this.fallbackCountries))));
+            return countries.map((country) => {
+                if (lang == country.regional) {
+                    return {
+                        ...country,
+                        title: country.native,
+                    };
+                }
+                else {
+                    return country;
+                }
+            });
+        }
+        catch {
+            return this.fallbackCountries.map((country) => {
+                if (lang == country.regional) {
+                    return {
+                        ...country,
+                        title: country.native,
+                    };
+                }
+                else {
+                    return country;
+                }
+            });
+        }
+    }
+    async getProvinces(countryId) {
+        let params = new HttpParams();
+        if (countryId) {
+            params = params.set('countryId', countryId);
+        }
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/provinces`, { params }).pipe(catchError(() => of(this.fallbackProvinces))));
+        }
+        catch {
+            return this.fallbackProvinces;
+        }
+    }
+    async getCities(filter) {
+        let params = new HttpParams();
+        if (filter?.countryId) {
+            params = params.set('countryId', filter.countryId);
+        }
+        if (filter?.provinceId) {
+            params = params.set('provinceId', filter.provinceId);
+        }
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/cities`, { params }).pipe(catchError(() => of(this.fallbackCities))));
+        }
+        catch {
+            return this.fallbackCities;
+        }
+    }
+    async getCurrencies() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/currencies`).pipe(catchError(() => of(this.fallbackCurrencies))));
+        }
+        catch {
+            return this.fallbackCurrencies;
+        }
+    }
+    async getLocaleProfiles() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/locale-profiles`).pipe(catchError(() => of(this.fallbackLocaleProfiles))));
+        }
+        catch {
+            return this.fallbackLocaleProfiles;
+        }
+    }
+    async getLanguages() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/languages`).pipe(catchError(() => of(this.fallbackLanguages))));
+        }
+        catch {
+            return this.fallbackLanguages;
+        }
+    }
+    async getAvailableLanguages() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/available-languages`).pipe(catchError(() => of(this.fallbackLanguages))));
+        }
+        catch {
+            return this.fallbackLanguages;
+        }
+    }
+    async getBrowserTimeZoneCode() {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    async getTimeZones() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/timezones`).pipe(catchError(() => of(this.fallbackTimeZones))));
+        }
+        catch {
+            return this.fallbackTimeZones;
+        }
+    }
+}
+
+class AXCFileStorageApiService extends AXPFileStorageService {
+    constructor() {
+        super(...arguments);
+        this.http = inject(HttpClient);
+        //#region ----   API Endpoints   ----
+        this.baseUrl = '/api/file-storage';
+        //#endregion
+        //#region ----   Fallback Data   ----
+        this.fallbackFileInfo = {
+            fileId: 'fallback-file-id',
+            refId: 'fallback-ref-id',
+            refType: 'fallback-ref-type',
+            category: 'fallback-category',
+            size: 0,
+            mimeType: 'application/octet-stream',
+            uploadedAt: new Date(),
+            isPublic: true,
+            isPrimary: false,
+            status: AXPFileStorageStatus.Temporary,
+            name: 'fallback-file',
+            binary: new File([''], 'fallback-file'),
+        };
+    }
+    //#endregion
+    async save(request) {
+        try {
+            const formData = new FormData();
+            formData.append('file', request.file);
+            formData.append('refId', request.refId);
+            formData.append('refType', request.refType);
+            formData.append('category', request.category);
+            if (request.name) {
+                formData.append('name', request.name);
+            }
+            if (request.path) {
+                formData.append('path', request.path);
+            }
+            if (request.isPrimary !== undefined) {
+                formData.append('isPrimary', request.isPrimary.toString());
+            }
+            if (request.status) {
+                formData.append('status', request.status);
+            }
+            if (request.metadata) {
+                formData.append('metadata', JSON.stringify(request.metadata));
+            }
+            return await firstValueFrom(this.http.post(`${this.baseUrl}/save`, formData).pipe(catchError(() => of(this.fallbackFileInfo))));
+        }
+        catch {
+            return this.fallbackFileInfo;
+        }
+    }
+    async update(request) {
+        try {
+            const updateData = {
+                metadata: request.metadata,
+            };
+            if (request.path !== undefined) {
+                updateData.path = request.path;
+            }
+            if (request.isPrimary !== undefined) {
+                updateData.isPrimary = request.isPrimary;
+            }
+            return await firstValueFrom(this.http.put(`${this.baseUrl}/update/${request.fileId}`, updateData).pipe(catchError(() => of(this.fallbackFileInfo))));
+        }
+        catch {
+            return this.fallbackFileInfo;
+        }
+    }
+    async find(request) {
+        try {
+            let params = new HttpParams();
+            if (request.refId) {
+                params = params.set('refId', request.refId);
+            }
+            if (request.refType) {
+                params = params.set('refType', request.refType);
+            }
+            if (request.category) {
+                params = params.set('category', request.category);
+            }
+            if (request.mimeType) {
+                params = params.set('mimeType', request.mimeType);
+            }
+            if (request.isPublic !== undefined) {
+                params = params.set('isPublic', request.isPublic.toString());
+            }
+            if (request.isPrimary !== undefined) {
+                params = params.set('isPrimary', request.isPrimary.toString());
+            }
+            if (request.uploadedAtRange) {
+                params = params.set('uploadedAtFrom', request.uploadedAtRange.from.toISOString());
+                params = params.set('uploadedAtTo', request.uploadedAtRange.to.toISOString());
+            }
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/find`, { params }).pipe(catchError(() => of([]))));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getInfo(fileId) {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/info/${fileId}`).pipe(catchError(() => of(this.fallbackFileInfo))));
+        }
+        catch {
+            return this.fallbackFileInfo;
+        }
+    }
+    async remove(fileId) {
+        try {
+            await firstValueFrom(this.http.delete(`${this.baseUrl}/remove/${fileId}`).pipe(catchError(() => of(void 0))));
+        }
+        catch {
+            // Silently fail in fallback mode
+        }
+    }
+    async commit(fileId) {
+        try {
+            await firstValueFrom(this.http.post(`${this.baseUrl}/commit/${fileId}`, {}).pipe(catchError(() => of(void 0))));
+        }
+        catch {
+            // Silently fail in fallback mode
+        }
+    }
+    async markForDeletion(fileId) {
+        try {
+            await firstValueFrom(this.http.post(`${this.baseUrl}/mark-for-deletion/${fileId}`, {}).pipe(catchError(() => of(void 0))));
+        }
+        catch {
+            // Silently fail in fallback mode
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCFileStorageApiService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCFileStorageApiService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCFileStorageApiService, decorators: [{
+            type: Injectable
+        }] });
+
 class AXMOidcApplicationLoader {
     constructor(http) {
         this.http = http;
         this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.apiGetApps = `${this.configs.baseUrl}/applications/GetListByTenantId`;
+        this.apiGetApps = `${this.configs.baseUrl}/applications/applications-for-current-tenant`;
         this.apiSetApp = `${this.configs.baseUrl}/SetApplication`;
     }
     getList() {
@@ -177,10 +565,10 @@ class AXMOidcApplicationLoader {
             // features: item.features || [],
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcApplicationLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcApplicationLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
@@ -220,10 +608,10 @@ class AXMConfigurationService {
             switchMap(() => of(this.applicationConfig)));
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMConfigurationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -250,11 +638,13 @@ class AXMOidcFeatureLoader {
     }
 }
 
-class AXMOidcStrategy {
+class AXCAPIOidcStrategy extends AXPAuthStrategy {
     constructor() {
+        super(...arguments);
         this.aXMAuthConfigs = inject(AXM_AUTH_CONFIG_TOKEN);
         this.oauthService = inject(OAuthService);
         this.http = inject(HttpClient);
+        this.sessionService = inject(AXPSessionService);
     }
     async configureOAuth() {
         if (this.openidConfigurationInfo)
@@ -284,148 +674,310 @@ class AXMOidcStrategy {
         if (oidcJson) {
             const authData = JSON.parse(oidcJson);
             if (authData) {
-                this.setServiceProps(authData);
+                this.sessionService.setSession(authData);
                 if (authData.expiresIn && new Date(authData.expiresIn) < new Date()) {
                     if (authData.expiresIn) {
-                        // this.refresh();
+                        this.sessionService.refreshToken();
                     }
                     else {
-                        this.logout();
+                        this.signout();
                     }
                 }
             }
         }
     }
     async signin(credentials) {
-        await this.configureOAuth();
-        try {
-            const body = new HttpParams()
-                .set('grant_type', 'password')
-                .set('client_id', this.authConfig.clientId)
-                .set('client_secret', this.authConfig.dummyClientSecret)
-                .set('username', credentials.username)
-                .set('password', credentials.password)
-                .set('scope', this.authConfig.scope);
-            const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
-            const response = await firstValueFrom(this.http.post(this.openidConfigurationInfo.info.discoveryDocument.token_endpoint, body.toString(), { headers }));
-            // const authData = new AuthenticationData(response);
-            this.setServiceProps({
-                accessToken: response.access_token,
-                refreshToken: response.refresh_token,
-                idToken: response.id_token,
-                expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
-            });
+        // If OIDC with username/password
+        if (credentials.strategy === 'oidc' && credentials.username && credentials.password) {
+            return this.handleOidcPasswordSignin(credentials);
+        }
+        // If OIDC with idToken/accessToken (OAuth callback)
+        if (credentials.strategy === 'oidc' && credentials['idToken'] && credentials['accessToken']) {
+            const payload = JwtUtil.parseJwt(credentials['idToken']);
+            const user = {
+                id: payload['sub'] || payload['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier'] || '',
+                title: payload['name'] || payload['email'] || '',
+                name: payload['name'] || payload['email'] || '',
+                avatar: payload['picture'] || '',
+            };
+            const tenant = payload['tenantid'] || payload['tenant']
+                ? {
+                    id: payload['tenantid'] || payload['tenant'] || '',
+                    name: payload['tenantname'] || 'test',
+                    title: payload['tenanttitle'] || '',
+                }
+                : undefined;
+            const application = payload['applicationid'] || payload['application']
+                ? {
+                    id: payload['applicationid'] || payload['application'] || '',
+                    name: payload['applicationname'] || '',
+                    title: payload['applicationtitle'] || '',
+                }
+                : undefined;
             return {
                 succeed: true,
                 data: {
-                    accessToken: response.access_token,
-                    expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
-                    idToken: response.id_token,
-                    refreshToken: response.refresh_token,
-                    user: {
-                        id: response.sub,
-                        title: response.fullname,
-                        name: response.sub,
-                        avatar: response.picture,
-                    },
-                    tenant: {
-                        id: response.tenantid,
-                        name: response.tenantname,
-                        title: response.tenanttitle,
-                    },
-                    application: {
-                        id: response.applicationid,
-                        name: response.applicationname,
-                        title: response.applicationtitle,
-                    },
+                    accessToken: credentials['accessToken'],
+                    refreshToken: credentials['refreshToken'],
+                    idToken: credentials['idToken'],
+                    user,
+                    tenant,
+                    application,
                 },
             };
         }
-        catch (error) {
-            this.handleError(error);
+        throw new Error(`Unsupported authentication strategy or credentials: ${credentials.strategy}`);
+    }
+    /**
+     * Handles OIDC password-based authentication
+     */
+    async handleOidcPasswordSignin(credentials) {
+        await this.configureOAuth();
+        const loginRes = await fetch(this.authConfig.issuer + '/api/auth/manual-login', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ username: credentials.username, password: credentials.password }),
+            credentials: 'include',
+        });
+        if (!loginRes.ok) {
+            let errorText = 'Login failed';
+            try {
+                const errorJson = await loginRes.json();
+                if (errorJson && errorJson.error && errorJson.error.description) {
+                    errorText = errorJson.error.description;
+                }
+            }
+            catch {
+                try {
+                    const text = await loginRes.text();
+                    if (text) {
+                        errorText = text;
+                    }
+                }
+                catch { }
+            }
+            throw new Error(errorText);
         }
+        // Redirect to authorization endpoint (this will reload the page)
+        await this.startAuthorizationFlow('', '');
+        // Return a Promise that never resolves, so the sessionService/component does not proceed
+        return new Promise(() => { });
     }
+    // private async handleOidcPasswordSignin(credentials: AXPUserPassCredentials): Promise<AXPSignInResult> {
+    //   await this.configureOAuth();
+    //   try {
+    //     const body = new HttpParams()
+    //       .set('grant_type', 'password')
+    //       .set('client_id', this.authConfig.clientId!)
+    //       .set('username', credentials.username)
+    //       .set('password', credentials.password)
+    //       .set('scope', this.authConfig.scope!);
+    //     const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+    //     const response = await firstValueFrom(
+    //       this.http.post<IAuthenticationDataModel>(
+    //         this.openidConfigurationInfo.info.discoveryDocument.token_endpoint,
+    //         body.toString(),
+    //         { headers },
+    //       ),
+    //     );
+    //     // Parse id_token to extract user, tenant, and application info
+    //     const payload = JwtUtil.parseJwt(response.id_token);
+    //     const user = {
+    //       id: payload['sub'] || payload['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier'] || '',
+    //       title: payload['name'] || payload['email'] || '',
+    //       name: payload['name'] || payload['email'] || '',
+    //       avatar: payload['picture'] || '',
+    //     } as AXPUser;
+    //     const tenant =
+    //       payload['tenantid'] || payload['tenant']
+    //         ? {
+    //             id: payload['tenantid'] || payload['tenant'] || '',
+    //             name: payload['tenantname'] || '',
+    //             title: payload['tenanttitle'] || '',
+    //           }
+    //         : undefined;
+    //     const application =
+    //       payload['applicationid'] || payload['application']
+    //         ? {
+    //             id: payload['applicationid'] || payload['application'] || '',
+    //             name: payload['applicationname'] || '',
+    //             title: payload['applicationtitle'] || '',
+    //           }
+    //         : undefined;
+    //     return {
+    //       succeed: true,
+    //       data: {
+    //         accessToken: response.access_token,
+    //         expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
+    //         idToken: response.id_token,
+    //         refreshToken: response.refresh_token!,
+    //         user,
+    //         tenant,
+    //         application,
+    //       },
+    //     };
+    //   } catch (error: any) {
+    //     this.handleError(error);
+    //   }
+    // }
     async signout() {
-        //this.logout();
+        localStorage.removeItem('pkce_code_verifier');
+        localStorage.removeItem('oauth_provider');
+        const logoutUrl = `${this.aXMAuthConfigs?.authConfig?.issuer}/api/auth/logout`;
+        await firstValueFrom(this.http.post(logoutUrl, {}, { withCredentials: true }));
     }
     async refreshToken(context) {
         try {
             await this.configureOAuth();
-            const refreshResult = await this.refresh(context.tenant?.id, context.application?.id);
-            if (refreshResult) {
-                return {
-                    succeed: true,
-                    data: {
-                        accessToken: this.oauthService.getAccessToken(),
-                        refreshToken: this.oauthService.getRefreshToken(),
-                    },
-                };
+            if (!this.authConfig || !this.authConfig.clientId) {
+                throw new Error('authConfig or clientId is missing');
             }
-            else {
+            const authData = this.loadAuthData();
+            if (!authData) {
                 return { succeed: false };
             }
-        }
-        catch (error) {
-            console.error('Error refreshing token', error);
-            return { succeed: false };
-        }
-    }
-    async refresh(tenantId, applicationId) {
-        await this.configureOAuth();
-        const authData = this.loadAuthData();
-        if (!authData)
-            return false;
-        const refreshToken = this.oauthService.getRefreshToken();
-        if (!refreshToken)
-            return false;
-        const body = new HttpParams()
-            .set('grant_type', 'refresh_token')
-            .set('client_id', this.authConfig.clientId)
-            .set('client_secret', this.authConfig.dummyClientSecret)
-            .set('refresh_token', refreshToken)
-            .set('tenantId', tenantId ?? '')
-            .set('applicationId', applicationId ?? '');
-        const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
-        try {
+            const refreshToken = authData.refreshToken;
+            if (!refreshToken) {
+                return { succeed: false };
+            }
+            const body = new HttpParams()
+                .set('grant_type', 'refresh_token')
+                .set('client_id', this.authConfig.clientId)
+                .set('refresh_token', refreshToken);
+            const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
             const response = await firstValueFrom(this.http.post(this.openidConfigurationInfo.info.discoveryDocument.token_endpoint, body.toString(), { headers }));
-            this.setServiceProps({
+            // Extract user, tenant, and application from id_token
+            const payload = JwtUtil.parseJwt(response.id_token);
+            const user = {
+                id: payload['sub'] || payload['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier'] || '',
+                title: payload['name'] || payload['email'] || '',
+                name: payload['name'] || payload['email'] || '',
+                avatar: payload['picture'] || '',
+            };
+            const tenant = payload['tenantid'] || payload['tenant']
+                ? {
+                    id: payload['tenantid'] || payload['tenant'] || '',
+                    name: payload['tenantname'] || '',
+                    title: payload['tenanttitle'] || '',
+                }
+                : undefined;
+            const application = payload['applicationid'] || payload['application']
+                ? {
+                    id: payload['applicationid'] || payload['application'] || '',
+                    name: payload['applicationname'] || '',
+                    title: payload['applicationtitle'] || '',
+                }
+                : undefined;
+            const sessionData = {
                 accessToken: response.access_token,
                 refreshToken: response.refresh_token,
                 idToken: response.id_token,
+                strategy: 'oidc',
                 expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
-            });
-            return true;
+                user,
+                tenant,
+                application,
+            };
+            // this.setServiceProps(sessionData);
+            return {
+                succeed: true,
+                data: sessionData,
+            };
         }
         catch (error) {
-            console.error('Token refresh error', error);
-            return false;
+            console.error('Error refreshing token', error);
+            return { succeed: false };
         }
     }
-    expires_in_milisecound(expires_in_date) {
-        const now = new Date();
-        const expire = new Date(expires_in_date);
-        return expire.getTime() - now.getTime();
-    }
-    setServiceProps(authData) {
-        this.oauthService.getAccessToken = () => authData.accessToken;
-        this.oauthService.getIdToken = () => authData.idToken ?? '';
-        this.oauthService.getRefreshToken = () => authData.refreshToken;
-        if (authData.expiresIn) {
-            const refreshTime = this.expires_in_milisecound(authData.expiresIn);
-            this.oauthService.getAccessTokenExpiration = () => refreshTime;
-            // if (refreshTime < 0) {
-            //   this.refresh();
-            // }else{
-            // }
+    /**
+     * Starts the OIDC authorization code flow, redirecting to the authorize endpoint with tenant_id and application_id as query params.
+     */
+    async startAuthorizationFlow(tenantId, applicationId) {
+        if (!this.openidConfigurationInfo) {
+            await this.configureOAuth();
         }
+        // فقط اینجا مقداردهی شود:
+        const codeVerifier = this.generateRandomString(128);
+        localStorage.setItem('pkce_code_verifier', codeVerifier);
+        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
+        const authorizeEndpoint = this.openidConfigurationInfo.info.discoveryDocument.authorization_endpoint;
+        const clientId = this.authConfig.clientId;
+        const redirectUri = this.authConfig.redirectUri;
+        const scope = this.authConfig.scope;
+        const responseType = 'code';
+        const state = Math.random().toString(36).substring(2);
+        const url = `${authorizeEndpoint}?response_type=${encodeURIComponent(responseType)}&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${encodeURIComponent(scope)}&state=${encodeURIComponent(state)}&tenant_id=${encodeURIComponent(tenantId)}&application_id=${encodeURIComponent(applicationId)}&code_challenge=${encodeURIComponent(codeChallenge)}&code_challenge_method=S256`;
+        window.location.href = url;
+    }
+    /**
+     * Unified method to complete the authorization code flow.
+     */
+    async completeAuthorizationCodeFlow(options) {
+        // Ensure OAuth is configured first
+        if (!this.openidConfigurationInfo) {
+            await this.configureOAuth();
+        }
+        const codeVerifier = localStorage.getItem('pkce_code_verifier');
+        localStorage.removeItem('pkce_code_verifier');
+        if (!codeVerifier) {
+            throw new Error('Code verifier not found. Please try signing in again.');
+        }
+        // Removed provider logic
+        const tokenEndpoint = options.tokenEndpoint ||
+            this.openidConfigurationInfo?.info?.discoveryDocument?.token_endpoint ||
+            `${this.aXMAuthConfigs?.authConfig?.issuer}/connect/token`;
+        const clientId = options.clientId || this.authConfig?.clientId || this.aXMAuthConfigs?.authConfig?.clientId || 'spa-client';
+        // Use the passed redirectUri parameter
+        const redirectUri = options.redirectUri;
+        const body = new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: clientId,
+            code_verifier: codeVerifier,
+            code: options.code,
+            redirect_uri: redirectUri,
+        });
+        const response = await fetch(tokenEndpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: body.toString(),
+        });
+        if (!response.ok) {
+            throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
+        }
+        const tokenData = await response.json();
+        const credentials = {
+            strategy: 'oidc',
+            accessToken: tokenData.access_token,
+            refreshToken: tokenData.refresh_token,
+            idToken: tokenData.id_token,
+            // Optionally, you can add user info if your signin supports it
+        };
+        await this.sessionService.signin(credentials);
+    }
+    // Helper methods:
+    generateRandomString(length) {
+        const array = new Uint8Array(length);
+        crypto.getRandomValues(array);
+        return this.base64UrlEncode(array);
+    }
+    async generateCodeChallenge(codeVerifier) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(codeVerifier);
+        const digest = await crypto.subtle.digest('SHA-256', data);
+        return this.base64UrlEncode(new Uint8Array(digest));
+    }
+    base64UrlEncode(array) {
+        return btoa(String.fromCharCode(...array))
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=/g, '');
+    }
+    expires_in_milisecound(expires_in_date) {
+        return new Date(expires_in_date).getTime() - new Date().getTime();
     }
     loadAuthData() {
-        const authDataJson = localStorage.getItem(AXPSessionService.SESSION_KEY);
-        if (!authDataJson)
-            return undefined;
-        const authData = JSON.parse(authDataJson);
-        // return authData ? new AuthenticationData(authData) : undefined;
-        return authData;
+        const sessionData = this.sessionService.getSessionData();
+        return sessionData || undefined;
     }
     async loadUserInfo() {
         return this.oauthService.loadUserProfile();
@@ -433,32 +985,173 @@ class AXMOidcStrategy {
     calculateExpireInDate(expireInMilisecound) {
         return new Date(Date.now() + expireInMilisecound * 1000).toISOString();
     }
-    logout() {
-        this.oauthService.logOut({
-            noRedirectToLogoutUrl: true
-        });
-    }
+    // private logout(): void {
+    //   // this.oauthService.logOut();
+    //   // Use the public signout method instead of private clearSession
+    //   this.sessionService.signout();
+    // }
     handleError(error) {
-        if (error?.reason) {
-            throw new Error(JSON.stringify(error.reason));
-        }
-        else if (error?.message) {
-            throw new Error(error.message);
-        }
-        else {
-            throw new Error('Network or server error occurred');
-        }
+        console.error('Authentication error:', error);
+        throw error;
     }
     //#region getter
     get name() {
-        return 'user-pass';
+        return 'oidc';
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcStrategy }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCAPIOidcStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCAPIOidcStrategy }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCAPIOidcStrategy, decorators: [{
             type: Injectable
         }] });
+class JwtUtil {
+    /**
+     * Decodes a JWT token and returns its payload as an object.
+     * @param token JWT string
+     */
+    static parseJwt(token) {
+        try {
+            return JSON.parse(atob(token.split('.')[1]));
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    static createJwt(payload) {
+        // Create a proper JWT token with header, payload, and signature
+        const header = {
+            alg: 'HS256',
+            typ: 'JWT'
+        };
+        const headerEncoded = JwtUtil.base64url(header);
+        const payloadEncoded = JwtUtil.base64url(payload);
+        const signature = 'mock-signature-for-testing'; // Mock signature
+        const signatureEncoded = JwtUtil.base64url(signature);
+        const idToken = `${headerEncoded}.${payloadEncoded}.${signatureEncoded}`;
+        return idToken;
+    }
+    // For mock, just JSON stringify as the idToken
+    // Convert idTokenPayload to a JWT-like string (header.payload.signature) so jwtutil can parse it
+    // Use base64url encoding for header and payload, and a dummy signature
+    static base64url(obj) {
+        const json = JSON.stringify(obj);
+        // Encode to UTF-8 bytes
+        let utf8 = [];
+        for (let i = 0; i < json.length; i++) {
+            const charcode = json.charCodeAt(i);
+            if (charcode < 0x80)
+                utf8.push(charcode);
+            else if (charcode < 0x800) {
+                utf8.push(0xc0 | (charcode >> 6));
+                utf8.push(0x80 | (charcode & 0x3f));
+            }
+            else if (charcode < 0xd800 || charcode >= 0xe000) {
+                utf8.push(0xe0 | (charcode >> 12));
+                utf8.push(0x80 | ((charcode >> 6) & 0x3f));
+                utf8.push(0x80 | (charcode & 0x3f));
+            }
+            else {
+                // surrogate pair
+                i++;
+                // UTF-16 encodes 0x10000-0x10FFFF by subtracting 0x10000 and
+                // splitting the 20 bits of 0x0-0xFFFFF into two halves
+                const surrogatePair = 0x10000 + (((charcode & 0x3ff) << 10) | (json.charCodeAt(i) & 0x3ff));
+                utf8.push(0xf0 | (surrogatePair >> 18));
+                utf8.push(0x80 | ((surrogatePair >> 12) & 0x3f));
+                utf8.push(0x80 | ((surrogatePair >> 6) & 0x3f));
+                utf8.push(0x80 | (surrogatePair & 0x3f));
+            }
+        }
+        // Manual base64 encoding (no Buffer, no btoa)
+        const base64abc = [
+            'A',
+            'B',
+            'C',
+            'D',
+            'E',
+            'F',
+            'G',
+            'H',
+            'I',
+            'J',
+            'K',
+            'L',
+            'M',
+            'N',
+            'O',
+            'P',
+            'Q',
+            'R',
+            'S',
+            'T',
+            'U',
+            'V',
+            'W',
+            'X',
+            'Y',
+            'Z',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f',
+            'g',
+            'h',
+            'i',
+            'j',
+            'k',
+            'l',
+            'm',
+            'n',
+            'o',
+            'p',
+            'q',
+            'r',
+            's',
+            't',
+            'u',
+            'v',
+            'w',
+            'x',
+            'y',
+            'z',
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            '+',
+            '/',
+        ];
+        let result = '', i;
+        for (i = 0; i + 2 < utf8.length; i += 3) {
+            result += base64abc[utf8[i] >> 2];
+            result += base64abc[((utf8[i] & 0x03) << 4) | (utf8[i + 1] >> 4)];
+            result += base64abc[((utf8[i + 1] & 0x0f) << 2) | (utf8[i + 2] >> 6)];
+            result += base64abc[utf8[i + 2] & 0x3f];
+        }
+        if (i < utf8.length) {
+            result += base64abc[utf8[i] >> 2];
+            if (i === utf8.length - 1) {
+                result += base64abc[(utf8[i] & 0x03) << 4];
+                // result += '==';
+            }
+            else {
+                result += base64abc[((utf8[i] & 0x03) << 4) | (utf8[i + 1] >> 4)];
+                result += base64abc[(utf8[i + 1] & 0x0f) << 2];
+                // result += '=';
+            }
+        }
+        // base64url encoding: replace + with -, / with _, remove =
+        return result.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    }
+}
 
 class AXMOidcPermissionLoader {
     constructor(http) {
@@ -481,10 +1174,10 @@ class AXMOidcPermissionLoader {
         const truePolicies = Object.keys(policies).filter((key) => policies[key] === true);
         return truePolicies;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcPermissionLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcPermissionLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
@@ -492,11 +1185,12 @@ class AXMOidcTenantLoader {
     constructor(http) {
         this.http = http;
         this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.apiGetTenants = `${this.configs.baseUrl}/user-tenants/Tenants`;
-        this.apiSetTenant = `${this.configs.baseUrl}/SetTenant`;
+        this.apiGetTenants = `${this.configs.baseUrl}/tenants/available-for-user`;
     }
     getList() {
-        return this.http.get(this.apiGetTenants).pipe(map((response) => response.items.map((item) => this.mapToAXPTenant(item))));
+        return this.http.get(this.apiGetTenants).pipe(map((response) => response.items.map((item) => {
+            return this.mapToAXPTenant(item);
+        })));
     }
     async set(tenant) {
         return Promise.resolve();
@@ -509,21 +1203,29 @@ class AXMOidcTenantLoader {
             // Add other fields and defaults as needed, and handle the logo if applicable
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcTenantLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
 class AXCApiModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXCApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.7", ngImport: i0, type: AXCApiModule, imports: [i1$1.OAuthModule, i2.AXPAuthModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXCApiModule, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, imports: [i1$1.OAuthModule, i2.AXPAuthModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, providers: [
             {
                 provide: AXPEntityStorageService,
                 useClass: AXCApiEntityStorageService,
             },
+            {
+                provide: AXPRegionalService,
+                useClass: AXCRegionalApiService,
+            },
+            {
+                provide: AXPFileStorageService,
+                useClass: AXCFileStorageApiService,
+            },
             {
                 provide: AXP_TENANT_LOADER,
                 useClass: AXMOidcTenantLoader,
@@ -549,16 +1251,16 @@ class AXCApiModule {
             },
         ], imports: [OAuthModule.forRoot(),
             AXPAuthModule.forRoot({
-                strategies: [AXMOidcStrategy],
+                strategies: [AXCAPIOidcStrategy],
             })] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImport: i0, type: AXCApiModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
                         OAuthModule.forRoot(),
                         AXPAuthModule.forRoot({
-                            strategies: [AXMOidcStrategy],
+                            strategies: [AXCAPIOidcStrategy],
                         }),
                     ],
                     providers: [
@@ -566,6 +1268,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImpor
                             provide: AXPEntityStorageService,
                             useClass: AXCApiEntityStorageService,
                         },
+                        {
+                            provide: AXPRegionalService,
+                            useClass: AXCRegionalApiService,
+                        },
+                        {
+                            provide: AXPFileStorageService,
+                            useClass: AXCFileStorageApiService,
+                        },
                         {
                             provide: AXP_TENANT_LOADER,
                             useClass: AXMOidcTenantLoader,
@@ -597,5 +1307,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcStrategy, AXMOidcTenantLoader };
+export { AXCAPIOidcStrategy, AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcTenantLoader, JwtUtil };
 //# sourceMappingURL=acorex-connectivity-api.mjs.map