@acorex-platform/module-help-desk-client 0.0.21

package/fesm2022/acorex-platform-module-help-desk-client-acorex-platform-module-help-desk-client-OtDtf3iY.mjs

@@ -0,0 +1,783 @@
+import * as i0 from '@angular/core';
+import { computed, Injectable, inject, ApplicationRef, ViewContainerRef, NgModule } from '@angular/core';
+import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+import { AXPStatusProvider } from '@acorex-platform/framework-shared/core';
+import { RootConfig, AXPCollaborationPermissionKeys, AXPHelpDeskMenuKeys } from '@acorex-platform/module-help-desk-client/contracts';
+import * as i1 from '@acorex-platform/framework-client/core';
+import { AXPDataGenerator, AXPEntityBroadcastService, AXPComponentSlotModule, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER } from '@acorex-platform/framework-client/core';
+import { provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import { AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPCommonPermissionGroupKeys, AXPCommonMenuKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { AXPopupService } from '@acorex/components/popup';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXToastService } from '@acorex/components/toast';
+import html2canvas from 'html2canvas';
+import { Subject, take } from 'rxjs';
+
+const AXMLogCaptureService = signalStore({ providedIn: 'root' }, withState(() => {
+    const state = {
+        logs: [],
+        canCapture: false,
+    };
+    return state;
+}), withComputed((store) => ({
+    canCaptureLog: computed(() => store.canCapture()),
+    consoleLogs: computed(() => store.logs()),
+})), withMethods((store) => {
+    const startCapturingLog = () => {
+        patchState(store, { canCapture: true });
+    };
+    const finishCapturingLog = () => {
+        patchState(store, { canCapture: false });
+    };
+    const addConsoleLog = (message) => {
+        patchState(store, {
+            logs: [...store.logs(), { type: 'log', message, timeStamp: new Date().toISOString() }],
+        });
+    };
+    const addConsoleError = (message) => {
+        patchState(store, {
+            logs: [...store.logs(), { type: 'error', message, timeStamp: new Date().toISOString() }],
+        });
+    };
+    const addConsoleWarning = (message) => {
+        patchState(store, {
+            logs: [...store.logs(), { type: 'warning', message, timeStamp: new Date().toISOString() }],
+        });
+    };
+    return {
+        startCapturingLog,
+        finishCapturingLog,
+        addConsoleLog,
+        addConsoleError,
+        addConsoleWarning,
+    };
+}));
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Reported Issues Status Provider   ----
+const status = (name, title, color, options = {}) => ({
+    name,
+    title,
+    color,
+    ...options,
+});
+const workflowCommand = (action) => `${RootConfig.module.name}.${RootConfig.entities.reportedIssues.name}:${action}`;
+/**
+ * Provides lifecycle status definitions for reported issues.
+ */
+class AXMReportedIssuesStatusProvider extends AXPStatusProvider {
+    constructor() {
+        super(...arguments);
+        this.key = 'help-desk.status.reported-issues';
+        this.statuses = [
+            status('new', '@help-desk:reported-issues.states.new', 'info', { isInitial: true, order: 1, generateView: true }),
+            status('in-progress', '@help-desk:reported-issues.states.in-progress', 'primary', { order: 2, generateView: true }),
+            status('pending', '@help-desk:reported-issues.states.pending', 'warning', { order: 3, generateView: true }),
+            status('resolved', '@help-desk:reported-issues.states.resolved', 'success', { order: 4, generateView: true }),
+            status('closed', '@help-desk:reported-issues.states.closed', 'neutral', { isFinal: true, order: 5, generateView: true }),
+        ];
+        this.transitions = [
+            { from: 'new', to: 'in-progress' },
+            { from: 'in-progress', to: 'pending' },
+            { from: 'in-progress', to: 'resolved' },
+            { from: 'pending', to: 'in-progress' },
+            { from: 'pending', to: 'resolved' },
+            { from: 'resolved', to: 'closed' },
+        ];
+        this.defaultStatus = 'new';
+    }
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Help Desk Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const HelpDeskManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'domain',
+    domain: 'operations',
+    // Module dependencies (optional)
+};
+//#endregion
+
+//#endregion
+//#region ----- Permission Provider -----
+/**
+ * Registers help desk capabilities into the shared Collaboration group.
+ */
+class AXMPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPCollaborationPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:collaboration.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.Collaboration.Root, `${G}.collaboration.title`, `${G}.collaboration.description`, { order: 80 });
+        context
+            .addGroup(groups.Collaboration.HelpDesk, `${G}.collaboration-help-desk.title`, `${G}.collaboration-help-desk.description`, { parent: groups.Collaboration.Root, order: 40 })
+            .addPermission(keys.MaintainHelpDesk, `${P}.maintain-help-desk.title`, `${P}.maintain-help-desk.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const keys = AXPCollaborationPermissionKeys;
+        //#region ----   Configuration > Help Desk (Issue Types)   ----
+        const helpDeskConfigMenu = context.find(AXPCommonMenuKeys.HelpDeskConfig);
+        if (!helpDeskConfigMenu.exists) {
+            context.find(AXPCommonMenuKeys.Configuration).addItems([
+                {
+                    name: AXPCommonMenuKeys.HelpDeskConfig,
+                    priority: 8940,
+                    text: '@general:menus.help-desk.title',
+                    icon: module.icon,
+                    type: 'menu',
+                    children: [],
+                    policy: {
+                        features: [module.name],
+                        permissions: [keys.MaintainHelpDesk],
+                    },
+                },
+            ]);
+        }
+        context.find(AXPCommonMenuKeys.HelpDeskConfig).addItems([
+            {
+                name: AXPHelpDeskMenuKeys.IssueTypes,
+                text: '@help-desk:issue-types.menus.issue-types.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.issueType.name),
+                icon: RootConfig.entities.issueType.icon,
+                priority: 1,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainHelpDesk],
+                },
+            },
+        ]);
+        //#endregion
+        //#region ----   Administration > Reported Issues   ----
+        context.find(AXPCommonMenuKeys.Administration).addItems([
+            {
+                name: `${AXPHelpDeskMenuKeys.ReportedIssues}:divider`,
+                text: '',
+                type: 'break',
+                priority: 996,
+            },
+            {
+                name: AXPHelpDeskMenuKeys.ReportedIssues,
+                text: '@help-desk:reported-issues.menus.reported-issues.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.reportedIssues.name),
+                icon: RootConfig.entities.reportedIssues.icon,
+                priority: 997,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainHelpDesk],
+                },
+            },
+        ]);
+        //#endregion
+        //#region ----   Help Menu Extensions (Requests & Issues, Report Issue)   ----
+        context.find(AXPCommonMenuKeys.Help).addItems([
+            {
+                name: AXPHelpDeskMenuKeys.Divider1,
+                text: '',
+                type: 'break',
+                priority: 900004,
+            },
+            {
+                name: AXPHelpDeskMenuKeys.MyReportedIssues,
+                text: '@help-desk:my-reported-issues.menus.my-reported-issues.title',
+                icon: RootConfig.entities.reportedIssues.icon,
+                path: this.entityService.createPath(module.name, RootConfig.entities.reportedIssues.name),
+                priority: 900005,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainHelpDesk],
+                },
+            },
+        ]);
+        //#endregion
+    }
+}
+
+class AXMSettingProvider {
+    async provide(context) {
+        // context
+        //   // Add Form Template Group
+        //   .addGroup('form-template', 'Form Template', 'Settings related to form templates.', RootConfig.module.icon)
+        //   // Start Interface Section
+        //   .addSection('interface', 'UI Interface', 'Customize the user interface for forms.')
+        //   .addSetting({
+        //     key: 'history-panel',
+        //     title: 'Show History Panel',
+        //     scope: 'U',
+        //     isInherited: true,
+        //     defaultValue: false,
+        //     widget: {
+        //       type: AXPWidgetsCatalog.toggle,
+        //     },
+        //     description: 'Enable or disable the history panel for forms.',
+        //     validationRules: [
+        //       {
+        //         rule: 'required',
+        //       },
+        //     ],
+        //   })
+        //   .endSection()
+        //   .endGroup();
+    }
+}
+
+const AXMCaptureScreenService = signalStore({ providedIn: 'root' }, withState(() => {
+    const state = {
+        loading: false,
+        captureMode: 'screenshot',
+        screenshotBlob: '',
+        videoBlob: '',
+        muted: false,
+        isRecording: false,
+        timer: {
+            second: 0,
+            minute: 0,
+        },
+        onFinish: undefined,
+    };
+    return state;
+}), withMethods((store) => {
+    let interval;
+    let videoStream;
+    let audioStream;
+    let mediaRecorder;
+    let recordedChunks = [];
+    let componentRef;
+    const toastService = inject(AXToastService);
+    const translationService = inject(AXTranslationService);
+    const application = inject(ApplicationRef);
+    const logCaptureService = inject(AXMLogCaptureService);
+    const stopRecorderSubject = new Subject();
+    const recordStream = async () => {
+        logCaptureService.startCapturingLog();
+        mediaRecorder = await new MediaRecorder(videoStream, {
+            mimeType: 'video/mp4;codecs=avc1,mp4a.40.2',
+        });
+        patchState(store, { isRecording: true });
+        mediaRecorder.start();
+        startTimer();
+        mediaRecorder.ondataavailable = (e) => {
+            recordedChunks.push(e.data);
+        };
+        mediaRecorder.onstop = () => {
+            stopRecorder();
+        };
+        videoStream.getVideoTracks()[0].onended = () => {
+            stopRecorder();
+        };
+    };
+    const finishRecording = async (result) => {
+        // if (store.onFinish() && result) {
+        // store.onFinish()?.(result);
+        // }
+        logCaptureService.finishCapturingLog();
+        store.onFinish()?.(result ?? false);
+        resetState();
+        componentRef.destroy();
+    };
+    const stopRecorder = async () => {
+        await stopRecorderSubject.pipe(take(1)).subscribe(async () => {
+            try {
+                if (mediaRecorder && videoStream?.active) {
+                    await mediaRecorder.stop();
+                    if (audioStream) {
+                        audioStream.getTracks().forEach((track) => track.stop());
+                    }
+                    videoStream.getVideoTracks().forEach((track) => track.stop());
+                    clearInterval(interval);
+                    patchState(store, { isRecording: false, timer: { second: 0, minute: 0 } });
+                    setTimeout(() => {
+                        createVideoBlob();
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Error stopping recorder:', error);
+                finishRecording(null);
+            }
+        });
+        stopRecorderSubject.next();
+    };
+    const createVideoBlob = () => {
+        try {
+            if (recordedChunks.length > 0) {
+                const blob = new Blob(recordedChunks, {
+                    type: recordedChunks[0].type,
+                });
+                finishRecording({ blob, type: 'video' });
+            }
+        }
+        catch (error) {
+            console.error('Error creating video blob:', error);
+            finishRecording(null);
+        }
+    };
+    const startTimer = () => {
+        interval = setInterval(() => {
+            if (store.timer().minute === 5) {
+                stopRecorder();
+                setTimeout(async () => {
+                    toastService.show({
+                        color: 'warning',
+                        content: await translationService.translateAsync('@help-desk:report-new-issue.components.report-new-issue-form.recording-time-limit'),
+                        timeOut: 5000,
+                    });
+                }, 100);
+            }
+            else if (store.timer().second === 59) {
+                patchState(store, { timer: { minute: ++store.timer().minute, second: 0 } });
+            }
+            else {
+                patchState(store, { timer: { minute: store.timer().minute, second: ++store.timer().second } });
+            }
+        }, 1000);
+    };
+    const resetState = () => {
+        patchState(store, {
+            loading: false,
+            captureMode: 'screenshot',
+            screenshotBlob: '',
+            videoBlob: '',
+            muted: false,
+            isRecording: false,
+            timer: {
+                second: 0,
+                minute: 0,
+            },
+            onFinish: undefined,
+        });
+    };
+    return {
+        init: async (onFinish) => {
+            try {
+                const { AXMCaptureScreenComponent } = await import('./acorex-platform-module-help-desk-client-capture-screen.component-AyM-9U5W.mjs');
+                const viewContainerRef = application.components[0].injector.get(ViewContainerRef);
+                componentRef = viewContainerRef.createComponent(AXMCaptureScreenComponent);
+                document.body.appendChild(componentRef.location.nativeElement);
+                patchState(store, { onFinish });
+            }
+            catch (error) {
+                console.error('Error initializing capture screen:', error);
+                onFinish?.({ blob: new Blob(), type: 'image' });
+            }
+        },
+        cancelClick() {
+            if (store.isRecording()) {
+                stopRecorder();
+                return;
+            }
+            this.changeCaptureMode();
+            finishRecording(null);
+        },
+        changeCaptureMode() {
+            patchState(store, {
+                captureMode: store.captureMode() === 'screenshot' ? 'video' : 'screenshot',
+            });
+        },
+        async mutedClick() {
+            const enabled = store.muted();
+            if (audioStream) {
+                audioStream.getTracks().forEach((track) => (track.enabled = enabled));
+            }
+            patchState(store, { muted: !enabled });
+        },
+        async screenshotClick() {
+            await patchState(store, { loading: true });
+            const captureElement = document.getElementsByTagName('body')[0];
+            setTimeout(() => {
+                html2canvas(captureElement)
+                    .then(async (canvas) => {
+                    try {
+                        const blob = await new Promise((resolve, reject) => {
+                            canvas.toBlob((nextBlob) => nextBlob ? resolve(nextBlob) : reject(new Error('Failed to create blob')), 'image/png');
+                        });
+                        finishRecording({ blob, type: 'image' });
+                    }
+                    catch (error) {
+                        console.error('Error creating screenshot:', error);
+                        finishRecording(null);
+                    }
+                })
+                    .catch((error) => {
+                    console.error('Error capturing screenshot:', error);
+                    finishRecording(null);
+                })
+                    .finally(() => {
+                    patchState(store, { loading: false });
+                });
+            });
+        },
+        async recordScreenClick() {
+            if (!store.isRecording() && !videoStream?.active) {
+                try {
+                    videoStream = await navigator.mediaDevices.getDisplayMedia({
+                        video: { displaySurface: 'monitor' },
+                        audio: true,
+                    });
+                    await this.getMicrophonePermission();
+                    await recordStream();
+                }
+                catch (error) {
+                    console.error('Error starting screen recording:', error);
+                    toastService.show({
+                        color: 'warning',
+                        content: await translationService.translateAsync('@help-desk:report-new-issue.components.report-new-issue-form.capture-screen-error'),
+                        timeOut: 5000,
+                    });
+                    finishRecording(null);
+                }
+            }
+            else if (mediaRecorder) {
+                stopRecorder();
+            }
+        },
+        async getMicrophonePermission() {
+            try {
+                audioStream = await navigator.mediaDevices.getUserMedia({
+                    audio: {
+                        echoCancellation: true,
+                        noiseSuppression: true,
+                        sampleRate: 44100,
+                        autoGainControl: true,
+                    },
+                });
+                if (audioStream && videoStream) {
+                    videoStream.addTrack(audioStream.getTracks()[0]);
+                    audioStream.getTracks()[0].enabled = !store.muted();
+                }
+            }
+            catch (error) {
+                console.error('Error getting microphone permission:', error);
+                toastService.show({
+                    color: 'warning',
+                    content: await translationService.translateAsync('@help-desk:report-new-issue.components.report-new-issue-form.get-microphone-error'),
+                    timeOut: 5000,
+                });
+                audioStream = null;
+            }
+        },
+    };
+}));
+
+const AXMReportNewIssueViewModel = signalStore({ providedIn: 'root' }, withState(() => {
+    const state = {
+        id: AXPDataGenerator.uuid(),
+        data: {
+            title: '',
+            description: '',
+            issueType: {},
+            priority: {},
+        },
+        status: 'new',
+        media: [],
+    };
+    return state;
+}), withComputed(({ status }) => ({
+    isRecording: computed(() => status() === 'recording'),
+})), withMethods((store, popupService = inject(AXPopupService), captureScreenService = inject(AXMCaptureScreenService), logCaptureService = inject(AXMLogCaptureService), entityEvents = inject(AXPEntityBroadcastService), translateService = inject(AXTranslationService)) => {
+    const createMediaItem = (name, mediaUrl, type) => ({
+        id: (store.media().length + 1).toString(),
+        name: name,
+        type: type,
+        thumbnailUrl: mediaUrl,
+        url: mediaUrl,
+    });
+    return {
+        async startCapturing() {
+            patchState(store, { status: 'recording' });
+            captureScreenService.init(async (data) => {
+                try {
+                    if (typeof data === 'object' && 'blob' in data) {
+                        const newMedia = [];
+                        const mediaUrl = await URL.createObjectURL(data.blob);
+                        const fileName = `${new Date().toISOString()}.${data.type === 'image' ? 'png' : 'mp4'}`;
+                        newMedia.push(createMediaItem(fileName, mediaUrl, data.type));
+                        if (data.type === 'video') {
+                            const data = JSON.stringify(await logCaptureService.logs());
+                            const logFileName = `logs-${new Date().toLocaleDateString(translateService.getActiveLang())}.txt`;
+                            const blobLogFile = await new Blob([data], { type: 'text/txt;charset=utf-8' });
+                            const logFileMediaUrl = await URL.createObjectURL(blobLogFile);
+                            newMedia.push(createMediaItem(logFileName, logFileMediaUrl, 'text'));
+                        }
+                        patchState(store, {
+                            media: [...store.media(), ...newMedia],
+                            status: 'recorded',
+                        });
+                    }
+                    this.showPopup();
+                }
+                catch (error) {
+                    console.error('Error capturing media:', error);
+                    return undefined;
+                }
+            });
+        },
+        async showPopup() {
+            try {
+                const { AXMReportNewIssueComponent } = await import('./acorex-platform-module-help-desk-client-report-new-issue.component-C-vY_x_C.mjs');
+                const config = {
+                    title: await translateService.translateAsync('@help-desk:report-new-issue.entities.report-new-issue.title'),
+                };
+                const result = await popupService.open(AXMReportNewIssueComponent, config);
+                if (result.data?.insertResult) {
+                    entityEvents.publishLayoutRefresh('reported-issues');
+                    patchState(store, { status: 'new' });
+                }
+            }
+            catch (error) {
+                console.error('Error showing popup:', error);
+                patchState(store, { status: 'new' });
+            }
+        },
+        deleteCapturedItem(index) {
+            patchState(store, { media: store.media().filter((_, i) => i !== index) });
+        },
+        resetState() {
+            patchState(store, {
+                id: AXPDataGenerator.uuid(),
+                data: {
+                    title: '',
+                    description: '',
+                    issueType: {},
+                    priority: {},
+                },
+                status: 'new',
+                media: [],
+            });
+        },
+    };
+}));
+
+const CaptureScreenHookProvider = {
+    key: 'file-uploader.actions',
+    priority: 0,
+    execute: (payload) => {
+        const vm = inject(AXMReportNewIssueViewModel);
+        const isExcluded = Array.isArray(payload.excludePlugins) && payload.excludePlugins.includes('capture-screen');
+        // show if plugin is explicitly enabled or it's global and not excluded
+        const isEnabled = Array.isArray(payload.plugins) && payload.plugins.some(p => p.name === 'capture-screen');
+        if (!isEnabled && isExcluded) {
+            return payload;
+        }
+        payload.actions = [
+            ...payload.actions,
+            {
+                plugin: 'capture-screen',
+                global: false,
+                textKey: '@help-desk:report-new-issue.components.report-new-issue-form.capture-screen',
+                icon: 'fa-light fa-video',
+                run: async () => {
+                    vm.startCapturing();
+                },
+            },
+        ];
+        return payload;
+    },
+};
+
+//#endregion
+//#region ---- Helpers ----
+const comingSoon = (messageKey) => ({
+    name: 'auth:profile-coming-soon',
+    options: { messageKey },
+});
+//#endregion
+//#region ---- Help desk profile sections ----
+/** Contributes help desk sections to the user profile hub. */
+const HelpDeskProfileSectionsHookProvider = {
+    key: 'profile-page.sections',
+    priority: 10,
+    execute: (payload) => {
+        if (payload.groupId && payload.groupId !== 'requests') {
+            return payload;
+        }
+        return {
+            ...payload,
+            sections: [
+                ...payload.sections,
+                {
+                    id: 'my-tickets',
+                    groupId: 'requests',
+                    title: '@help-desk:profile-page.sections.my-tickets.title',
+                    description: '@help-desk:profile-page.sections.my-tickets.description',
+                    icon: 'far fa-ticket',
+                    priority: 10,
+                    layout: { colSpan: 6 },
+                    actions: [
+                        {
+                            name: 'view-my-tickets',
+                            title: '@help-desk:profile-page.sections.my-tickets.actions.manage',
+                            icon: 'far fa-arrow-right',
+                            command: comingSoon('@help-desk:profile-page.commands.view-my-tickets.coming-soon'),
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+//#endregion
+
+class AXMHelpDeskModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMHelpDeskModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMHelpDeskModule, imports: [i1.AXPComponentSlotModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMHelpDeskModule, providers: [
+            // Module-specific providers (not part of manifest system)
+            {
+                provide: AXP_STATUS_PROVIDERS,
+                useClass: AXMReportedIssuesStatusProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                useValue: CaptureScreenHookProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                useValue: HelpDeskProfileSectionsHookProvider,
+                multi: true,
+            },
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: HelpDeskManifest,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMSettingProvider,
+                multi: true,
+            },
+            provideCommandSetups([
+                {
+                    key: 'show-report-issue',
+                    command: () => import('./acorex-platform-module-help-desk-client-show-report-issue.command-q2fqdnAS.mjs').then((c) => c.AXMShowReportIssueCommand),
+                },
+                {
+                    key: 'download-log-file',
+                    command: () => import('./acorex-platform-module-help-desk-client-download-log-file.command-eMaHHzLd.mjs').then((c) => c.AXMDownloadLogFileCommand),
+                },
+            ]),
+        ], imports: [AXPComponentSlotModule.forChild({
+            // 'file-uploader-widget-actions': [
+            //   {
+            //     name: 'capture-screen-actions',
+            //     component: AXPCaptureScreenWidgetExtensionComponent,
+            //   },
+            // ],
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMHelpDeskModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPComponentSlotModule.forChild({
+                        // 'file-uploader-widget-actions': [
+                        //   {
+                        //     name: 'capture-screen-actions',
+                        //     component: AXPCaptureScreenWidgetExtensionComponent,
+                        //   },
+                        // ],
+                        }),
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        // Module-specific providers (not part of manifest system)
+                        {
+                            provide: AXP_STATUS_PROVIDERS,
+                            useClass: AXMReportedIssuesStatusProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                            useValue: CaptureScreenHookProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                            useValue: HelpDeskProfileSectionsHookProvider,
+                            multi: true,
+                        },
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: HelpDeskManifest,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMSettingProvider,
+                            multi: true,
+                        },
+                        provideCommandSetups([
+                            {
+                                key: 'show-report-issue',
+                                command: () => import('./acorex-platform-module-help-desk-client-show-report-issue.command-q2fqdnAS.mjs').then((c) => c.AXMShowReportIssueCommand),
+                            },
+                            {
+                                key: 'download-log-file',
+                                command: () => import('./acorex-platform-module-help-desk-client-download-log-file.command-eMaHHzLd.mjs').then((c) => c.AXMDownloadLogFileCommand),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMReportNewIssueViewModel as A, AXMLogCaptureService as a, AXMCaptureScreenService as b, AXMHelpDeskModule as c, AXMMenuProvider as d, AXMPermissionDefinitionProvider as e, AXMReportedIssuesStatusProvider as f, AXMSettingProvider as g };
+//# sourceMappingURL=acorex-platform-module-help-desk-client-acorex-platform-module-help-desk-client-OtDtf3iY.mjs.map