import { AXPEntity, AXPMenuProvider, AXPMenuProviderContext, AXPSearchCommandProvider, AXPSearchResult } from '@acorex/platform/common';
import { AXPEntityDefinitionLoader, AXPEntityModel, AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
import { AXPFeatureDefinitionProvider, AXPFeatureDefinitionProviderContext, AXPEntityReference } from '@acorex/platform/core';
import { AXPPermissionDefinitionProvider, AXPPermissionDefinitionProviderContext } from '@acorex/platform/auth';
import * as _angular_core from '@angular/core';
import { OnInit } from '@angular/core';
import * as _acorex_platform_layout_widget_core from '@acorex/platform/layout/widget-core';
import { AXPWidgetNode, AXPWidgetContainerComponent, AXPValueWidgetComponent } from '@acorex/platform/layout/widget-core';
import * as _ngrx_signals from '@ngrx/signals';
import { AXFormComponent } from '@acorex/components/form';
import * as _acorex_modules_assessment_management from '@acorex/modules/assessment-management';
import { AXPPageLayoutBaseComponent } from '@acorex/platform/layout/views';
import { ActivatedRoute } from '@angular/router';

declare const RootConfig: {
    config: {
        i18n: string;
    };
    module: {
        module: string;
        route: string;
        name: string;
        title: string;
        icon: string;
    };
    entities: {
        questionBankItem: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        questionnaire: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        assessmentCase: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        assessmentSession: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
    };
};

declare class AXMAssessmentManagementEntityProvider implements AXPEntityDefinitionLoader {
    private readonly injector;
    get(moduleName: string, entityName: string): Promise<AXPEntity | null>;
    list(): Promise<{
        name: string;
        module: string;
    }[]>;
}

/**
 * Assessment Management Feature Definition Provider.
 * Provides feature definitions for the Assessment Management module.
 */
declare class AXMAssessmentManagementFeatureDefinitionProvider implements AXPFeatureDefinitionProvider {
    provide(context: AXPFeatureDefinitionProviderContext): Promise<void>;
}

declare const AXMAssessmentManagementFeatureKeys: {
    readonly QuestionnaireManagement: "AssessmentManagement:Feature:Questionnaire.Management";
};

declare class AXMAssessmentManagementMenuProvider implements AXPMenuProvider {
    private entityService;
    provide(context: AXPMenuProviderContext): Promise<void>;
}

declare const AXPAssessmentManagementMenuKeys: {
    readonly Questionnaires: "AssessmentManagement:Menu:Questionnaires";
    readonly Cases: "AssessmentManagement:Menu:Cases";
    readonly QuestionBankItems: "AssessmentManagement:Menu:QuestionBankItems";
};

declare class AXMAssessmentManagementPermissionDefinitionProvider implements AXPPermissionDefinitionProvider {
    define(context: AXPPermissionDefinitionProviderContext): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAssessmentManagementPermissionDefinitionProvider, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMAssessmentManagementPermissionDefinitionProvider>;
}

declare const AXMAssessmentManagementPermissionKeys: {
    readonly AssessmentManagement: {
        readonly QuestionBank: "AssessmentManagement:QuestionBank:Management";
        readonly Questionnaire: {
            readonly Management: "AssessmentManagement:Questionnaire:Management";
            readonly Create: "AssessmentManagement:Questionnaire:Create";
            readonly Edit: "AssessmentManagement:Questionnaire:Edit";
            readonly Delete: "AssessmentManagement:Questionnaire:Delete";
        };
        readonly Case: {
            readonly Management: "AssessmentManagement:Case:Management";
            readonly Create: "AssessmentManagement:Case:Create";
            readonly Edit: "AssessmentManagement:Case:Edit";
            readonly Delete: "AssessmentManagement:Case:Delete";
        };
        readonly Session: {
            readonly Management: "AssessmentManagement:Session:Management";
            readonly Create: "AssessmentManagement:Session:Create";
            readonly Edit: "AssessmentManagement:Session:Edit";
            readonly Delete: "AssessmentManagement:Session:Delete";
        };
    };
};

declare class AXMAssessmentManagementSearchCommandProvider extends AXPSearchCommandProvider {
    commands: AXPSearchResult[];
}

declare class AXMQuestionBankItemEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionBankItemEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMQuestionBankItemEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMQuestionBankItemEntityModule>;
}

declare class AXMQuestionnaireBuilderFeatureModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireBuilderFeatureModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMQuestionnaireBuilderFeatureModule, never, [typeof _acorex_platform_layout_widget_core.AXPWidgetCoreModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMQuestionnaireBuilderFeatureModule>;
}

declare class AXMQuestionnaireEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMQuestionnaireEntityModule, never, [typeof AXMQuestionnaireBuilderFeatureModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMQuestionnaireEntityModule>;
}

declare class AXMAssessmentCaseEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAssessmentCaseEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMAssessmentCaseEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMAssessmentCaseEntityModule>;
}

declare class AXMAssessmentSessionEntityModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAssessmentSessionEntityModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMAssessmentSessionEntityModule, never, never, never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMAssessmentSessionEntityModule>;
}

/**
 * View mode for displaying questionnaire
 * - single-page: All groups in a single page
 * - page-per-group: One section (group) per page
 * - page-per-question: One question per page
 * - side-menu: Sections in left sidebar, questions on right
 */
type QuestionnaireViewMode = 'single-page' | 'page-per-group' | 'page-per-question' | 'side-menu';
/**
 * Timer display configuration
 */
interface QuestionnaireTimerConfig {
    showTimer: boolean;
    mode?: 'countdown' | 'elapsed' | 'scheduled';
    timeLimit?: number;
    startTime?: Date;
}
/**
 * Progress calculation mode
 * - answered: Progress based on number of answered questions
 * - navigation: Progress based on current navigation position
 */
type QuestionnaireProgressMode = 'answered' | 'navigation';
/**
 * Questionnaire Viewer Configuration
 */
interface QuestionnaireViewerConfig {
    /**
     * View mode: single-page, page-per-group, page-per-question
     */
    viewMode?: QuestionnaireViewMode;
    /**
     * Timer configuration
     */
    timer?: QuestionnaireTimerConfig;
    /**
     * Show progress bar
     */
    showProgressBar?: boolean;
    /**
     * Progress calculation mode: answered or navigation
     */
    progressMode?: QuestionnaireProgressMode;
    /**
     * Show section titles
     */
    showSectionTitles?: boolean;
    /**
     * Allow navigation between questions
     */
    allowNavigation?: boolean;
    /**
     * Show question numbers
     */
    showQuestionNumbers?: boolean;
    /**
     * Readonly mode (no answers can be submitted)
     */
    readonly?: boolean;
    /**
     * Auto-save answers as user types
     */
    autoSave?: boolean;
    /**
     * Show validation errors inline
     */
    showValidationErrors?: boolean;
    /**
     * Allow skipping questions (if not required)
     */
    allowSkipping?: boolean;
    /**
     * Show question counter (e.g., "Question 3 of 10")
     */
    showQuestionCounter?: boolean;
    /**
     * Validate before allowing navigation to other sections/pages
     * When true, navigation is blocked if current page has validation errors
     * When false, navigation is allowed but validation errors are still shown
     * Default: true
     */
    validateBeforeNavigation?: boolean;
}
/**
 * Question data with full details
 */
interface QuestionnaireViewerQuestion {
    id: string;
    questionBankItemId: string;
    sectionId: string;
    order: number;
    isRequired?: boolean;
    visibilityCondition?: string;
    requiredCondition?: string;
    scoringOverride?: {
        points?: number;
        weight?: number;
    };
    question: {
        id: string;
        title: string;
        description?: string;
        difficulty?: string;
        scoringType?: string;
        interface?: any;
    };
}
/**
 * Section data with questions
 */
interface QuestionnaireViewerSection {
    id: string;
    title: string;
    description?: string;
    order: number;
    visibilityCondition?: string;
    questions: QuestionnaireViewerQuestion[];
}
/**
 * Questionnaire data for viewer
 */
interface QuestionnaireViewerData {
    id: string;
    title: string;
    description?: string;
    type: 'questionnaire' | 'survey' | 'checklist' | 'test' | 'evaluation';
    sections: QuestionnaireViewerSection[];
    scoringType?: 'none' | 'cumulative' | 'weighted' | 'formula';
    passingScore?: number;
}

/**
 * Display settings for questionnaire viewer
 */
interface QuestionnaireDisplaySettings {
    /**
     * View mode: single-page, page-per-group, page-per-question, side-menu
     */
    viewMode?: 'single-page' | 'page-per-group' | 'page-per-question' | 'side-menu';
    /**
     * Show progress bar
     */
    showProgressBar?: boolean;
    /**
     * Progress calculation mode: answered or navigation
     */
    progressMode?: 'answered' | 'navigation';
    /**
     * Show timer
     */
    showTimer?: boolean;
    /**
     * Show section titles
     */
    showSectionTitles?: boolean;
    /**
     * Show question numbers
     */
    showQuestionNumbers?: boolean;
    /**
     * Auto-save answers as user types
     */
    autoSave?: boolean;
    /**
     * Show validation errors inline
     */
    showValidationErrors?: boolean;
    /**
     * Allow skipping questions (if not required)
     */
    allowSkipping?: boolean;
    /**
     * Show question counter (e.g., "Question 3 of 10")
     */
    showQuestionCounter?: boolean;
    /**
     * Validate before allowing navigation to other sections/pages
     * When true, navigation is blocked if current page has validation errors
     * When false, navigation is allowed but validation errors are still shown
     * Default: true
     */
    validateBeforeNavigation?: boolean;
}
/**
 * Value structure stored in entity (simplified for persistence)
 */
interface QuestionnaireBuilderValue {
    sections: Array<{
        id: string;
        title: string;
        description?: string;
        order: number;
        visibilityCondition?: string;
        items: Array<{
            id: string;
            questionBankItemId: string;
            order: number;
            isRequired?: boolean;
            visibilityCondition?: string;
            requiredCondition?: string;
            scoringOverride?: {
                points?: number;
                weight?: number;
            };
            interfaceOverride?: AXPWidgetNode;
        }>;
    }>;
    /**
     * Display settings for questionnaire viewer
     */
    displaySettings?: QuestionnaireDisplaySettings;
}

interface QuestionnaireValidationError {
    questionId: string;
    questionTitle: string;
    sectionId?: string;
    sectionTitle?: string;
    error: string;
}
interface QuestionnaireValidationResult {
    isValid: boolean;
    errors: QuestionnaireValidationError[];
}

/**
 * Questionnaire Viewer Component
 * Renders a questionnaire for viewing/answering with configurable display modes
 */
declare class AXMQuestionnaireViewerComponent {
    protected readonly vm: {
        questionnaireData: _angular_core.Signal<QuestionnaireViewerData | null>;
        structure: _angular_core.Signal<QuestionnaireBuilderValue | null>;
        config: _angular_core.Signal<QuestionnaireViewerConfig | null>;
        isLoading: _angular_core.Signal<boolean>;
        error: _angular_core.Signal<string | null>;
        currentSectionIndex: _angular_core.Signal<number>;
        currentQuestionIndex: _angular_core.Signal<number>;
        timerElapsed: _angular_core.Signal<number>;
        timerInterval: _angular_core.Signal<any>;
        form: _angular_core.Signal<any>;
        widgetContainer: _angular_core.Signal<AXPWidgetContainerComponent | null>;
        validationErrors: _angular_core.Signal<QuestionnaireValidationError[]>;
        viewMode: _angular_core.Signal<QuestionnaireViewMode>;
        sections: _angular_core.Signal<QuestionnaireViewerSection[]>;
        currentSection: _angular_core.Signal<QuestionnaireViewerSection | null>;
        currentQuestion: _angular_core.Signal<QuestionnaireViewerQuestion | null>;
        totalQuestionsCount: _angular_core.Signal<number>;
        totalSectionsCount: _angular_core.Signal<number>;
        progressMode: _angular_core.Signal<QuestionnaireProgressMode>;
        answeredQuestionsCount: _angular_core.Signal<number>;
        progressPercentage: _angular_core.Signal<number>;
        showProgressBar: _angular_core.Signal<boolean>;
        showTimer: _angular_core.Signal<boolean>;
        timerTimeLimit: _angular_core.Signal<number | undefined>;
        showSectionTitles: _angular_core.Signal<boolean>;
        showQuestionNumbers: _angular_core.Signal<boolean>;
        showQuestionCounter: _angular_core.Signal<boolean>;
        currentQuestionPosition: _angular_core.Signal<{
            current: number;
            total: number;
        }>;
        timerText: _angular_core.Signal<string>;
        timerWidget: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetNode | null>;
        validateBeforeNavigation: _angular_core.Signal<boolean>;
        canNavigateNext: _angular_core.Signal<boolean>;
        canNavigatePrevious: _angular_core.Signal<boolean>;
        isLastStep: _angular_core.Signal<boolean>;
        areAllRequiredQuestionsAnswered: _angular_core.Signal<boolean>;
        registerForm: (form: any) => void;
        registerWidgetContainer: (container: AXPWidgetContainerComponent) => void;
        loadQuestionnaire: (id: string, initialAnswers?: Record<string, any>, config?: QuestionnaireViewerConfig) => Promise<void>;
        loadStructure: (structure: QuestionnaireBuilderValue, config?: QuestionnaireViewerConfig, initialAnswers?: Record<string, any>) => Promise<void>;
        isQuestionVisible: (question: QuestionnaireViewerQuestion) => boolean;
        getVisibleQuestions: () => QuestionnaireViewerQuestion[];
        validateQuestion: (question: QuestionnaireViewerQuestion) => Promise<string | null>;
        validateCurrentPage: () => Promise<QuestionnaireValidationResult>;
        validateAllQuestions: () => Promise<QuestionnaireValidationResult>;
        navigateNext: () => Promise<boolean>;
        navigatePrevious: () => Promise<boolean>;
        isCurrentSectionValid: () => Promise<boolean>;
        isSectionNavigable: (sectionIndex: number) => Promise<boolean>;
        navigateToSection: (index: number) => Promise<boolean>;
        navigateToQuestion: (sectionIndex: number, questionIndex: number) => Promise<boolean>;
        getAllAnswers: () => Record<string, any>;
        getQuestionsWithAnswers: () => Array<{
            questionId: string;
            questionBankItemId: string;
            sectionId: string;
            title: string;
            description?: string;
            answer: any;
            isRequired?: boolean;
            question: QuestionnaireViewerQuestion;
        }>;
        getSectionUnansweredRequiredCount: (sectionId: string) => number;
        submit: () => Promise<{
            success: boolean;
            answers: Record<string, any>;
            errors?: QuestionnaireValidationError[];
        }>;
        startTimer: () => void;
        stopTimer: () => void;
        updateTimerElapsed: (value: number) => void;
    } & _ngrx_signals.StateSource<{
        questionnaireData: QuestionnaireViewerData | null;
        structure: QuestionnaireBuilderValue | null;
        config: QuestionnaireViewerConfig | null;
        isLoading: boolean;
        error: string | null;
        currentSectionIndex: number;
        currentQuestionIndex: number;
        timerElapsed: number;
        timerInterval: any;
        form: any;
        widgetContainer: AXPWidgetContainerComponent | null;
        validationErrors: QuestionnaireValidationError[];
    }>;
    /**
     * Questionnaire ID to load and display (required if structure is not provided)
     */
    questionnaireId: _angular_core.InputSignal<string | undefined>;
    /**
     * Structure data for preview mode (used when questionnaireId is not provided)
     */
    structure: _angular_core.InputSignal<QuestionnaireBuilderValue | undefined>;
    /**
     * Viewer configuration
     * Note: If properties are undefined, displaySettings from structure will be used
     */
    config: _angular_core.InputSignal<QuestionnaireViewerConfig | undefined>;
    /**
     * Initial answers to pre-fill the questionnaire
     */
    initialAnswers: _angular_core.InputSignal<Record<string, any>>;
    /**
     * Emitted when answers change
     */
    answersChanged: _angular_core.OutputEmitterRef<Record<string, any>>;
    /**
     * Emitted when a question is answered
     */
    questionAnswered: _angular_core.OutputEmitterRef<{
        questionId: string;
        value: any;
    }>;
    /**
     * Form reference for validation
     */
    protected form: _angular_core.Signal<AXFormComponent | undefined>;
    /**
     * Widget container reference for context access
     */
    protected widgetContainer: _angular_core.Signal<AXPWidgetContainerComponent | undefined>;
    constructor();
    /**
     * Get viewmodel instance (for accessing computed properties)
     */
    get viewmodel(): {
        questionnaireData: _angular_core.Signal<QuestionnaireViewerData | null>;
        structure: _angular_core.Signal<QuestionnaireBuilderValue | null>;
        config: _angular_core.Signal<QuestionnaireViewerConfig | null>;
        isLoading: _angular_core.Signal<boolean>;
        error: _angular_core.Signal<string | null>;
        currentSectionIndex: _angular_core.Signal<number>;
        currentQuestionIndex: _angular_core.Signal<number>;
        timerElapsed: _angular_core.Signal<number>;
        timerInterval: _angular_core.Signal<any>;
        form: _angular_core.Signal<any>;
        widgetContainer: _angular_core.Signal<AXPWidgetContainerComponent | null>;
        validationErrors: _angular_core.Signal<QuestionnaireValidationError[]>;
        viewMode: _angular_core.Signal<QuestionnaireViewMode>;
        sections: _angular_core.Signal<QuestionnaireViewerSection[]>;
        currentSection: _angular_core.Signal<QuestionnaireViewerSection | null>;
        currentQuestion: _angular_core.Signal<QuestionnaireViewerQuestion | null>;
        totalQuestionsCount: _angular_core.Signal<number>;
        totalSectionsCount: _angular_core.Signal<number>;
        progressMode: _angular_core.Signal<QuestionnaireProgressMode>;
        answeredQuestionsCount: _angular_core.Signal<number>;
        progressPercentage: _angular_core.Signal<number>;
        showProgressBar: _angular_core.Signal<boolean>;
        showTimer: _angular_core.Signal<boolean>;
        timerTimeLimit: _angular_core.Signal<number | undefined>;
        showSectionTitles: _angular_core.Signal<boolean>;
        showQuestionNumbers: _angular_core.Signal<boolean>;
        showQuestionCounter: _angular_core.Signal<boolean>;
        currentQuestionPosition: _angular_core.Signal<{
            current: number;
            total: number;
        }>;
        timerText: _angular_core.Signal<string>;
        timerWidget: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetNode | null>;
        validateBeforeNavigation: _angular_core.Signal<boolean>;
        canNavigateNext: _angular_core.Signal<boolean>;
        canNavigatePrevious: _angular_core.Signal<boolean>;
        isLastStep: _angular_core.Signal<boolean>;
        areAllRequiredQuestionsAnswered: _angular_core.Signal<boolean>;
        registerForm: (form: any) => void;
        registerWidgetContainer: (container: AXPWidgetContainerComponent) => void;
        loadQuestionnaire: (id: string, initialAnswers?: Record<string, any>, config?: QuestionnaireViewerConfig) => Promise<void>;
        loadStructure: (structure: QuestionnaireBuilderValue, config?: QuestionnaireViewerConfig, initialAnswers?: Record<string, any>) => Promise<void>;
        isQuestionVisible: (question: QuestionnaireViewerQuestion) => boolean;
        getVisibleQuestions: () => QuestionnaireViewerQuestion[];
        validateQuestion: (question: QuestionnaireViewerQuestion) => Promise<string | null>;
        validateCurrentPage: () => Promise<QuestionnaireValidationResult>;
        validateAllQuestions: () => Promise<QuestionnaireValidationResult>;
        navigateNext: () => Promise<boolean>;
        navigatePrevious: () => Promise<boolean>;
        isCurrentSectionValid: () => Promise<boolean>;
        isSectionNavigable: (sectionIndex: number) => Promise<boolean>;
        navigateToSection: (index: number) => Promise<boolean>;
        navigateToQuestion: (sectionIndex: number, questionIndex: number) => Promise<boolean>;
        getAllAnswers: () => Record<string, any>;
        getQuestionsWithAnswers: () => Array<{
            questionId: string;
            questionBankItemId: string;
            sectionId: string;
            title: string;
            description?: string;
            answer: any;
            isRequired?: boolean;
            question: QuestionnaireViewerQuestion;
        }>;
        getSectionUnansweredRequiredCount: (sectionId: string) => number;
        submit: () => Promise<{
            success: boolean;
            answers: Record<string, any>;
            errors?: QuestionnaireValidationError[];
        }>;
        startTimer: () => void;
        stopTimer: () => void;
        updateTimerElapsed: (value: number) => void;
    } & _ngrx_signals.StateSource<{
        questionnaireData: QuestionnaireViewerData | null;
        structure: QuestionnaireBuilderValue | null;
        config: QuestionnaireViewerConfig | null;
        isLoading: boolean;
        error: string | null;
        currentSectionIndex: number;
        currentQuestionIndex: number;
        timerElapsed: number;
        timerInterval: any;
        form: any;
        widgetContainer: AXPWidgetContainerComponent | null;
        validationErrors: QuestionnaireValidationError[];
    }>;
    /**
     * Check if can navigate previous
     */
    get canNavigatePrevious(): boolean;
    /**
     * Check if can navigate next
     */
    get canNavigateNext(): boolean;
    /**
     * Get current view mode
     */
    get viewMode(): 'single-page' | 'page-per-group' | 'page-per-question' | 'side-menu';
    /**
     * Check if we're on the last step
     */
    get isLastStep(): boolean;
    /**
     * Check if all required questions are answered
     */
    get areAllRequiredQuestionsAnswered(): boolean;
    /**
     * Navigate to next question/section
     * Validates current page before navigating
     * @returns true if navigation succeeded, false if validation failed
     */
    navigateNext(): Promise<boolean>;
    /**
     * Navigate to previous question/section
     * @returns true if navigation succeeded
     */
    navigatePrevious(): Promise<boolean>;
    /**
     * Navigate to specific section
     * Validates current page before navigating
     * @param index Section index (0-based)
     * @returns true if navigation succeeded, false if validation failed
     */
    navigateToSection(index: number): Promise<boolean>;
    /**
     * Navigate to specific question
     * Validates current page before navigating
     * @param sectionIndex Section index (0-based)
     * @param questionIndex Question index (0-based)
     * @returns true if navigation succeeded, false if validation failed
     */
    navigateToQuestion(sectionIndex: number, questionIndex: number): Promise<boolean>;
    /**
     * Validate all visible questions on current page
     * @returns Validation result with errors
     */
    validateCurrentPage(): Promise<QuestionnaireValidationResult>;
    /**
     * Validate all questions in entire questionnaire
     * @returns Validation result with errors
     */
    validateAllQuestions(): Promise<QuestionnaireValidationResult>;
    /**
     * Get all answers from context
     */
    getAllAnswers(): Record<string, any>;
    /**
     * Get questions with their corresponding answers
     */
    getQuestionsWithAnswers(): {
        questionId: string;
        questionBankItemId: string;
        sectionId: string;
        title: string;
        description?: string;
        answer: any;
        isRequired?: boolean;
        question: QuestionnaireViewerQuestion;
    }[];
    /**
     * Get context data for review step (answers at widget paths).
     * Must be called before transitioning to review while viewer is still rendered.
     */
    getReviewContext(): Record<string, any>;
    /**
     * Submit questionnaire
     * Validates all questions before submitting
     * @returns Submit result with success status, answers, and errors if any
     */
    submit(): Promise<{
        success: boolean;
        answers: Record<string, any>;
        errors?: QuestionnaireValidationError[];
    }>;
    /**
     * Handle context changes for auto-save
     */
    protected handleContextChanged(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireViewerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMQuestionnaireViewerComponent, "axm-questionnaire-viewer", never, { "questionnaireId": { "alias": "questionnaireId"; "required": false; "isSignal": true; }; "structure": { "alias": "structure"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "initialAnswers": { "alias": "initialAnswers"; "required": false; "isSignal": true; }; }, { "answersChanged": "answersChanged"; "questionAnswered": "questionAnswered"; }, never, never, true, never>;
}

/**
 * Questionnaire Viewer Widget Component
 * Wraps the reusable AXMQuestionnaireViewerComponent for use as a widget
 */
declare class AXMQuestionnaireViewerWidgetEditComponent extends AXPValueWidgetComponent {
    /**
     * Get questionnaire ID from options or value (reactive)
     */
    questionnaireId: _angular_core.Signal<string | undefined>;
    /**
     * Get structure data from options or value (for preview mode) (reactive)
     */
    structure: _angular_core.Signal<QuestionnaireBuilderValue | undefined>;
    /**
     * Get viewer configuration from options (reactive)
     * Simple wrapper - only passes through explicitly set options
     * The main component will handle displaySettings priority
     */
    viewerConfig: _angular_core.Signal<QuestionnaireViewerConfig | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireViewerWidgetEditComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMQuestionnaireViewerWidgetEditComponent, "axm-questionnaire-viewer-widget-edit", never, {}, {}, never, never, true, never>;
}

declare class AXMQuestionnaireViewerFeatureModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireViewerFeatureModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMQuestionnaireViewerFeatureModule, never, [typeof _acorex_platform_layout_widget_core.AXPWidgetCoreModule, typeof AXMQuestionnaireViewerComponent, typeof AXMQuestionnaireViewerWidgetEditComponent], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMQuestionnaireViewerFeatureModule>;
}

declare class AXMAssessmentManagementModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAssessmentManagementModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMAssessmentManagementModule, never, [typeof AXMQuestionBankItemEntityModule, typeof AXMQuestionnaireEntityModule, typeof AXMAssessmentCaseEntityModule, typeof AXMAssessmentSessionEntityModule, typeof AXMQuestionnaireViewerFeatureModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMAssessmentManagementModule>;
}

interface AXMAssessmentManagementQuestionBankItemEntityModel extends AXPEntityModel<string> {
    title: string;
    description?: string;
    categoryId?: string;
    tags?: string[];
    scoringType?: 'none' | 'points' | 'weighted' | 'formula';
    points?: number;
    weight?: number;
    correctAnswer?: any;
    difficulty?: 'easy' | 'medium' | 'hard';
    estimatedTime?: number;
    interface?: any;
}

declare abstract class AXMQuestionBankItemService extends AXMEntityCrudServiceImpl<string, AXMAssessmentManagementQuestionBankItemEntityModel> {
}
declare class AXMQuestionBankItemServiceImpl extends AXMQuestionBankItemService {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionBankItemServiceImpl, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMQuestionBankItemServiceImpl>;
}

/**
 * Pre-questionnaire content (welcome/intro).
 * When multiLanguage is used, value is Record<locale, string>.
 */
type PrePostContentValue = string | Record<string, string>;
/**
 * Pre-questionnaire configuration (shown before questions).
 */
interface PreQuestionnaireConfig {
    enabled: boolean;
    /** Rich text content. Supports multi-language: Record<locale, string>. */
    content?: PrePostContentValue;
}
/**
 * Post-questionnaire configuration (review before submit, summary after submit).
 * Summary content supports placeholders: {{score}}, {{passFail}}, {{totalQuestions}}, {{answeredCount}}.
 */
interface PostQuestionnaireConfig {
    /** Show review step before submit (all answers, edit/submit). */
    reviewEnabled: boolean;
    /** Show summary screen after submit. */
    summaryEnabled: boolean;
    /** Rich text content for summary. Supports multi-language and placeholders. */
    summaryContent?: PrePostContentValue;
}
/**
 * Pre/post questionnaire configuration for viewer flow.
 * Extracted from questionnaire entity or passed explicitly.
 */
interface PrePostConfig {
    preEnabled?: boolean;
    preContent?: PrePostContentValue;
    postReviewEnabled?: boolean;
    postSummaryEnabled?: boolean;
    postSummaryContent?: PrePostContentValue;
    passingScore?: number;
}
interface AXMAssessmentManagementQuestionnaireEntityModel extends AXPEntityModel<string> {
    title: string;
    description?: string;
    type: 'questionnaire' | 'survey' | 'checklist' | 'test' | 'evaluation';
    structure?: QuestionnaireBuilderValue;
    preEnabled?: boolean;
    preContent?: PrePostContentValue;
    postReviewEnabled?: boolean;
    postSummaryEnabled?: boolean;
    postSummaryContent?: PrePostContentValue;
    scoringType?: 'none' | 'cumulative' | 'weighted' | 'formula';
    passingScore?: number;
    scoringFormula?: string;
    gradingScale?: Record<string, {
        min: number;
        max: number;
    }>;
    categoryId?: string;
    tags?: string[];
    color?: string;
}
/**
 * Extract PrePostConfig from questionnaire entity.
 */
declare function toPrePostConfig(q: Partial<AXMAssessmentManagementQuestionnaireEntityModel> | null | undefined): PrePostConfig | null;

declare abstract class AXMQuestionnaireService extends AXMEntityCrudServiceImpl<string, AXMAssessmentManagementQuestionnaireEntityModel> {
}
declare class AXMQuestionnaireServiceImpl extends AXMQuestionnaireService {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireServiceImpl, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMQuestionnaireServiceImpl>;
}

type AXMAssessmentCaseStatus = 'active' | 'closed' | 'cancelled';
interface AXMAssessmentManagementAssessmentCaseEntityModel extends AXPEntityModel<string> {
    /**
     * Single questionnaire assigned to this case.
     */
    questionnaireId: string;
    /**
     * Optional friendly title for lists/search.
     */
    title: string;
    description?: string;
    /**
     * Target entity (e.g. AssetManagement.Asset, HumanCapital.Employee).
     */
    subjectRef: AXPEntityReference;
    status: AXMAssessmentCaseStatus;
}

declare abstract class AXMAssessmentCaseService extends AXMEntityCrudServiceImpl<string, AXMAssessmentManagementAssessmentCaseEntityModel> {
}
declare class AXMAssessmentCaseServiceImpl extends AXMAssessmentCaseService {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAssessmentCaseServiceImpl, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMAssessmentCaseServiceImpl>;
}

type AXMAssessmentSessionRole = 'responder' | 'supervisor' | 'reviewer';
type AXMAssessmentSessionStatus = 'not-started' | 'in-progress' | 'submitted' | 'under-review' | 'approved' | 'rejected' | 'completed';
interface AXMAssessmentManagementAssessmentSessionEntityModel extends AXPEntityModel<string> {
    caseId: string;
    responderId: string;
    role: AXMAssessmentSessionRole;
    startedAt?: Date;
    lastSavedAt?: Date;
    timeSpent?: number;
    progressPercentage: number;
    answeredQuestionsCount: number;
    answers: Record<string, unknown>;
    previousId?: string;
}

declare abstract class AXMAssessmentSessionService extends AXMEntityCrudServiceImpl<string, AXMAssessmentManagementAssessmentSessionEntityModel> {
}
declare class AXMAssessmentSessionServiceImpl extends AXMAssessmentSessionService {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMAssessmentSessionServiceImpl, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMAssessmentSessionServiceImpl>;
}

/**
 * Placeholder values for post-questionnaire summary content.
 */
interface SummaryPlaceholderValues {
    score?: number;
    passFail?: string;
    totalQuestions?: number;
    answeredCount?: number;
}

interface QuestionWithAnswer {
    questionId: string;
    title: string;
    answer: unknown;
    /** Full question with interface for widget rendering in view mode. */
    question?: QuestionnaireViewerQuestion;
}

type FlowStep$1 = 'pre' | 'questions' | 'review' | 'summary';
declare class AXMQuestionnaireViewerPageComponent extends AXPPageLayoutBaseComponent {
    protected readonly route: ActivatedRoute;
    private readonly router;
    private readonly caseService;
    private readonly questionnaireService;
    private readonly assessmentSessionService;
    private readonly authSession;
    protected readonly structure: _angular_core.WritableSignal<QuestionnaireBuilderValue | null>;
    protected readonly questionnaire: _angular_core.WritableSignal<AXMAssessmentManagementQuestionnaireEntityModel | null>;
    protected readonly initialAnswers: _angular_core.WritableSignal<Record<string, any>>;
    protected readonly viewerConfig: _angular_core.WritableSignal<QuestionnaireViewerConfig | undefined>;
    protected readonly prePostConfig: _angular_core.WritableSignal<_acorex_modules_assessment_management.PrePostConfig | null>;
    protected readonly isLoading: _angular_core.WritableSignal<boolean>;
    protected readonly loadError: _angular_core.WritableSignal<string | null>;
    protected readonly currentSessionId: _angular_core.WritableSignal<string | null>;
    protected readonly flowStep: _angular_core.WritableSignal<FlowStep$1>;
    protected readonly reviewSnapshot: _angular_core.WritableSignal<QuestionWithAnswer[]>;
    protected readonly reviewContext: _angular_core.WritableSignal<Record<string, any> | null>;
    protected readonly submitResult: _angular_core.WritableSignal<SummaryPlaceholderValues | null>;
    protected readonly isSubmitting: _angular_core.WritableSignal<boolean>;
    protected readonly canNavigatePrevious: _angular_core.WritableSignal<boolean>;
    protected readonly canNavigateNext: _angular_core.WritableSignal<boolean>;
    protected readonly showNavigationButtons: _angular_core.WritableSignal<boolean>;
    protected readonly isLastStep: _angular_core.WritableSignal<boolean>;
    protected readonly areAllRequiredQuestionsAnswered: _angular_core.WritableSignal<boolean>;
    protected readonly viewer: _angular_core.Signal<AXMQuestionnaireViewerComponent | undefined>;
    protected readonly viewerViewModel: _angular_core.Signal<({
        questionnaireData: _angular_core.Signal<QuestionnaireViewerData | null>;
        structure: _angular_core.Signal<QuestionnaireBuilderValue | null>;
        config: _angular_core.Signal<QuestionnaireViewerConfig | null>;
        isLoading: _angular_core.Signal<boolean>;
        error: _angular_core.Signal<string | null>;
        currentSectionIndex: _angular_core.Signal<number>;
        currentQuestionIndex: _angular_core.Signal<number>;
        timerElapsed: _angular_core.Signal<number>;
        timerInterval: _angular_core.Signal<any>;
        form: _angular_core.Signal<any>;
        widgetContainer: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetContainerComponent | null>;
        validationErrors: _angular_core.Signal<QuestionnaireValidationError[]>;
        viewMode: _angular_core.Signal<QuestionnaireViewMode>;
        sections: _angular_core.Signal<QuestionnaireViewerSection[]>;
        currentSection: _angular_core.Signal<QuestionnaireViewerSection | null>;
        currentQuestion: _angular_core.Signal<QuestionnaireViewerQuestion | null>;
        totalQuestionsCount: _angular_core.Signal<number>;
        totalSectionsCount: _angular_core.Signal<number>;
        progressMode: _angular_core.Signal<QuestionnaireProgressMode>;
        answeredQuestionsCount: _angular_core.Signal<number>;
        progressPercentage: _angular_core.Signal<number>;
        showProgressBar: _angular_core.Signal<boolean>;
        showTimer: _angular_core.Signal<boolean>;
        timerTimeLimit: _angular_core.Signal<number | undefined>;
        showSectionTitles: _angular_core.Signal<boolean>;
        showQuestionNumbers: _angular_core.Signal<boolean>;
        showQuestionCounter: _angular_core.Signal<boolean>;
        currentQuestionPosition: _angular_core.Signal<{
            current: number;
            total: number;
        }>;
        timerText: _angular_core.Signal<string>;
        timerWidget: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetNode | null>;
        validateBeforeNavigation: _angular_core.Signal<boolean>;
        canNavigateNext: _angular_core.Signal<boolean>;
        canNavigatePrevious: _angular_core.Signal<boolean>;
        isLastStep: _angular_core.Signal<boolean>;
        areAllRequiredQuestionsAnswered: _angular_core.Signal<boolean>;
        registerForm: (form: any) => void;
        registerWidgetContainer: (container: _acorex_platform_layout_widget_core.AXPWidgetContainerComponent) => void;
        loadQuestionnaire: (id: string, initialAnswers?: Record<string, any>, config?: QuestionnaireViewerConfig) => Promise<void>;
        loadStructure: (structure: QuestionnaireBuilderValue, config?: QuestionnaireViewerConfig, initialAnswers?: Record<string, any>) => Promise<void>;
        isQuestionVisible: (question: QuestionnaireViewerQuestion) => boolean;
        getVisibleQuestions: () => QuestionnaireViewerQuestion[];
        validateQuestion: (question: QuestionnaireViewerQuestion) => Promise<string | null>;
        validateCurrentPage: () => Promise<QuestionnaireValidationResult>;
        validateAllQuestions: () => Promise<QuestionnaireValidationResult>;
        navigateNext: () => Promise<boolean>;
        navigatePrevious: () => Promise<boolean>;
        isCurrentSectionValid: () => Promise<boolean>;
        isSectionNavigable: (sectionIndex: number) => Promise<boolean>;
        navigateToSection: (index: number) => Promise<boolean>;
        navigateToQuestion: (sectionIndex: number, questionIndex: number) => Promise<boolean>;
        getAllAnswers: () => Record<string, any>;
        getQuestionsWithAnswers: () => Array<{
            questionId: string;
            questionBankItemId: string;
            sectionId: string;
            title: string;
            description?: string;
            answer: any;
            isRequired?: boolean;
            question: QuestionnaireViewerQuestion;
        }>;
        getSectionUnansweredRequiredCount: (sectionId: string) => number;
        submit: () => Promise<{
            success: boolean;
            answers: Record<string, any>;
            errors?: QuestionnaireValidationError[];
        }>;
        startTimer: () => void;
        stopTimer: () => void;
        updateTimerElapsed: (value: number) => void;
    } & _ngrx_signals.StateSource<{
        questionnaireData: QuestionnaireViewerData | null;
        structure: QuestionnaireBuilderValue | null;
        config: QuestionnaireViewerConfig | null;
        isLoading: boolean;
        error: string | null;
        currentSectionIndex: number;
        currentQuestionIndex: number;
        timerElapsed: number;
        timerInterval: any;
        form: any;
        widgetContainer: _acorex_platform_layout_widget_core.AXPWidgetContainerComponent | null;
        validationErrors: QuestionnaireValidationError[];
    }>) | undefined>;
    protected readonly totalQuestionsCount: _angular_core.Signal<number>;
    protected readonly totalSectionsCount: _angular_core.Signal<number>;
    protected readonly showTimer: _angular_core.Signal<boolean>;
    protected readonly timerTimeLimit: _angular_core.Signal<number | undefined>;
    protected readonly timerElapsed: _angular_core.Signal<number>;
    protected readonly showProgressBar: _angular_core.Signal<boolean>;
    protected readonly answeredQuestionsCount: _angular_core.Signal<number>;
    protected readonly isReadonly: _angular_core.Signal<boolean>;
    protected readonly showReviewButton: _angular_core.Signal<boolean>;
    /** Use answers from review context when returning from review; otherwise use initial answers. */
    protected readonly effectiveInitialAnswers: _angular_core.Signal<Record<string, any>>;
    constructor();
    ngOnInit(): Promise<void>;
    private loadData;
    private saveSessionAndGetSummary;
    getPageTitle(): Promise<string>;
    getPageBreadcrumbs(): ReturnType<AXPPageLayoutBaseComponent['getPageBreadcrumbs']>;
    getBackButton(): Promise<{
        title: string;
    } | null>;
    onBackButtonClick(): void;
    private getCasesListPath;
    private calculateProgress;
    protected handleAnswersChanged(_answers: Record<string, any>): void;
    protected handleReviewClick(): void;
    protected handleReviewSubmit(): Promise<void>;
    protected handlePreviousClick(): Promise<void>;
    protected handleNextClick(): Promise<void>;
    protected handleSubmitClick(): Promise<void>;
    protected handleDone(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireViewerPageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMQuestionnaireViewerPageComponent, "axm-questionnaire-viewer-page", never, {}, {}, never, never, true, never>;
}

type FlowStep = 'pre' | 'questions' | 'review' | 'summary';
declare class AXMQuestionnaireViewerStandalonePageComponent implements OnInit {
    private readonly route;
    private readonly sessionService;
    private readonly caseService;
    private readonly questionnaireService;
    protected readonly structure: _angular_core.WritableSignal<QuestionnaireBuilderValue | null>;
    protected readonly questionnaire: _angular_core.WritableSignal<any>;
    protected readonly initialAnswers: _angular_core.WritableSignal<Record<string, any>>;
    protected readonly prePostConfig: _angular_core.WritableSignal<_acorex_modules_assessment_management.PrePostConfig | null>;
    protected readonly viewerConfig: _angular_core.WritableSignal<QuestionnaireViewerConfig | undefined>;
    protected readonly isLoading: _angular_core.WritableSignal<boolean>;
    protected readonly loadError: _angular_core.WritableSignal<string | null>;
    protected readonly isSubmitting: _angular_core.WritableSignal<boolean>;
    protected readonly flowStep: _angular_core.WritableSignal<FlowStep>;
    protected readonly reviewSnapshot: _angular_core.WritableSignal<QuestionWithAnswer[]>;
    protected readonly reviewContext: _angular_core.WritableSignal<Record<string, any> | null>;
    protected readonly submitResult: _angular_core.WritableSignal<SummaryPlaceholderValues | null>;
    protected readonly canNavigatePrevious: _angular_core.WritableSignal<boolean>;
    protected readonly canNavigateNext: _angular_core.WritableSignal<boolean>;
    protected readonly showNavigationButtons: _angular_core.WritableSignal<boolean>;
    protected readonly isLastStep: _angular_core.WritableSignal<boolean>;
    protected readonly areAllRequiredQuestionsAnswered: _angular_core.WritableSignal<boolean>;
    protected readonly viewer: _angular_core.Signal<AXMQuestionnaireViewerComponent | undefined>;
    protected readonly viewerViewModel: _angular_core.Signal<({
        questionnaireData: _angular_core.Signal<QuestionnaireViewerData | null>;
        structure: _angular_core.Signal<QuestionnaireBuilderValue | null>;
        config: _angular_core.Signal<QuestionnaireViewerConfig | null>;
        isLoading: _angular_core.Signal<boolean>;
        error: _angular_core.Signal<string | null>;
        currentSectionIndex: _angular_core.Signal<number>;
        currentQuestionIndex: _angular_core.Signal<number>;
        timerElapsed: _angular_core.Signal<number>;
        timerInterval: _angular_core.Signal<any>;
        form: _angular_core.Signal<any>;
        widgetContainer: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetContainerComponent | null>;
        validationErrors: _angular_core.Signal<QuestionnaireValidationError[]>;
        viewMode: _angular_core.Signal<QuestionnaireViewMode>;
        sections: _angular_core.Signal<QuestionnaireViewerSection[]>;
        currentSection: _angular_core.Signal<QuestionnaireViewerSection | null>;
        currentQuestion: _angular_core.Signal<QuestionnaireViewerQuestion | null>;
        totalQuestionsCount: _angular_core.Signal<number>;
        totalSectionsCount: _angular_core.Signal<number>;
        progressMode: _angular_core.Signal<QuestionnaireProgressMode>;
        answeredQuestionsCount: _angular_core.Signal<number>;
        progressPercentage: _angular_core.Signal<number>;
        showProgressBar: _angular_core.Signal<boolean>;
        showTimer: _angular_core.Signal<boolean>;
        timerTimeLimit: _angular_core.Signal<number | undefined>;
        showSectionTitles: _angular_core.Signal<boolean>;
        showQuestionNumbers: _angular_core.Signal<boolean>;
        showQuestionCounter: _angular_core.Signal<boolean>;
        currentQuestionPosition: _angular_core.Signal<{
            current: number;
            total: number;
        }>;
        timerText: _angular_core.Signal<string>;
        timerWidget: _angular_core.Signal<_acorex_platform_layout_widget_core.AXPWidgetNode | null>;
        validateBeforeNavigation: _angular_core.Signal<boolean>;
        canNavigateNext: _angular_core.Signal<boolean>;
        canNavigatePrevious: _angular_core.Signal<boolean>;
        isLastStep: _angular_core.Signal<boolean>;
        areAllRequiredQuestionsAnswered: _angular_core.Signal<boolean>;
        registerForm: (form: any) => void;
        registerWidgetContainer: (container: _acorex_platform_layout_widget_core.AXPWidgetContainerComponent) => void;
        loadQuestionnaire: (id: string, initialAnswers?: Record<string, any>, config?: QuestionnaireViewerConfig) => Promise<void>;
        loadStructure: (structure: QuestionnaireBuilderValue, config?: QuestionnaireViewerConfig, initialAnswers?: Record<string, any>) => Promise<void>;
        isQuestionVisible: (question: QuestionnaireViewerQuestion) => boolean;
        getVisibleQuestions: () => QuestionnaireViewerQuestion[];
        validateQuestion: (question: QuestionnaireViewerQuestion) => Promise<string | null>;
        validateCurrentPage: () => Promise<QuestionnaireValidationResult>;
        validateAllQuestions: () => Promise<QuestionnaireValidationResult>;
        navigateNext: () => Promise<boolean>;
        navigatePrevious: () => Promise<boolean>;
        isCurrentSectionValid: () => Promise<boolean>;
        isSectionNavigable: (sectionIndex: number) => Promise<boolean>;
        navigateToSection: (index: number) => Promise<boolean>;
        navigateToQuestion: (sectionIndex: number, questionIndex: number) => Promise<boolean>;
        getAllAnswers: () => Record<string, any>;
        getQuestionsWithAnswers: () => Array<{
            questionId: string;
            questionBankItemId: string;
            sectionId: string;
            title: string;
            description?: string;
            answer: any;
            isRequired?: boolean;
            question: QuestionnaireViewerQuestion;
        }>;
        getSectionUnansweredRequiredCount: (sectionId: string) => number;
        submit: () => Promise<{
            success: boolean;
            answers: Record<string, any>;
            errors?: QuestionnaireValidationError[];
        }>;
        startTimer: () => void;
        stopTimer: () => void;
        updateTimerElapsed: (value: number) => void;
    } & _ngrx_signals.StateSource<{
        questionnaireData: QuestionnaireViewerData | null;
        structure: QuestionnaireBuilderValue | null;
        config: QuestionnaireViewerConfig | null;
        isLoading: boolean;
        error: string | null;
        currentSectionIndex: number;
        currentQuestionIndex: number;
        timerElapsed: number;
        timerInterval: any;
        form: any;
        widgetContainer: _acorex_platform_layout_widget_core.AXPWidgetContainerComponent | null;
        validationErrors: QuestionnaireValidationError[];
    }>) | undefined>;
    protected readonly totalQuestionsCount: _angular_core.Signal<number>;
    protected readonly showTimer: _angular_core.Signal<boolean>;
    protected readonly timerTimeLimit: _angular_core.Signal<number | undefined>;
    protected readonly timerElapsed: _angular_core.Signal<number>;
    protected readonly showProgressBar: _angular_core.Signal<boolean>;
    protected readonly answeredQuestionsCount: _angular_core.Signal<number>;
    protected readonly isReadonly: _angular_core.Signal<boolean>;
    protected readonly showReviewButton: _angular_core.Signal<boolean>;
    /** Use answers from review context when returning from review; otherwise use initial answers. */
    protected readonly effectiveInitialAnswers: _angular_core.Signal<Record<string, any>>;
    constructor();
    ngOnInit(): void;
    private loadData;
    private saveSessionAndGetSummary;
    private calculateProgress;
    protected handleReviewClick(): void;
    protected handleReviewSubmit(): Promise<void>;
    protected handlePreviousClick(): Promise<void>;
    protected handleNextClick(): Promise<void>;
    protected handleSubmitClick(): Promise<void>;
    protected handleDone(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMQuestionnaireViewerStandalonePageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMQuestionnaireViewerStandalonePageComponent, "axm-questionnaire-viewer-standalone-page", never, {}, {}, never, never, true, never>;
}

export { AXMAssessmentCaseService, AXMAssessmentCaseServiceImpl, AXMAssessmentManagementEntityProvider, AXMAssessmentManagementFeatureDefinitionProvider, AXMAssessmentManagementFeatureKeys, AXMAssessmentManagementMenuProvider, AXMAssessmentManagementModule, AXMAssessmentManagementPermissionDefinitionProvider, AXMAssessmentManagementPermissionKeys, AXMAssessmentManagementSearchCommandProvider, AXMAssessmentSessionService, AXMAssessmentSessionServiceImpl, AXMQuestionBankItemService, AXMQuestionBankItemServiceImpl, AXMQuestionnaireService, AXMQuestionnaireServiceImpl, AXMQuestionnaireViewerPageComponent, AXMQuestionnaireViewerStandalonePageComponent, AXPAssessmentManagementMenuKeys, RootConfig, toPrePostConfig };
export type { AXMAssessmentCaseStatus, AXMAssessmentManagementAssessmentCaseEntityModel, AXMAssessmentManagementAssessmentSessionEntityModel, AXMAssessmentManagementQuestionBankItemEntityModel, AXMAssessmentManagementQuestionnaireEntityModel, AXMAssessmentSessionRole, AXMAssessmentSessionStatus, PostQuestionnaireConfig, PrePostConfig, PrePostContentValue, PreQuestionnaireConfig };
