import { DbxInjectionComponentConfig, DbxActionSuccessHandlerFunction } from '@dereekb/dbx-core';
import { IndexNumber, Maybe, RangeInput, MaybeMap } from '@dereekb/util';
import * as rxjs from 'rxjs';
import { Observable, Subscription } from 'rxjs';
import * as _dereekb_dbx_form_quiz from '@dereekb/dbx-form/quiz';
import { ComponentStore } from '@ngrx/component-store';
import { ObservableOrValue, Work } from '@dereekb/rxjs';
import * as _angular_core from '@angular/core';
import { Provider, Signal } from '@angular/core';

/**
 * Unique identifier for a quiz instance.
 */
type QuizId = string;
/**
 * Unique identifier for a question within a quiz.
 */
type QuizQuestionId = string;
/**
 * Zero-based index of the currently selected question.
 */
type QuestionIndex = IndexNumber;
/**
 * Full quiz definition including metadata, questions, and injection configs for pre/post views.
 *
 * @example
 * ```ts
 * const quiz: Quiz = {
 *   id: 'onboarding',
 *   titleDetails: { title: 'Onboarding Quiz' },
 *   questions: [{ id: 'q1', questionComponentConfig: { ... }, answerComponentConfig: { ... } }],
 *   resultsComponentConfig: { componentClass: MyResultsComponent }
 * };
 * ```
 */
interface Quiz {
    readonly id: QuizId;
    /**
     * Title details for the quiz.
     */
    readonly titleDetails: QuizTitleDetails;
    /**
     * Questions to display. The questions are displayed in order.
     */
    readonly questions: QuizQuestion[];
    /**
     * Component config for the pre-quiz view.
     */
    readonly preQuizComponentConfig?: DbxInjectionComponentConfig<any>;
    /**
     * Component config for the results view.
     */
    readonly resultsComponentConfig: DbxInjectionComponentConfig<any>;
}
/**
 * Display metadata for a quiz header area.
 */
interface QuizTitleDetails {
    /**
     * Name/title of the quiz
     */
    readonly title: string;
    /**
     * Subtitle of the quiz
     */
    readonly subtitle?: string;
    /**
     * Description of the quiz
     */
    readonly description?: string;
}
/**
 * Pairs a question id with the user's typed answer data.
 */
interface QuizAnswer<T = unknown> {
    /**
     * Id of the question this answer belongs to.
     */
    readonly id: QuizQuestionId;
    /**
     * The answer payload, typed per-question component.
     */
    readonly data: T;
}
/**
 * Lightweight pair linking a question id to its positional index in the quiz.
 */
interface QuizQuestionIdIndexPair {
    readonly id: QuizQuestionId;
    readonly index: QuestionIndex;
}
/**
 * Single question definition within a quiz, pairing a display component with an answer component.
 */
interface QuizQuestion {
    /**
     * Question id. Should be unique in the quiz.
     */
    readonly id: QuizQuestionId;
    /**
     * Question component config
     */
    readonly questionComponentConfig: DbxInjectionComponentConfig<any>;
    /**
     * Answer component config
     */
    readonly answerComponentConfig: DbxInjectionComponentConfig<any>;
}
/**
 * A QuizQuestion enriched with its positional index, used by the store to track the current question.
 */
interface QuizQuestionWithIndex extends QuizQuestion, QuizQuestionIdIndexPair {
}

/**
 * Internal state shape managed by QuizStore.
 */
interface QuizStoreState {
    /**
     * Map of questions, keyed by id.
     *
     * Unset if the quiz is not yet set.
     */
    readonly questionMap?: Maybe<ReadonlyMap<QuizQuestionId, QuizQuestion>>;
    /**
     * Started quiz
     */
    readonly startedQuiz: boolean;
    /**
     * Questions that have been answered, sorted by index.
     */
    readonly completedQuestions: QuizQuestionIdIndexPair[];
    /**
     * Questions that are remaining to be answered, sorted by index.
     */
    readonly unansweredQuestions: QuizQuestionIdIndexPair[];
    /**
     * Map of current answers.
     */
    readonly answers: ReadonlyMap<QuizQuestionId, QuizAnswer>;
    /**
     * The current index that corresponds with the selected question.
     *
     * If null, defaults to the first question.
     *
     * If greater than the total number of questions, then the quiz is considered complete.
     */
    readonly questionIndex?: Maybe<QuestionIndex>;
    /**
     * If true, the quiz is locked from navigation.
     *
     * Typically used while submitting the quiz.
     */
    readonly lockQuizNavigation?: boolean;
    /**
     * If true, the quiz has been marked as submitted.
     */
    readonly submittedQuiz?: boolean;
    /**
     * The current/active quiz.
     */
    readonly quiz?: Maybe<Quiz>;
    /**
     * If true, allows going back to visit previous questions.
     */
    readonly allowVisitingPreviousQuestion: boolean;
    /**
     * If true, automatically advances to the next question when an answer is set.
     */
    readonly autoAdvanceToNextQuestion: boolean;
    /**
     * Whether or not skipping questions is allowed.
     *
     * Defaults to false.
     */
    readonly allowSkipQuestion: boolean;
}
/**
 * Lookup input for retrieving an answer by question id, index, or the current question.
 * Provide exactly one of `id`, `index`, or `currentIndex`.
 */
interface QuizStoreAnswerLookupInput extends Partial<QuizQuestionIdIndexPair> {
    readonly currentIndex?: boolean;
}
/**
 * NgRx ComponentStore that manages quiz lifecycle: question navigation, answer tracking,
 * submission state, and navigation locking.
 *
 * Provided at the component level by `QuizComponent`.
 *
 * @example
 * ```ts
 * // Access from a child component via DI:
 * readonly quizStore = inject(QuizStore);
 * this.quizStore.startQuiz();
 * this.quizStore.updateAnswerForCurrentQuestion(5);
 * ```
 */
declare class QuizStore extends ComponentStore<QuizStoreState> {
    constructor();
    readonly quiz$: Observable<Maybe<Quiz>>;
    readonly titleDetails$: Observable<_dereekb_dbx_form_quiz.QuizTitleDetails | undefined>;
    readonly questions$: Observable<QuizQuestion[]>;
    readonly startedQuiz$: Observable<boolean>;
    readonly lockQuizNavigation$: Observable<boolean | undefined>;
    readonly submittedQuiz$: Observable<boolean | undefined>;
    readonly answers$: Observable<ReadonlyMap<string, QuizAnswer<unknown>>>;
    readonly questionIndex$: Observable<number>;
    readonly completedQuestions$: Observable<QuizQuestionIdIndexPair[]>;
    readonly unansweredQuestions$: Observable<QuizQuestionIdIndexPair[]>;
    readonly hasAnswerForEachQuestion$: Observable<boolean>;
    readonly isAtEndOfQuestions$: Observable<boolean>;
    readonly canGoToPreviousQuestion$: Observable<boolean>;
    readonly canGoToNextQuestion$: Observable<boolean>;
    readonly currentQuestion$: Observable<Maybe<QuizQuestionWithIndex>>;
    /**
     * Returns a reactive observable of the answer for a given question, looked up by id, index, or the current question.
     *
     * @param lookupInput - Lookup criteria specifying which question's answer to retrieve.
     * @param lookupInput - Lookup criteria specifying which question's answer to retrieve.
     * @returns An observable that emits the current answer for the specified question, or undefined if not answered.
     *
     * @example
     * ```ts
     * // By current question:
     * store.answerForQuestion({ currentIndex: true }).subscribe(answer => console.log(answer));
     * // By question id:
     * store.answerForQuestion({ id: 'q1' }).subscribe(answer => console.log(answer));
     * ```
     */
    answerForQuestion(lookupInput: ObservableOrValue<QuizStoreAnswerLookupInput>): Observable<Maybe<QuizAnswer>>;
    readonly startQuiz: () => void;
    readonly setQuiz: (() => void) | ((observableOrValue: Maybe<Quiz> | Observable<Maybe<Quiz>>) => rxjs.Subscription);
    /**
     * Resets the quiz entirely, back to the pre-quiz state.
     */
    readonly resetQuiz: () => void;
    /**
     * Restarts the quiz to the first question.
     */
    readonly restartQuizToFirstQuestion: () => void;
    readonly setAnswers: (() => void) | ((observableOrValue: Maybe<QuizAnswer<unknown>[]> | Observable<Maybe<QuizAnswer<unknown>[]>>) => rxjs.Subscription);
    readonly updateAnswers: (() => void) | ((observableOrValue: Maybe<QuizAnswer<unknown>[]> | Observable<Maybe<QuizAnswer<unknown>[]>>) => rxjs.Subscription);
    readonly updateAnswerForCurrentQuestion: (observableOrValue: unknown) => rxjs.Subscription;
    readonly setQuestionIndex: (observableOrValue: number | Observable<number>) => rxjs.Subscription;
    readonly setAutoAdvanceToNextQuestion: (observableOrValue: boolean | Observable<boolean>) => rxjs.Subscription;
    readonly setAllowSkipQuestion: (observableOrValue: boolean | Observable<boolean>) => rxjs.Subscription;
    readonly setAllowVisitingPreviousQuestion: (observableOrValue: boolean | Observable<boolean>) => rxjs.Subscription;
    readonly goToNextQuestion: () => void;
    readonly goToPreviousQuestion: () => void;
    readonly setLockQuizNavigation: (observableOrValue: boolean | Observable<boolean>) => rxjs.Subscription;
    readonly setSubmittedQuiz: (observableOrValue: boolean | Observable<boolean>) => rxjs.Subscription;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuizStore, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<QuizStore>;
}

/**
 * Abstract accessor injected into answer/question child components to read the current question
 * and write answers back to the QuizStore without coupling to it directly.
 *
 * Use `provideCurrentQuestionQuizQuestionAccessor()` to bind this to the store's current question.
 */
declare abstract class QuizQuestionAccessor<T = unknown> {
    /**
     * The active quiz definition.
     */
    abstract readonly quiz$: Observable<Maybe<Quiz>>;
    /**
     * The question this accessor is bound to.
     */
    abstract readonly question$: Observable<Maybe<QuizQuestion>>;
    /**
     * The current answer for this question, or undefined if unanswered.
     */
    abstract readonly answer$: Observable<Maybe<QuizAnswer<T>>>;
    /**
     * Submits an answer value for this question.
     */
    abstract setAnswer(answer: T): void;
    /**
     * Binds an observable source whose emissions are forwarded as answer updates.
     */
    abstract setAnswerSource(answer: Observable<T>): Subscription;
}
/**
 * Provides QuizQuestionAccessor bound to the current question in QuizStore.
 *
 * @returns An Angular provider that binds QuizQuestionAccessor to the current quiz question.
 *
 * @usage
 * ```typescript
 * @Component ({
 *   providers: [QuizStore, provideCurrentQuestionQuizQuestionAccessor()]
 * })
 * ```
 */
declare function provideCurrentQuestionQuizQuestionAccessor<T = unknown>(): Provider;

/**
 * Lifecycle state of the quiz container view.
 */
type QuizComponentState = 'init' | 'pre-quiz' | 'quiz' | 'post-quiz';
/**
 * Discriminated union of view configs, one per quiz lifecycle state.
 */
type QuizComponentViewConfig = QuizComponentViewInitConfig | QuizComponentViewPreQuizConfig | QuizComponentViewQuizConfig | QuizComponentViewPostQuizConfig;
interface QuizComponentViewInitConfig {
    readonly state: 'init';
}
interface QuizComponentViewPreQuizConfig {
    readonly state: 'pre-quiz';
    readonly preQuizComponent?: Maybe<DbxInjectionComponentConfig>;
}
interface QuizComponentViewQuizConfig {
    readonly state: 'quiz';
    readonly questionComponent?: Maybe<DbxInjectionComponentConfig>;
    readonly answerComponent?: Maybe<DbxInjectionComponentConfig>;
}
interface QuizComponentViewPostQuizConfig {
    readonly state: 'post-quiz';
    readonly resultsComponent?: Maybe<DbxInjectionComponentConfig>;
}
/**
 * Top-level quiz container that orchestrates pre-quiz, active quiz, and post-quiz views.
 *
 * Provides its own `QuizStore` and `QuizQuestionAccessor`, so child components injected via
 * `DbxInjectionComponent` can access quiz state directly through DI.
 *
 * Supports keyboard navigation: Enter (start / next), ArrowLeft (previous), ArrowRight (next).
 *
 * @example
 * ```html
 * <dbx-quiz [quiz]="myQuiz"></dbx-quiz>
 * ```
 */
declare class QuizComponent {
    readonly quizStore: QuizStore;
    readonly quiz: _angular_core.InputSignal<Maybe<Quiz>>;
    readonly keysFilter: string[];
    readonly quizEffect: _angular_core.EffectRef;
    readonly quiz$: Observable<Maybe<Quiz>>;
    readonly quizTitleSignal: Signal<string | undefined>;
    readonly currentQuestionSignal: Signal<Maybe<_dereekb_dbx_form_quiz.QuizQuestionWithIndex>>;
    readonly questionTitleSignal: Signal<string>;
    readonly startedQuiz$: Observable<boolean>;
    readonly currentQuestion$: Observable<Maybe<_dereekb_dbx_form_quiz.QuizQuestionWithIndex>>;
    readonly canGoToPreviousQuestionSignal: Signal<boolean>;
    readonly canGoToNextQuestionSignal: Signal<boolean>;
    readonly viewConfig$: Observable<QuizComponentViewConfig>;
    readonly viewConfigSignal: Signal<QuizComponentViewConfig>;
    readonly viewStateSignal: Signal<QuizComponentState>;
    readonly preQuizComponentConfigSignal: Signal<Maybe<DbxInjectionComponentConfig>>;
    readonly questionComponentConfigSignal: Signal<Maybe<DbxInjectionComponentConfig>>;
    readonly answerComponentConfigSignal: Signal<Maybe<DbxInjectionComponentConfig>>;
    readonly resultsComponentConfigSignal: Signal<Maybe<DbxInjectionComponentConfig>>;
    handleKeyDown(event: KeyboardEvent): void;
    clickPreviousQuestion(): void;
    clickNextQuestion(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuizComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuizComponent, "dbx-quiz", never, { "quiz": { "alias": "quiz"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Named preset for common number ranges.
 */
type QuizAnswerNumberComponentPreset = 'oneToFive';
/**
 * Configuration for the number answer component. Provide a preset, explicit range, or arbitrary numbers.
 */
interface QuizAnswerNumberComponentConfig {
    /**
     * Uses a preset to compute the range/numbers.
     */
    readonly preset?: QuizAnswerNumberComponentPreset;
    /**
     * Range configuration
     */
    readonly range?: RangeInput;
    /**
     * Arbitrary array of numbers
     */
    readonly numbers?: number[];
}
interface QuizAnswerNumberChoice {
    readonly number: number;
    readonly selected?: boolean;
}
/**
 * Answer component that displays configurable number buttons.
 *
 * @usage
 * Used as an answer component in a QuizQuestion's answerComponentConfig.
 * Defaults to 1-5 range if no config is provided.
 *
 * ```typescript
 * answerComponentConfig: {
 *   componentClass: QuizAnswerNumberComponent,
 *   init: (instance: QuizAnswerNumberComponent) => {
 *     instance.config.set({ range: { start: 1, end: 11 } });
 *   }
 * }
 * ```
 */
declare class QuizAnswerNumberComponent {
    readonly questionAccessor: QuizQuestionAccessor<number>;
    readonly config: _angular_core.ModelSignal<Maybe<QuizAnswerNumberComponentConfig>>;
    readonly currentAnswerSignal: _angular_core.Signal<Maybe<_dereekb_dbx_form_quiz.QuizAnswer<number>>>;
    readonly currentAnswerValueSignal: _angular_core.Signal<number | undefined>;
    readonly choicesSignal: _angular_core.Signal<QuizAnswerNumberChoice[]>;
    readonly relevantKeysSignal: _angular_core.Signal<string[]>;
    clickedAnswer(answer: number): void;
    handleKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuizAnswerNumberComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuizAnswerNumberComponent, "ng-component", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
}

/**
 * Upper-case letter label for a multiple choice option (e.g. "A", "B").
 */
type MultipleChoiceLetter = string;
/**
 * Display text for a single multiple choice option.
 */
type MultipleChoiceText = string;
/**
 * Answer data stored when a multiple choice option is selected.
 */
interface MultipleChoiceAnswer {
    readonly isCorrectAnswer: boolean;
    readonly letter: MultipleChoiceLetter;
    readonly text: MultipleChoiceText;
}
/**
 * Configuration for the multiple choice answer component.
 */
interface QuizAnswerMultipleChoiceComponentConfig {
    /**
     * Ordered list of answer option texts. Letters are auto-assigned A, B, C, etc.
     */
    readonly answerText: readonly MultipleChoiceText[];
    /**
     * Zero-based index of the correct answer, used to set `isCorrectAnswer` on the stored answer.
     */
    readonly correctAnswerIndex?: number;
}
interface QuizAnswerMultipleChoice extends MultipleChoiceAnswer {
    readonly selected?: boolean;
}
/**
 * Answer component that displays multiple choice letter-labeled buttons.
 *
 * @usage
 * Used as an answer component in a QuizQuestion's answerComponentConfig.
 * Supports keyboard shortcuts (pressing the letter key selects that answer).
 *
 * ```typescript
 * answerComponentConfig: {
 *   componentClass: QuizAnswerMultipleChoiceComponent,
 *   init: (instance: QuizAnswerMultipleChoiceComponent) => {
 *     instance.config.set({
 *       answerText: ['Option A', 'Option B', 'Option C'],
 *       correctAnswerIndex: 1
 *     });
 *   }
 * }
 * ```
 */
declare class QuizAnswerMultipleChoiceComponent {
    readonly questionAccessor: QuizQuestionAccessor<QuizAnswerMultipleChoice>;
    readonly config: _angular_core.ModelSignal<Maybe<QuizAnswerMultipleChoiceComponentConfig>>;
    readonly currentAnswerSignal: _angular_core.Signal<Maybe<_dereekb_dbx_form_quiz.QuizAnswer<QuizAnswerMultipleChoice>>>;
    readonly currentAnswerValueSignal: _angular_core.Signal<QuizAnswerMultipleChoice | undefined>;
    readonly choicesSignal: _angular_core.Signal<QuizAnswerMultipleChoice[]>;
    readonly relevantKeysSignal: _angular_core.Signal<string[]>;
    clickedAnswer(answer: QuizAnswerMultipleChoice): void;
    handleKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuizAnswerMultipleChoiceComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuizAnswerMultipleChoiceComponent, "ng-component", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
}

/**
 * Config for the pre-quiz intro component.
 *
 * Overrides the title details.
 */
type QuizPreQuizIntroConfig = Partial<MaybeMap<QuizTitleDetails>>;
/**
 * Pre-quiz intro component that displays the quiz title, subtitle, description, and a start button.
 *
 * @usage
 * Used as a preQuizComponentConfig in a Quiz definition.
 * Inherits title details from the quiz unless overridden via config.
 *
 * ```typescript
 * preQuizComponentConfig: {
 *   componentClass: QuizPreQuizIntroComponent,
 *   init: (instance: QuizPreQuizIntroComponent) => {
 *     instance.config.set({ subtitle: 'Custom subtitle' });
 *   }
 * }
 * ```
 */
declare class QuizPreQuizIntroComponent {
    readonly quizStore: QuizStore;
    readonly config: _angular_core.ModelSignal<Maybe<Partial<MaybeMap<QuizTitleDetails>>>>;
    readonly quizTitleDetailsSignal: _angular_core.Signal<QuizTitleDetails | undefined>;
    readonly configSignal: _angular_core.Signal<{
        title: string | undefined;
        subtitle: string | undefined;
        description: string | undefined;
    }>;
    readonly titleSignal: _angular_core.Signal<string | undefined>;
    readonly subtitleSignal: _angular_core.Signal<string | undefined>;
    readonly descriptionSignal: _angular_core.Signal<string | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuizPreQuizIntroComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuizPreQuizIntroComponent, "ng-component", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
}

/**
 * Configuration for the text-based question display. Used with `quizAgreementPrompt()` and
 * `quizFrequencyPrompt()` helpers for Likert-scale questions.
 */
interface QuizQuestionTextComponentConfig {
    /**
     * Instructional prompt displayed above the main text (e.g. "Rate how much you agree:").
     */
    readonly prompt?: string;
    /**
     * The primary question or statement text.
     */
    readonly text: string;
    /**
     * Scale guidance displayed below the text (e.g. "1 = Strongly Disagree, 5 = Strongly Agree").
     */
    readonly guidance?: string;
}
/**
 * Question component that displays text with optional prompt and guidance.
 *
 * @usage
 * Used as a questionComponentConfig in a QuizQuestion definition.
 *
 * ```typescript
 * questionComponentConfig: {
 *   componentClass: QuizQuestionTextComponent,
 *   init: (instance: QuizQuestionTextComponent) => {
 *     instance.config.set({ text: 'How do you handle ambiguity?', prompt: 'Rate yourself:', guidance: '1=Never, 5=Always' });
 *   }
 * }
 * ```
 */
declare class QuizQuestionTextComponent {
    readonly config: _angular_core.ModelSignal<Maybe<QuizQuestionTextComponentConfig>>;
    readonly promptSignal: _angular_core.Signal<string | undefined>;
    readonly textSignal: _angular_core.Signal<string | undefined>;
    readonly guidanceSignal: _angular_core.Signal<string | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuizQuestionTextComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuizQuestionTextComponent, "ng-component", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "config": "configChange"; }, never, never, true, never>;
}

/**
 * Submission lifecycle state within the post-quiz view.
 */
type DbxQuizPostQuizState = 'presubmit' | 'postsubmit';
/**
 * Post-quiz component that handles quiz submission and displays pre/post submit content.
 *
 * @usage
 * Use as a wrapper in your results component template:
 *
 * ```html
 * <dbx-quiz-post-quiz [handleSubmitQuiz]="handleSubmitQuiz">
 *   <div presubmit>Pre-submit content...</div>
 *   <div postsubmit>Post-submit content (scores, etc.)...</div>
 * </dbx-quiz-post-quiz>
 * ```
 */
declare class DbxQuizPostQuizComponent {
    readonly quizStore: QuizStore;
    readonly quizSubmittedSignal: _angular_core.Signal<boolean | undefined>;
    readonly stateSignal: _angular_core.Signal<"presubmit" | "postsubmit">;
    readonly handleSubmitQuiz: _angular_core.InputSignal<Work<void> | undefined>;
    readonly handleSubmitQuizButton: Work<void>;
    readonly handleSubmitQuizSuccess: DbxActionSuccessHandlerFunction;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxQuizPostQuizComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxQuizPostQuizComponent, "dbx-quiz-post-quiz", never, { "handleSubmitQuiz": { "alias": "handleSubmitQuiz"; "required": false; "isSignal": true; }; }, {}, never, ["[presubmit]", "[postsubmit]", "*"], true, never>;
}

/**
 * Button component that restarts the quiz to the first question.
 *
 * @usage
 * ```html
 * <dbx-quiz-reset-button buttonText="Try Again"></dbx-quiz-reset-button>
 * ```
 */
declare class DbxQuizResetButtonComponent {
    readonly quizStore: QuizStore;
    readonly buttonText: _angular_core.InputSignal<string>;
    readonly handleResetQuizButton: Work<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxQuizResetButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxQuizResetButtonComponent, "dbx-quiz-reset-button", never, { "buttonText": { "alias": "buttonText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Input data for rendering the quiz score display.
 */
interface DbxQuizScoreInput {
    /**
     * Whether to show the retake/reset button.
     */
    readonly showRetakeButton?: boolean;
    /**
     * Feedback text to display.
     */
    readonly feedbackText: string;
    /**
     * Optional subtitle text.
     */
    readonly subtitle?: Maybe<string>;
    /**
     * The score achieved.
     */
    readonly score: number;
    /**
     * The maximum possible score.
     */
    readonly maxScore: number;
}
/**
 * Generic quiz score display component.
 *
 * @usage
 * ```html
 * <dbx-quiz-score [input]="scoreInput"></dbx-quiz-score>
 * ```
 */
declare class DbxQuizScoreComponent {
    readonly input: _angular_core.InputSignal<Maybe<DbxQuizScoreInput>>;
    readonly scoreSignal: _angular_core.Signal<number | undefined>;
    readonly maxScoreSignal: _angular_core.Signal<number | undefined>;
    readonly feedbackTextSignal: _angular_core.Signal<string>;
    readonly subtitleSignal: _angular_core.Signal<Maybe<string>>;
    readonly showRetakeButtonSignal: _angular_core.Signal<boolean | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxQuizScoreComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxQuizScoreComponent, "dbx-quiz-score", never, { "input": { "alias": "input"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Creates a Likert scale question config with agreement prompt (Strongly Disagree to Strongly Agree).
 *
 * @param text - The statement to rate agreement on.
 * @param text - The statement to rate agreement on.
 * @returns A quiz question config with an agreement-based prompt and guidance text.
 *
 * @example
 * ```ts
 * instance.config.set(quizAgreementPrompt('I feel confident leading under pressure.'));
 * // { prompt: 'Please rate how much you agree...', text: '...', guidance: '1 = Strongly Disagree, 5 = Strongly Agree' }
 * ```
 */
declare function quizAgreementPrompt(text: string): QuizQuestionTextComponentConfig;
/**
 * Creates a Likert scale question config with frequency prompt (Never to Always).
 *
 * @param text - The statement to rate frequency on.
 * @param text - The statement to rate frequency on.
 * @returns A quiz question config with a frequency-based prompt and guidance text.
 *
 * @example
 * ```ts
 * instance.config.set(quizFrequencyPrompt('I break vague direction into first steps.'));
 * // { prompt: 'Please rate how much you agree...', text: '...', guidance: '1 = Never, 5 = Always' }
 * ```
 */
declare function quizFrequencyPrompt(text: string): QuizQuestionTextComponentConfig;

export { DbxQuizPostQuizComponent, DbxQuizResetButtonComponent, DbxQuizScoreComponent, QuizAnswerMultipleChoiceComponent, QuizAnswerNumberComponent, QuizComponent, QuizPreQuizIntroComponent, QuizQuestionAccessor, QuizQuestionTextComponent, QuizStore, provideCurrentQuestionQuizQuestionAccessor, quizAgreementPrompt, quizFrequencyPrompt };
export type { DbxQuizPostQuizState, DbxQuizScoreInput, MultipleChoiceAnswer, MultipleChoiceLetter, MultipleChoiceText, QuestionIndex, Quiz, QuizAnswer, QuizAnswerMultipleChoiceComponentConfig, QuizAnswerNumberComponentConfig, QuizAnswerNumberComponentPreset, QuizComponentState, QuizComponentViewConfig, QuizComponentViewInitConfig, QuizComponentViewPostQuizConfig, QuizComponentViewPreQuizConfig, QuizComponentViewQuizConfig, QuizId, QuizPreQuizIntroConfig, QuizQuestion, QuizQuestionId, QuizQuestionIdIndexPair, QuizQuestionTextComponentConfig, QuizQuestionWithIndex, QuizStoreAnswerLookupInput, QuizStoreState, QuizTitleDetails };