import * as lit from 'lit';
import { LitElement, PropertyValues, nothing } from 'lit';
import { b as transformTestApi, t as transformItemApi } from './qti-transform-test.d-BL7GGFJj.js';
import { C as ComputedContext, a as ComputedItem } from './computed.types.d-SsTm3ieP.js';
import { QtiAssessmentItem, QtiModalFeedback } from './elements.js';
import { Q as QtiContext } from './qti.context.d-CejJMlfZ.js';
import { T as TestContext, Q as QtiExpression, a as QtiExpressionBase } from './qti-expression.d-B-Cfbqlb.js';
import { TemplateFunction } from '@heximal/templates';
import { h as VariableValue, b as ItemContext, c as OutcomeVariable, V as VariableDeclaration } from './item.types.d-DuVR0ZVK.js';
import { S as SessionContext, V as View } from './session.context.d-Cw8GcziG.js';
import { C as ConfigContext } from './config.context.d-BvU9r-Mg.js';
import { b as QtiRuleBase } from './qti-rule-base.d-Bdzg8eGH.js';

declare class QtiAssessmentTest extends LitElement {
    #private;
    identifier: string;
    get title(): string;
    set title(value: string);
    _testContext?: TestContext;
    connectedCallback(): Promise<void>;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-assessment-test': QtiAssessmentTest;
    }
}
declare module '../../public-events' {
    interface PublicEventMap {
        'cito-test-loaded': CustomEvent<QtiAssessmentTest>;
    }
}

/**
 * Defined here, and re-exported by the navigation mixin under the same name, so this file imports
 * nothing from the mixin: the mixin imports the components that consume this context, and a type
 * import counts as a dependency for madge.
 */
type PostLoadTestTransformCallback = (transformer: transformTestApi, testElement: QtiAssessmentTest) => transformTestApi | Promise<transformTestApi>;
/**
 * What the components inside a test need from the `qti-test` that contains them: the things a host
 * put on it, and the element to query. Provided by `qti-test` about itself.
 *
 * It is context and not `closest('qti-test')` because a request crosses shadow roots and `closest`
 * stops at the first one, so a navigation or container a host renders inside its own component
 * would never find its test. Internal on purpose: not exported from the package, and not API.
 */
interface TestHost extends HTMLElement {
    qtiContext: QtiContext;
    postLoadTestTransformCallback: PostLoadTestTransformCallback | null;
}

/**
 * The model a `<template item-ref>` is rendered with.
 *
 * Only what this element already knows: the item's parsed document and the
 * attributes off the item-ref itself. `itemRef` is the escape hatch — a
 * template that needs anything else (a click handler, a value from the host
 * app) reaches it through a property on the element, which the host is free to
 * set.
 */
interface ItemRefTemplateModel {
    /** The item's parsed document, i.e. what the element renders by default. */
    xmlDoc: DocumentFragment;
    identifier?: string;
    href?: string;
    category?: string;
    /**
     * This item's entry in the computed context, the same object the stamps
     * iterate as `item`: `index` (1-based, null for info items), `score`,
     * `maxScore`, `completed`, `active`, … Undefined until the test has computed it.
     */
    item?: ComputedItem;
    /** The element being rendered. */
    itemRef: QtiAssessmentItemRef;
}
declare class QtiAssessmentItemRef extends LitElement {
    #private;
    category?: string;
    identifier?: string;
    required?: boolean;
    fixed?: boolean;
    href?: string;
    protected computedContext?: ComputedContext;
    /**
     * The `<qti-weight>` children of this ref, keyed by identifier — what
     * `qti-test-variables`' `weight-identifier` resolves against.
     *
     * Read on access rather than cached: the test document is rendered into this
     * element's light DOM, so the weights are not in place at construction time,
     * and outcome processing runs long after they are.
     */
    get weights(): Map<string, number>;
    xmlDoc: DocumentFragment | null;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    get assessmentItem(): QtiAssessmentItem | null;
    myTemplate: TemplateFunction | null;
    /** The `qti-test` this ref belongs to, wherever it renders: light DOM, or any depth of shadow roots. */
    protected testHost?: TestHost;
    disconnectedCallback(): void;
    connectedCallback(): Promise<void>;
    render(): unknown;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-assessment-item-ref': QtiAssessmentItemRef;
    }
}

declare class QtiAssessmentSection extends LitElement {
    #private;
    identifier: string;
    required: string;
    fixed: boolean;
    get title(): string;
    set title(value: string);
    visible: boolean;
    keepTogether: boolean;
    navigationMode?: 'linear' | 'nonlinear';
    submissionMode?: 'individual' | 'simultaneous';
    _testContext?: TestContext;
    connectedCallback(): Promise<void>;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-assessment-section': QtiAssessmentSection;
    }
}

/** An element that evaluates to a boolean: a `qti-pre-condition` or `qti-branch-rule`. */
interface Condition extends Element {
    evaluate(): boolean;
}

/**
 * @summary The qti-branch-rule element jumps the test forward to `target` when its expression is true.
 * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.branch-rule
 *
 * A child of `qti-test-part`, `qti-assessment-section` or `qti-assessment-item-ref`. It is
 * evaluated after the parent has been presented; the first rule whose expression is true wins.
 * Branch rules only apply in linear navigation mode. An expression that cannot be evaluated does
 * not branch.
 *
 * @attr {string} target - Required. The identifier of an item ref, section or test part ahead of
 *   the parent, or one of the reserved targets `EXIT_SECTION`, `EXIT_TESTPART`, `EXIT_TEST`.
 *
 * @slot - The boolean expression.
 */
declare class QtiBranchRule extends LitElement implements Condition {
    static readonly EXIT_SECTION = "EXIT_SECTION";
    static readonly EXIT_TESTPART = "EXIT_TESTPART";
    static readonly EXIT_TEST = "EXIT_TEST";
    static styles: lit.CSSResult;
    target: string;
    /** `true` when the test should jump to `target`. */
    evaluate(): boolean;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-branch-rule': QtiBranchRule;
    }
}

/**
 * @summary The qti-item-session-control element contains configurations relating to flow of test sessions.
 * @documentation https://www.imsglobal.org/sites/default/files/spec/qti/v3/info/imsqti_asi_v3p0p1_infomodel_v1p0.html#Derived_ItemSessionControl
 */
declare class QtiItemSessionControl extends LitElement {
    maxAttempts: number;
    showFeedback: boolean;
    allowReview: boolean;
    showSolution: boolean;
    allowComment: boolean;
    allowSkipping: boolean;
    validateResponses: boolean;
    connectedCallback(): Promise<void>;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-item-session-control': QtiItemSessionControl;
    }
}

/**
 * @summary The qti-number-presented expression counts the selected items that have been presented to the candidate.
 * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.number-presented
 *
 * Outcome processing only. `section-identifier`, `include-category` and
 * `exclude-category` narrow which item references are counted, the same way as
 * for `qti-number-selected` and `qti-test-variables`.
 *
 * An item is presented once its `completionStatus` has left `not_attempted`:
 * presenting an item starts its first attempt. An item a linear test part
 * passed over (pre-condition, branch rule) or one the candidate has not reached
 * keeps `not_attempted`. That makes this the count to use for a total over the
 * candidate's own route, such as a maximum score of one point per presented item.
 */
declare class QtiNumberPresented extends QtiExpression<number> {
    #private;
    _testContext?: TestContext;
    constructor();
    getResult(): number;
    calculate(): number;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-number-presented': QtiNumberPresented;
    }
}

/**
 * @summary The qti-number-selected expression counts the item refs selected for the test.
 * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.number-selected
 *
 * Outcome processing only. `section-identifier`, `include-category` and
 * `exclude-category` narrow which item references are counted; with none of
 * them it is every item reference in the test.
 *
 * The count comes from the item refs in the document rather than the test
 * context, so it is the same set `qti-test-variables` aggregates over — and it
 * is right before any item has been attempted.
 */
declare class QtiNumberSelected extends QtiExpression<number> {
    #private;
    constructor();
    getResult(): number;
    calculate(): number;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-number-selected': QtiNumberSelected;
    }
}

/**
 * @summary The qti-pre-condition element holds one boolean expression that decides whether its parent is presented.
 * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.pre-condition
 *
 * A child of `qti-test-part`, `qti-assessment-section` or `qti-assessment-item-ref`. When the test
 * is about to present the parent and the expression is false (or NULL), the parent is skipped.
 * Pre-conditions only apply in linear navigation mode; in nonlinear mode they are ignored.
 *
 * Evaluation is pull-based, like every expression: the test calls `evaluate()` when it needs the
 * answer. An expression that cannot be evaluated fails open, so the parent is shown.
 *
 * @slot - The boolean expression.
 */
declare class QtiPreCondition extends LitElement implements Condition {
    static styles: lit.CSSResult;
    /** `true` when the parent may be presented. */
    evaluate(): boolean;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-pre-condition': QtiPreCondition;
    }
}

declare class QtiOutcomeProcessing extends LitElement {
    static styles: lit.CSSResult[];
    render(): lit.TemplateResult<1>;
    process(): void;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-outcome-processing': QtiOutcomeProcessing;
    }
}
declare class QtiOutcomeProcessingProcessor {
    process(rules: QtiRuleBase[]): void;
}

/**
 * Test-level feedback. It renders nothing where it is declared: where and when it appears is up to
 * the host. After outcome processing, `qtiTest.getTestFeedback(access)` returns the ones that apply.
 */
declare class QtiTestFeedback extends QtiModalFeedback {
    static styles: lit.CSSResult;
    /** When the feedback may be shown: at the end of the test (`atEnd`), or while it runs (`during`). */
    access: 'atEnd' | 'during';
    /**
     * Whether this feedback applies for a value of its `outcome-identifier`: with `show-hide="show"`
     * when the value is (or, for a container, holds) its `identifier`; with `hide` when it is not.
     */
    matches(value: string | readonly string[] | null | undefined): boolean;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-test-feedback': QtiTestFeedback;
    }
}

declare class QtiTestPart extends LitElement {
    #private;
    identifier: string;
    get title(): string;
    set title(value: string);
    class: string;
    navigationMode: 'linear' | 'nonlinear';
    submissionMode: 'individual' | 'simultaneous';
    connectedCallback(): Promise<void>;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-test-part': QtiTestPart;
    }
}

declare class QtiTestVariables extends QtiExpression<number> {
    #private;
    _testContext?: TestContext;
    constructor();
    getResult(): number;
    calculate(): number;
}
declare class QtiTestVariablesExpression implements QtiExpressionBase<number> {
    private testContext;
    private itemVariable;
    private includedItems;
    constructor(testContext: TestContext, itemVariable: string, includedItems: {
        item: string;
        weight: number;
    }[]);
    calculate(): number;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-test-variables': QtiTestVariables;
    }
}

interface TestBaseInterface extends LitElement {
    testContext: Readonly<TestContext>;
    sessionContext: Readonly<SessionContext>;
    configContext?: Readonly<ConfigContext>;
    /** Provided by `qti-test`. */
    qtiContext?: Readonly<QtiContext>;
    _testElement: QtiAssessmentTest;
    updateItemVariables(itemRefID: string, variables: readonly ItemVariableValue[], state?: ItemContext['state']): void;
}
/** A value to set on an item; `type` is only needed for a variable the item does not declare. */
type ItemVariableValue = Pick<VariableValue<string | string[] | null>, 'identifier' | 'value'> & Partial<Pick<VariableValue<string | string[] | null>, 'type'>>;

type PostLoadTransformCallback = (transformer: transformItemApi, itemRef: QtiAssessmentItemRef) => transformItemApi | Promise<transformItemApi>;

/**
 * Exactly what this mixin adds. `IQtiTest` composes it (see ../types/iqti-test, which
 * re-exports it), and `TestNavigationClass` below `implements` it, so the interface and the
 * class cannot drift apart.
 *
 * This was `declare class TestNavigationInterface {}` — EMPTY — so the returned
 * `Constructor<TestNavigationInterface> & T` added nothing and every member the mixin
 * contributes was erased from the public type. `QtiTest` looked as though it had no
 * `navigate` or `postLoadTransformCallback`, and consumers had to intersect the class with
 * `IQtiTest` by hand to describe one element.
 *
 * `showLoadingIndicators` and `retryNavigation` used to be listed on the `IQtiTest` side with
 * no implementation anywhere in the repo, so calling `retryNavigation()` would have thrown.
 * They are gone rather than stubbed: there was no behaviour to preserve.
 */
interface ITestNavigationMixin {
    navigate: 'item' | 'section' | null;
    requestTimeout: number;
    postLoadTransformCallback: PostLoadTransformCallback | null;
    postLoadTestTransformCallback: PostLoadTestTransformCallback | null;
    navigateTo(type: 'item' | 'section', id?: string): void;
    getLoadingProgress(): {
        expectedItems: number;
        connectedItems: number;
        expectedStimulus: number;
        loadedStimulus: number;
        isComplete: boolean;
    };
}

/**
 * Everything a host needs to persist to resume a candidate's test session, and nothing else.
 *
 * Read it from `qtiTest.state` or the `qti-state-changed` event, store it wherever you like —
 * a database, `localStorage`, `sessionStorage` — and assign it back to `qtiTest.state` to resume.
 *
 * Deliberately not here:
 * - declaration metadata (`baseType`, `cardinality`, `correctResponse`, `mapping`, …): it comes
 *   from the item XML on every load, and persisting the answer key with the candidate's data is
 *   both bloat and a leak;
 * - `configContext` and `qtiContext`: inputs the host supplies on every load, not session state.
 *   The shuffle `seed` in particular must be passed in again, or the restored order changes;
 * - `view`: a role the host decides, not something the candidate produced;
 * - anything computed — scores per section, `done`, `active` — which is rederived from this.
 */
interface QtiTestState {
    /** Bumped on any incompatible change to this shape. A state with another version is ignored. */
    version: 1;
    test: {
        items: QtiTestStateItem[];
        /** Test-level outcome values. Only outcomes the test declares are restored. */
        outcomes: QtiTestStateValue[];
    };
    session: QtiTestStateSession;
}
interface QtiTestStateItem {
    /** The `qti-assessment-item-ref` identifier. */
    identifier: string;
    variables: (QtiTestStateValue & {
        type?: 'response' | 'outcome' | 'template' | 'context';
    })[];
    /** Opaque per-interaction state keyed by response identifier, e.g. a PCI's `getState()`. */
    state?: Record<string, string | null>;
}
interface QtiTestStateValue {
    identifier: string;
    value: string | string[] | null;
}
/** Where the candidate is. */
interface QtiTestStateSession {
    navPartId?: string | null;
    navSectionId?: string | null;
    navItemRefId?: string | null;
}

declare global {
    interface GlobalEventHandlersEventMap {
        'qti-state-changed': CustomEvent<QtiTestState>;
    }
}
interface ITestStateMixin {
    /**
     * The candidate's persistable state: what they answered and where they are.
     *
     * Assign a stored state to resume. It may be assigned at any time: before the test document
     * has loaded it is held and applied as soon as the test connects — before the first item
     * loads, so items and the initial navigation start from it — and after that it is applied
     * immediately and the test navigates to the restored position.
     *
     * Items are matched by item-ref identifier; items the state does not mention start fresh, and
     * stored items, test outcomes or a position the test no longer has are ignored. Restoring is a
     * resume, so linear-mode navigation restrictions do not apply.
     */
    state: QtiTestState;
}

declare class TestNavigation extends LitElement {
    #private;
    identifier: string | undefined;
    initContext: {
        identifier: string;
        [key: string]: any;
    }[];
    /**
     * @deprecated Set `qtiContext` on `qti-test`, which provides it. This is an alias for the
     * enclosing test's: reading returns it, writing replaces it, so a host that has always set the
     * shuffle seed here keeps working. Removed in the next major.
     *
     * Written before the navigation is inside a test, it waits and is handed over on connect.
     */
    get qtiContext(): QtiContext;
    set qtiContext(value: QtiContext);
    configContext: ConfigContext;
    protected _testContext?: TestContext;
    protected _sessionContext?: SessionContext;
    protected computedContext: ComputedContext;
    autoScoreItems: boolean;
    constructor();
    /**
     * Extension point for presentation packages reacting to an ended attempt.
     * `done` is settled here — from the freshly latched optimality and the
     * session-control cascade — because the computed context only catches up on
     * the next update, after this event has finished bubbling.
     */
    protected afterAttemptEnded(_assessmentItem: QtiAssessmentItem | undefined, _computedItem: ComputedItem | undefined, _done: boolean): void;
    /** The computed-context entry for an item, from the session-control cascade. */
    protected computedItemFor(identifier: string): ComputedItem | undefined;
    /** The currently active assessment item, exposed for optional presentation extensions. */
    protected get activeAssessmentItem(): QtiAssessmentItem | undefined;
    render(): lit.TemplateResult<1>;
    protected willUpdate(_changedProperties: PropertyValues): void;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-navigation': TestNavigation;
    }
}

/**
 * Represents a custom element for navigating to the next test item.
 *
 * @remarks
 * This element provides functionality for navigating to the next test item.
 *
 * @example
 * ```html
 * <test-next></test-next>
 * ```
 */
declare class TestNext extends LitElement {
    #private;
    _internalDisabled: boolean;
    protected computedContext: ComputedContext;
    sectionItems: ComputedItem[];
    itemIndex: number;
    _handleTestElementChange(_oldValue: ComputedContext, newValue: ComputedContext): void;
    static styles: lit.CSSResult;
    constructor();
    connectedCallback(): void;
    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
    checkDisabled(): void;
    protected _requestItem(identifier: string): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-next': TestNext;
    }
}

/**
 * Represents a custom element for navigating to the previous test item.
 *
 * @remarks
 * This element provides functionality for navigating to the previous test item.
 *
 * @example
 * ```html
 * <test-prev></test-prev>
 * ```
 */
declare class TestPrev extends LitElement {
    _internalDisabled: boolean;
    private computedContext;
    sectionItems: ComputedItem[];
    itemIndex: number;
    _handleTestElementChange(_oldValue: ComputedContext, newValue: ComputedContext): void;
    static styles: lit.CSSResult;
    constructor();
    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
    checkDisabled(): void;
    protected _requestItem(identifier: string): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-prev': TestPrev;
    }
}

declare class TestView extends LitElement {
    #private;
    static DEFAULT_VIEW_OPTIONS: string[];
    private sessionContext;
    /** label accompanying the select view dropdown  */
    label: string;
    /** The options to display in the dropdown, default: ['author', 'candidate', 'proctor', 'scorer', 'testConstructor', 'tutor'] */
    viewOptions: string;
    protected _handleViewOptionsChange: () => void;
    connectedCallback(): void;
    private _viewOptions;
    protected _switchView(view: string): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-view': TestView;
    }
}

declare class TestItemLink extends LitElement {
    static styles: lit.CSSResult;
    private itemId;
    constructor();
    protected _requestItem(identifier: string): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-item-link': TestItemLink;
    }
}

declare class TestEndAttempt extends LitElement {
    protected computedContext: ComputedContext;
    _internalDisabled: boolean;
    _handleTestElementChange(_oldValue: ComputedContext, newValue: ComputedContext): void;
    static styles: lit.CSSResult;
    constructor();
    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
    checkDisabled(): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-end-attempt': TestEndAttempt;
    }
}

/**
 * @deprecated test-paging-buttons-stamp is deprecated and will be removed in the future.
 */
declare class TestPagingButtonsStamp extends LitElement {
    #private;
    private computedContext;
    myTemplate: TemplateFunction;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    constructor();
    connectedCallback(): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-paging-buttons-stamp': TestPagingButtonsStamp;
    }
}

/**
 * `<test-container>` is a custom element designed for hosting the qti-assessment-item.
 * The `qti-assessment-test` will be placed inside the shadow DOM of this element.
 * The element loads the test from the provided URL and renders it inside the shadow DOM.
 *
 * ```html
 * <qti-test>
 *   <test-navigation>
 *      <test-container class="m-4 bg-white" test-url="./path/to/assessmenttest.xml"></test-container>
 *   </test-navigation>
 * </qti-test>
 * ```
 */
declare class TestContainer extends LitElement {
    #private;
    /** Scoped registry used by the test shadow root. Must be set before connection. */
    customElementRegistry: CustomElementRegistry | null;
    /** URL of the item to load */
    testURL: string | null;
    /** A parsed HTML document */
    testDoc: DocumentFragment | null;
    /** The raw XML string */
    testXML: string | null;
    /** The `qti-test` this container is in: where the host's `postLoadTestTransformCallback` lives. */
    protected testHost?: TestHost;
    protected qtiContext: QtiContext;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    /** Callback function to transform the test after loading */
    protected handleTestURLChange(): Promise<void>;
    protected handleTestXMLChange(): void;
    connectedCallback(): Promise<void>;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-container': TestContainer;
    }
}

/**
 * A variable value as text: a list as `a, b`, a record (e.g. the response of a PCI) as `time: 3.6, point: 455 250`.
 * Without this a record printed as "[object Object]".
 */
declare const formatVariableValue: (value: unknown) => string;
declare class TestPrintVariables extends LitElement {
    computedContext?: ComputedContext;
    static styles: lit.CSSResult;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-print-item-variables': TestPrintVariables;
    }
}

/**
 * @deprecated test-section-buttons-stamp is deprecated and will be removed in the future.
 */
declare class TestSectionButtonsStamp extends LitElement {
    #private;
    private computedContext;
    myTemplate: TemplateFunction;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    constructor();
    connectedCallback(): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-section-buttons-stamp': TestSectionButtonsStamp;
    }
}

declare class TestSectionLink extends LitElement {
    #private;
    static styles: lit.CSSResult;
    private sectionId;
    constructor();
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-section-link': TestSectionLink;
    }
}

declare class TestPrintContext extends LitElement {
    computedContext?: ComputedContext;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-print-context': TestPrintContext;
    }
}

/**
 * A custom web component that renders a test stamp using the Lit framework.
 * This component is deprecated and will be removed in the future.
 * @customElement
 * @extends {LitElement}
 */
declare class TestStamp extends LitElement {
    /**
     * Indicates whether the component is in debug mode.
     * When set to `true`, the available objects and properties (i.e.: stampContext) is displayed.
     */
    debug: boolean;
    private computedContext;
    private stampContext;
    myTemplate: TemplateFunction;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    connectedCallback(): void;
    protected willUpdate(_changedProperties: PropertyValues): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-stamp': TestStamp;
    }
}

declare class TestScoringButtons extends LitElement {
    #private;
    view: string;
    disabled: boolean;
    myTemplate: TemplateFunction | null;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    connectedCallback(): void;
    protected computedContext?: ComputedContext;
    render(): lit.TemplateResult<1> | typeof nothing;
    constructor();
}
declare global {
    interface HTMLElementTagNameMap {
        'test-scoring-buttons': TestScoringButtons;
    }
}

declare class TestViewToggle extends LitElement {
    myTemplate: any;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    private sessionContext;
    connectedCallback(): void;
    _switchView(view: string): void;
    protected firstUpdated(_changedProperties: PropertyValues): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-view-toggle': TestViewToggle;
    }
}

declare class TestScoringFeedback extends LitElement {
    protected computedContext?: ComputedContext;
    view: View;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-scoring-feedback': TestScoringFeedback;
    }
}

declare class TestCheckItem extends LitElement {
    protected testHost?: TestHost;
    static styles: lit.CSSResult;
    constructor();
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-check-item': TestCheckItem;
    }
}

type SpeechState = 'idle' | 'playing' | 'paused';
interface TtsContext {
    state: SpeechState;
    /** True while every reading element is highlighted and a click on one starts reading there. */
    picking: boolean;
    /** Index of the currently highlighted reading element (0-based). */
    currentElementIndex: number;
    /** Total number of navigable reading elements in the current item. */
    elementCount: number;
    play(): void;
    pause(): void;
    resume(): void;
    stop(): void;
    prevElement(): void;
    nextElement(): void;
    /** Toggle pick mode: highlight all reading elements, then read from the one that is clicked. */
    togglePick(): void;
}

declare const ttsContext: {
    __context__: TtsContext;
};
/**
 * Base class shared by all TTS control elements. Consumes `ttsContext` and
 * mirrors the current speech state onto CSS custom states so each child can
 * be styled with `:state(playing)`, `:state(paused)`, `:state(idle)`.
 */
declare abstract class TtsButtonBase extends LitElement {
    #private;
    static styles: lit.CSSResult;
    /**
     * Accessible name of the button. Without it the default icon carries an English name, and
     * slotted content names the button by its text; set it when you slot an icon of your own,
     * which has no text to be named by.
     */
    label?: string;
    protected _tts?: TtsContext;
    updated(_changed: PropertyValues): void;
}
/**
 * `<test-item-to-speech>` is the controller and context provider. It manages
 * speech synthesis, word highlighting, and item element lookup. Compose your
 * own player by placing control elements as children.
 *
 * @example
 * ```html
 * <test-item-to-speech language="nl-NL">
 *   <test-tts-play></test-tts-play>
 *   <test-tts-prev></test-tts-prev>
 *   <test-tts-next></test-tts-next>
 *   <test-tts-stop></test-tts-stop>
 * </test-item-to-speech>
 * ```
 *
 * The controller lays its controls out as a wrapping row; each control draws an icon button,
 * and slotted content replaces the icon — a slotted `<svg>` is sized like the default one. Give a
 * control with a slotted icon a `label`, since an icon has no text to name the button by. Buttons read the qti-theme tokens (with the theme's
 * defaults as fallbacks) and can be sized with `--test-button-size` and `--test-tts-icon-size`.
 *
 * ### Language resolution
 *
 * Each reading element is spoken in the language of the nearest `lang` attribute:
 *
 * 1. `lang` (or `xml:lang`) on the element itself
 * 2. `lang` on the closest ancestor — including `<qti-assessment-item xml:lang>` and, across
 *    shadow roots, anything wrapping the test
 * 3. `lang` on the document's `<html>` element
 * 4. the `language` attribute on `<test-item-to-speech>`
 *
 * The transformer copies `xml:lang` over as a plain `lang` attribute, so QTI authored with
 * `xml:lang="en-GB"` on a `<p>` or on the item root is honoured without further work.
 *
 * ### What is read
 *
 * Decided once per connect, by where the player is placed. The first rule that matches wins:
 *
 * 1. **Next to a stimulus placeholder** — the player shares its parent with a
 *    `[data-stimulus-idref]` element, e.g. in a reading-text panel beside the questions: the
 *    player reads that stimulus (its `qti-stimulus-body`), and only that. Not inside the
 *    placeholder: loading a stimulus replaces the placeholder's content. Items and navigation
 *    are ignored; when the stimulus is (re)loaded or the placeholder swapped, the player starts
 *    over on the new content.
 * 2. **Next to `[data-tts-content]`** — the player shares its parent with an element marked
 *    `data-tts-content`: any HTML, not QTI, e.g. a start screen rendered by React. The marker goes
 *    on one container; the player reads the readable elements inside it. Navigation is ignored.
 *    The reading list is rebuilt when the player starts from the top, and when an element in it
 *    has left the page — so a re-render of the content never interrupts speech.
 * 3. **Inside a `qti-assessment-item-ref`** — e.g. in a `<template item-ref>` on `<qti-test>`,
 *    so every item gets a player of its own: the player reads that item, and only that item.
 *    The navigation cursor is ignored; speech stops when the player leaves the page with its item.
 * 4. **Anywhere else** — a toolbar in the page chrome: the player follows the navigation cursor
 *    and reads the item `navItemRefId` (session context) points at, found in any
 *    `test-container` reachable from the player. Navigating stops speech and starts the next
 *    item from the top.
 *
 * ```html
 * <!-- 1. a player for the shared reading text -->
 * <aside>
 *   <test-item-to-speech>…</test-item-to-speech>
 *   <div data-stimulus-idref="Stimulus1"></div>
 * </aside>
 *
 * <!-- 2. a player for any other HTML -->
 * <div>
 *   <test-item-to-speech>…</test-item-to-speech>
 *   <section data-tts-content lang="nl-NL">…</section>
 * </div>
 *
 * <!-- 3. one player per item -->
 * <qti-test>
 *   <template item-ref>
 *     <test-item-to-speech>…</test-item-to-speech>
 *     {{ xmlDoc }}
 *   </template>
 *   …
 * </qti-test>
 *
 * <!-- 4. one player in the toolbar, following navigation -->
 * <test-navigation>
 *   <header><test-item-to-speech>…</test-item-to-speech></header>
 *   <test-container test-url="…"></test-container>
 * </test-navigation>
 * ```
 *
 * In modes 3 and 4 the item re-rendering (navigating to the item already shown) restarts the
 * player on the fresh content. An item player reads the item body as rendered: a stimulus
 * placed inside the item is read with it, one placed outside (mode 1) is not. Only one player
 * can speak at a time; starting one stops any other.
 *
 * Read are `p`, `h1`–`h6`, `li`, `dt`, `dd`, `th`, `td`, `caption`, `blockquote`, `figcaption`,
 * `qti-prompt` and `qti-simple-choice` — the innermost match only — unless hidden (`display: none`)
 * or inside `aria-hidden="true"`.
 *
 * ### Starting somewhere in the middle
 *
 * `<test-tts-pick>` switches the player into pick mode: every reading element gets the blue
 * cursor highlight, and the first click on one of them leaves pick mode and starts reading
 * from that element. Pressing the button again leaves pick mode without reading.
 *
 * @cssstate idle    - No speech active
 * @cssstate picking - Pick mode: all reading elements highlighted, waiting for a click
 * @cssstate playing - Speech is playing
 * @cssstate paused  - Speech is paused
 */
declare class TestItemToSpeech extends LitElement {
    #private;
    static styles: lit.CSSResult;
    /** Fallback language when neither the item content nor the document declares one. */
    language: string;
    protected _sessionContext?: SessionContext;
    /** The `qti-test` this player is in, across shadow roots. */
    protected testHost?: TestHost;
    _ttsContext: TtsContext;
    constructor();
    willUpdate(changed: PropertyValues): void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    render(): lit.TemplateResult<1>;
}
/**
 * Play/pause/resume toggle button — always enabled, cycles through states.
 * Use named slots `play` and `pause` to customise the icons/labels independently; `label` and
 * `pause-label` name the button in each state (set them when the slotted content is an icon).
 *
 * @example
 * ```html
 * <test-tts-play>
 *   <span slot="play">Voorlezen</span>
 *   <span slot="pause">Pauzeren</span>
 * </test-tts-play>
 * ```
 *
 * @cssstate idle / playing / paused
 * @csspart button
 */
declare class TestTtsPlay extends TtsButtonBase {
    #private;
    /** Accessible name of the button while speech is playing; see `label`. */
    pauseLabel?: string;
    render(): lit.TemplateResult<1>;
}
/**
 * Pause button — enabled only when playing.
 * @cssstate idle / playing / paused
 * @csspart button
 */
declare class TestTtsPause extends TtsButtonBase {
    render(): lit.TemplateResult<1>;
}
/**
 * Resume button — enabled only when paused.
 * @cssstate idle / playing / paused
 * @csspart button
 */
declare class TestTtsResume extends TtsButtonBase {
    render(): lit.TemplateResult<1>;
}
/**
 * Stop button — enabled when playing, paused, or in pick mode (where it leaves pick mode).
 * @cssstate idle / playing / paused
 * @csspart button
 */
declare class TestTtsStop extends TtsButtonBase {
    render(): lit.TemplateResult<1>;
}
/**
 * Prev-element button — moves cursor to the previous reading element and pauses.
 * Disabled at the first element. Reading elements are collected lazily, so an element count
 * of 0 means "not looked yet" rather than "nothing to read": the button stays enabled and the
 * first click collects them.
 * @cssstate idle / playing / paused
 * @csspart button
 */
declare class TestTtsPrev extends TtsButtonBase {
    render(): lit.TemplateResult<1>;
}
/**
 * Next-element button — moves cursor to the next reading element and pauses.
 * Disabled at the last element; enabled while the elements have not been collected yet
 * (see `TestTtsPrev`).
 * @cssstate idle / playing / paused
 * @csspart button
 */
declare class TestTtsNext extends TtsButtonBase {
    render(): lit.TemplateResult<1>;
}
/**
 * Pick button — toggles pick mode on the controller: every reading element is highlighted and
 * a click on one of them starts reading from there. Reflects the mode as `:state(picking)`.
 * @cssstate idle / playing / paused
 * @cssstate picking
 * @csspart button
 */
declare class TestTtsPick extends TtsButtonBase {
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'test-item-to-speech': TestItemToSpeech;
        'test-tts-play': TestTtsPlay;
        'test-tts-pause': TestTtsPause;
        'test-tts-resume': TestTtsResume;
        'test-tts-stop': TestTtsStop;
        'test-tts-prev': TestTtsPrev;
        'test-tts-next': TestTtsNext;
        'test-tts-pick': TestTtsPick;
    }
}

declare const QtiTest_base: (abstract new (...args: any[]) => ITestNavigationMixin) & (abstract new (...args: any[]) => {
    updateAssessmentItemView(assessmentItem: QtiAssessmentItem, view: View): void;
}) & (abstract new (...args: any[]) => {
    updateOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
    getOutcome(identifier: string): Readonly<OutcomeVariable>;
    getVariable(identifier: string): Readonly<VariableDeclaration<string | string[] | null>>;
    outcomeProcessing(): boolean;
    getTestFeedback(access?: "atEnd" | "during"): QtiTestFeedback[];
}) & (abstract new (...args: any[]) => ITestStateMixin) & (abstract new (...args: any[]) => TestBaseInterface) & typeof LitElement;
/**
 * `<qti-test>` is a custom element designed for rendering and interacting with QTI (Question and Test Interoperability) tests.
 *
 * This component leverages several mixins to provide functionality for loading, navigating, processing, and displaying QTI test assessments.
 *
 * ### Example Usage
 *
 * Minimal example including navigation:
 *
 * ```html
 * <qti-test>
 *  <test-navigation>
 *    <test-container test-url="./path/to/assessment.xml"></test-container>
 *    <nav class="flex">
 *      <test-prev></test-prev>
 *      <test-next></test-next>
 *    </nav>
 *  </test-navigation>
 * </qti-test>
 * ```
 *
 * Use the following file structure
 * A qti-test loads a QTI3.0 assessmenttest.xml file from a package folder.
 *
 * ```plaintext
 * Root/
 * ├── index.html
 * └── /assets/api/examples/
 *     ├── assessmenttest.xml
 *     └── imsmanifest.xml
 *
 * ```
 *
 * ### Test components
 *
 * Use test components inside the qti-test component for added functionality.
 * ### Test next
 * `<test-next> | TestNext`
 *
 * ### Test prev
 *
 * `<test-prev> | TestPrev`
 * ### Test components
 *
 * You can use normal class names to style the elements.
 * And you can use the `test-prev` and `test-next` elements to navigate through the test.
 *
 * @event qti-state-changed - The candidate's persistable state changed. `detail` is a `QtiTestState`; assign it back to `state` to resume.
 * @event qti-test-context-updated - Deprecated: listen to `qti-state-changed` to persist a session. `detail` is the full test context, including declaration metadata and the answer key. Removed in the next major.
 */
declare class QtiTest extends QtiTest_base {
    constructor();
    configContext: ConfigContext;
    /**
     * Who is taking which test, and the optional shuffle `seed`. Provided here, at the test, so
     * everything inside reads one value: the test-container shuffling the item order, the test
     * shuffling interactions as it navigates, and the expressions that read `QTI_CONTEXT`.
     *
     * Pass the same `seed` when resuming a session, or the order comes back different. Replace the
     * object, do not mutate it: an in-place change does not notify the components inside.
     *
     * `test-navigation.qtiContext` is an alias of this.
     */
    qtiContext: QtiContext;
    /**
     * Renders the component's template.
     * Provides a default `<slot>` for content projection.
     */
    connectedCallback(): Promise<void>;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'qti-test': QtiTest;
    }
}

export { TestScoringButtons as A, TestScoringFeedback as B, TestSectionButtonsStamp as C, TestSectionLink as D, TestStamp as E, TestTtsNext as F, TestTtsPause as G, TestTtsPick as H, type ITestNavigationMixin as I, TestTtsPlay as J, TestTtsPrev as K, TestTtsResume as L, TestTtsStop as M, TestView as N, TestViewToggle as O, type TtsContext as P, QtiAssessmentItemRef as Q, formatVariableValue as R, type SpeechState as S, TestCheckItem as T, ttsContext as U, type ItemVariableValue as V, type ITestStateMixin as a, type ItemRefTemplateModel as b, QtiAssessmentSection as c, QtiAssessmentTest as d, QtiBranchRule as e, QtiItemSessionControl as f, QtiNumberPresented as g, QtiNumberSelected as h, QtiOutcomeProcessing as i, QtiOutcomeProcessingProcessor as j, QtiPreCondition as k, QtiTest as l, QtiTestFeedback as m, QtiTestPart as n, QtiTestVariables as o, QtiTestVariablesExpression as p, TestContainer as q, TestEndAttempt as r, TestItemLink as s, TestItemToSpeech as t, TestNavigation as u, TestNext as v, TestPagingButtonsStamp as w, TestPrev as x, TestPrintContext as y, TestPrintVariables as z };