import { z } from 'zod';

type DisplayChoice = {
    id: string;
    contentHtml: string;
    inlineFeedbackHtml?: string;
};
type DisplayChoiceInteraction = {
    type: "choice";
    responseId: string;
    cardinality: "single" | "multiple";
    promptHtml: string;
    choices: DisplayChoice[];
    minChoices: number;
    maxChoices: number;
};
type DisplayTextInteraction = {
    type: "text";
    responseId: string;
    expectedLength?: number;
    placeholder?: string;
    patternMask?: string;
};
type DisplayTextEmbed = {
    responseId: string;
    expectedLength?: number;
    placeholder?: string;
    patternMask?: string;
};
type DisplayOrderInteraction = {
    type: "order";
    responseId: string;
    promptHtml: string;
    choices: DisplayChoice[];
    orientation: "vertical" | "horizontal";
};
type DisplayGapText = {
    id: string;
    contentHtml: string;
    matchMax: number;
};
type DisplayGap = {
    id: string;
};
type DisplayGapMatchInteraction = {
    type: "gapMatch";
    responseId: string;
    gapTexts: DisplayGapText[];
    gaps: DisplayGap[];
    contentHtml: string;
};
type DisplayAssociableChoice = {
    id: string;
    contentHtml: string;
    matchMax: number;
};
type DisplayMatchInteraction = {
    type: "match";
    responseId: string;
    promptHtml: string;
    maxAssociations: number;
    sourceChoices: DisplayAssociableChoice[];
    targetChoices: DisplayAssociableChoice[];
};
type DisplayInteraction = DisplayChoiceInteraction | DisplayTextInteraction | DisplayOrderInteraction | DisplayGapMatchInteraction | DisplayMatchInteraction;
type DisplayInlineEmbed = {
    responseId: string;
    shuffle: boolean;
    choices: Array<Pick<DisplayChoice, "id" | "contentHtml">>;
};
type DisplayBlock = {
    type: "stimulus";
    html: string;
} | {
    type: "richStimulus";
    html: string;
    inlineEmbeds: Record<string, DisplayInlineEmbed>;
    textEmbeds: Record<string, DisplayTextEmbed>;
} | {
    type: "interaction";
    interaction: DisplayInteraction;
};
type DisplayItem = {
    title: string;
    contentBlocks: DisplayBlock[];
};
type FormShape = Record<string, "single" | "multiple" | "ordered" | "directedPair">;
type ValidateResult = {
    overallCorrect: boolean;
    perResponse: Record<string, {
        isCorrect: boolean;
        messageHtml?: string;
    }>;
    selectedChoicesByResponse: Record<string, Array<{
        id: string;
        isCorrect: boolean;
    }>>;
    overallFeedback?: {
        isCorrect: boolean;
        messageHtml?: string;
    };
};

declare const ChoiceInteractionSchema: z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    minChoices: z.ZodNumber;
    maxChoices: z.ZodNumber;
    promptHtml: z.ZodString;
    choices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
        inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"choiceInteraction">;
}, z.core.$strip>;
type ChoiceInteraction = z.infer<typeof ChoiceInteractionSchema>;
declare const InlineChoiceInteractionSchema: z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    choices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"inlineChoiceInteraction">;
}, z.core.$strip>;
type InlineChoiceInteraction = z.infer<typeof InlineChoiceInteractionSchema>;
declare const TextEntryInteractionSchema: z.ZodObject<{
    responseIdentifier: z.ZodString;
    expectedLength: z.ZodOptional<z.ZodNumber>;
    placeholderText: z.ZodOptional<z.ZodString>;
    patternMask: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"textEntryInteraction">;
}, z.core.$strip>;
type TextEntryInteraction = z.infer<typeof TextEntryInteractionSchema>;
declare const OrderInteractionSchema: z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    minChoices: z.ZodNumber;
    maxChoices: z.ZodOptional<z.ZodNumber>;
    orientation: z.ZodEnum<{
        vertical: "vertical";
        horizontal: "horizontal";
    }>;
    promptHtml: z.ZodString;
    choices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
        inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"orderInteraction">;
}, z.core.$strip>;
type OrderInteraction = z.infer<typeof OrderInteractionSchema>;
declare const GapMatchInteractionSchema: z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    gapTexts: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
        matchMax: z.ZodNumber;
    }, z.core.$strip>>;
    gaps: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
    }, z.core.$strip>>;
    contentHtml: z.ZodString;
    type: z.ZodLiteral<"gapMatchInteraction">;
}, z.core.$strip>;
type GapMatchInteraction = z.infer<typeof GapMatchInteractionSchema>;
declare const MatchInteractionSchema: z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    maxAssociations: z.ZodNumber;
    sourceChoices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        matchMax: z.ZodNumber;
        contentHtml: z.ZodString;
    }, z.core.$strip>>;
    targetChoices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        matchMax: z.ZodNumber;
        contentHtml: z.ZodString;
    }, z.core.$strip>>;
    promptHtml: z.ZodString;
    type: z.ZodLiteral<"matchInteraction">;
}, z.core.$strip>;
type MatchInteraction = z.infer<typeof MatchInteractionSchema>;
declare const AnyInteractionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    minChoices: z.ZodNumber;
    maxChoices: z.ZodNumber;
    promptHtml: z.ZodString;
    choices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
        inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"choiceInteraction">;
}, z.core.$strip>, z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    choices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"inlineChoiceInteraction">;
}, z.core.$strip>, z.ZodObject<{
    responseIdentifier: z.ZodString;
    expectedLength: z.ZodOptional<z.ZodNumber>;
    placeholderText: z.ZodOptional<z.ZodString>;
    patternMask: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"textEntryInteraction">;
}, z.core.$strip>, z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    minChoices: z.ZodNumber;
    maxChoices: z.ZodOptional<z.ZodNumber>;
    orientation: z.ZodEnum<{
        vertical: "vertical";
        horizontal: "horizontal";
    }>;
    promptHtml: z.ZodString;
    choices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
        inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    type: z.ZodLiteral<"orderInteraction">;
}, z.core.$strip>, z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    gapTexts: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        contentHtml: z.ZodString;
        matchMax: z.ZodNumber;
    }, z.core.$strip>>;
    gaps: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
    }, z.core.$strip>>;
    contentHtml: z.ZodString;
    type: z.ZodLiteral<"gapMatchInteraction">;
}, z.core.$strip>, z.ZodObject<{
    responseIdentifier: z.ZodString;
    shuffle: z.ZodBoolean;
    maxAssociations: z.ZodNumber;
    sourceChoices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        matchMax: z.ZodNumber;
        contentHtml: z.ZodString;
    }, z.core.$strip>>;
    targetChoices: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        matchMax: z.ZodNumber;
        contentHtml: z.ZodString;
    }, z.core.$strip>>;
    promptHtml: z.ZodString;
    type: z.ZodLiteral<"matchInteraction">;
}, z.core.$strip>], "type">;
type AnyInteraction = z.infer<typeof AnyInteractionSchema>;
declare const ResponseDeclarationSchema: z.ZodObject<{
    identifier: z.ZodString;
    cardinality: z.ZodEnum<{
        single: "single";
        multiple: "multiple";
        ordered: "ordered";
    }>;
    baseType: z.ZodEnum<{
        string: "string";
        boolean: "boolean";
        identifier: "identifier";
        float: "float";
        integer: "integer";
        directedPair: "directedPair";
        pair: "pair";
    }>;
    correctResponse: z.ZodObject<{
        values: z.ZodArray<z.ZodString>;
    }, z.core.$strip>;
    mapping: z.ZodOptional<z.ZodObject<{
        defaultValue: z.ZodDefault<z.ZodNumber>;
        lowerBound: z.ZodOptional<z.ZodNumber>;
        upperBound: z.ZodOptional<z.ZodNumber>;
        entries: z.ZodArray<z.ZodObject<{
            key: z.ZodString;
            value: z.ZodNumber;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ResponseDeclaration = z.infer<typeof ResponseDeclarationSchema>;
declare const FeedbackBlockSchema: z.ZodObject<{
    outcomeIdentifier: z.ZodString;
    identifier: z.ZodString;
    showHide: z.ZodDefault<z.ZodEnum<{
        show: "show";
        hide: "hide";
    }>>;
    contentHtml: z.ZodString;
}, z.core.$strip>;
type FeedbackBlock = z.infer<typeof FeedbackBlockSchema>;
declare const BaseRuleSchema: z.ZodObject<{
    type: z.ZodLiteral<"setOutcomeValue">;
    identifier: z.ZodString;
    value: z.ZodString;
}, z.core.$strip>;
type BaseRule = z.infer<typeof BaseRuleSchema>;
declare const MatchConditionSchema: z.ZodObject<{
    type: z.ZodLiteral<"match">;
    variable: z.ZodString;
    correct: z.ZodLiteral<true>;
}, z.core.$strip>;
type MatchCondition = z.infer<typeof MatchConditionSchema>;
declare const MatchValueConditionSchema: z.ZodObject<{
    type: z.ZodLiteral<"matchValue">;
    variable: z.ZodString;
    value: z.ZodString;
}, z.core.$strip>;
type MatchValueCondition = z.infer<typeof MatchValueConditionSchema>;
declare const StringMatchConditionSchema: z.ZodObject<{
    type: z.ZodLiteral<"stringMatch">;
    variable: z.ZodString;
    value: z.ZodString;
    caseSensitive: z.ZodBoolean;
}, z.core.$strip>;
type StringMatchCondition = z.infer<typeof StringMatchConditionSchema>;
declare const MemberConditionSchema: z.ZodObject<{
    type: z.ZodLiteral<"member">;
    variable: z.ZodString;
    value: z.ZodString;
}, z.core.$strip>;
type MemberCondition = z.infer<typeof MemberConditionSchema>;
declare const EqualMapResponseConditionSchema: z.ZodObject<{
    type: z.ZodLiteral<"equalMapResponse">;
    variable: z.ZodString;
    value: z.ZodString;
}, z.core.$strip>;
type EqualMapResponseCondition = z.infer<typeof EqualMapResponseConditionSchema>;
declare const NumericEqualConditionSchema: z.ZodObject<{
    type: z.ZodLiteral<"numericEqual">;
    variable: z.ZodString;
    value: z.ZodString;
    baseType: z.ZodEnum<{
        float: "float";
        integer: "integer";
    }>;
    rounding: z.ZodOptional<z.ZodObject<{
        mode: z.ZodEnum<{
            significantFigures: "significantFigures";
            decimalPlaces: "decimalPlaces";
        }>;
        figures: z.ZodNumber;
    }, z.core.$strip>>;
}, z.core.$strip>;
type NumericEqualCondition = z.infer<typeof NumericEqualConditionSchema>;
type AndCondition = {
    type: "and";
    conditions: AnyCondition[];
};
type OrCondition = {
    type: "or";
    conditions: AnyCondition[];
};
type NotCondition = {
    type: "not";
    condition: AnyCondition;
};
type AnyCondition = MatchCondition | MatchValueCondition | StringMatchCondition | MemberCondition | AndCondition | OrCondition | NotCondition | EqualMapResponseCondition | NumericEqualCondition;
type ConditionBranch = {
    condition?: AnyCondition;
    actions: BaseRule[];
    nestedRules?: ResponseRule[];
};
type ResponseRule = {
    type: "condition";
    branches: ConditionBranch[];
} | {
    type: "action";
    action: BaseRule;
};
declare const ResponseProcessingSchema: z.ZodObject<{
    rules: z.ZodArray<z.ZodType<ResponseRule, unknown, z.core.$ZodTypeInternals<ResponseRule, unknown>>>;
    scoring: z.ZodObject<{
        responseIdentifier: z.ZodString;
        correctScore: z.ZodNumber;
        incorrectScore: z.ZodNumber;
    }, z.core.$strip>;
}, z.core.$strip>;
type ResponseProcessing = z.infer<typeof ResponseProcessingSchema>;
declare const AssessmentItemSchema: z.ZodObject<{
    identifier: z.ZodString;
    title: z.ZodString;
    timeDependent: z.ZodBoolean;
    xmlLang: z.ZodString;
    responseDeclarations: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        cardinality: z.ZodEnum<{
            single: "single";
            multiple: "multiple";
            ordered: "ordered";
        }>;
        baseType: z.ZodEnum<{
            string: "string";
            boolean: "boolean";
            identifier: "identifier";
            float: "float";
            integer: "integer";
            directedPair: "directedPair";
            pair: "pair";
        }>;
        correctResponse: z.ZodObject<{
            values: z.ZodArray<z.ZodString>;
        }, z.core.$strip>;
        mapping: z.ZodOptional<z.ZodObject<{
            defaultValue: z.ZodDefault<z.ZodNumber>;
            lowerBound: z.ZodOptional<z.ZodNumber>;
            upperBound: z.ZodOptional<z.ZodNumber>;
            entries: z.ZodArray<z.ZodObject<{
                key: z.ZodString;
                value: z.ZodNumber;
            }, z.core.$strip>>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    outcomeDeclarations: z.ZodArray<z.ZodObject<{
        identifier: z.ZodString;
        cardinality: z.ZodEnum<{
            single: "single";
            multiple: "multiple";
            ordered: "ordered";
        }>;
        baseType: z.ZodEnum<{
            string: "string";
            boolean: "boolean";
            identifier: "identifier";
            float: "float";
            integer: "integer";
            directedPair: "directedPair";
            pair: "pair";
        }>;
        defaultValue: z.ZodOptional<z.ZodObject<{
            value: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    itemBody: z.ZodObject<{
        contentBlocks: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            type: z.ZodLiteral<"stimulus">;
            html: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"richStimulus">;
            html: z.ZodString;
            inlineEmbeds: z.ZodRecord<z.ZodString, z.ZodObject<{
                responseIdentifier: z.ZodString;
                shuffle: z.ZodBoolean;
                choices: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                    contentHtml: z.ZodString;
                }, z.core.$strip>>;
                type: z.ZodLiteral<"inlineChoiceInteraction">;
            }, z.core.$strip>>;
            textEmbeds: z.ZodRecord<z.ZodString, z.ZodObject<{
                responseIdentifier: z.ZodString;
                expectedLength: z.ZodOptional<z.ZodNumber>;
                placeholderText: z.ZodOptional<z.ZodString>;
                patternMask: z.ZodOptional<z.ZodString>;
                type: z.ZodLiteral<"textEntryInteraction">;
            }, z.core.$strip>>;
        }, z.core.$strip>, z.ZodObject<{
            type: z.ZodLiteral<"interaction">;
            interaction: z.ZodDiscriminatedUnion<[z.ZodObject<{
                responseIdentifier: z.ZodString;
                shuffle: z.ZodBoolean;
                minChoices: z.ZodNumber;
                maxChoices: z.ZodNumber;
                promptHtml: z.ZodString;
                choices: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                    contentHtml: z.ZodString;
                    inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                type: z.ZodLiteral<"choiceInteraction">;
            }, z.core.$strip>, z.ZodObject<{
                responseIdentifier: z.ZodString;
                shuffle: z.ZodBoolean;
                choices: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                    contentHtml: z.ZodString;
                }, z.core.$strip>>;
                type: z.ZodLiteral<"inlineChoiceInteraction">;
            }, z.core.$strip>, z.ZodObject<{
                responseIdentifier: z.ZodString;
                expectedLength: z.ZodOptional<z.ZodNumber>;
                placeholderText: z.ZodOptional<z.ZodString>;
                patternMask: z.ZodOptional<z.ZodString>;
                type: z.ZodLiteral<"textEntryInteraction">;
            }, z.core.$strip>, z.ZodObject<{
                responseIdentifier: z.ZodString;
                shuffle: z.ZodBoolean;
                minChoices: z.ZodNumber;
                maxChoices: z.ZodOptional<z.ZodNumber>;
                orientation: z.ZodEnum<{
                    vertical: "vertical";
                    horizontal: "horizontal";
                }>;
                promptHtml: z.ZodString;
                choices: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                    contentHtml: z.ZodString;
                    inlineFeedbackHtml: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                type: z.ZodLiteral<"orderInteraction">;
            }, z.core.$strip>, z.ZodObject<{
                responseIdentifier: z.ZodString;
                shuffle: z.ZodBoolean;
                gapTexts: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                    contentHtml: z.ZodString;
                    matchMax: z.ZodNumber;
                }, z.core.$strip>>;
                gaps: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                }, z.core.$strip>>;
                contentHtml: z.ZodString;
                type: z.ZodLiteral<"gapMatchInteraction">;
            }, z.core.$strip>, z.ZodObject<{
                responseIdentifier: z.ZodString;
                shuffle: z.ZodBoolean;
                maxAssociations: z.ZodNumber;
                sourceChoices: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                    matchMax: z.ZodNumber;
                    contentHtml: z.ZodString;
                }, z.core.$strip>>;
                targetChoices: z.ZodArray<z.ZodObject<{
                    identifier: z.ZodString;
                    matchMax: z.ZodNumber;
                    contentHtml: z.ZodString;
                }, z.core.$strip>>;
                promptHtml: z.ZodString;
                type: z.ZodLiteral<"matchInteraction">;
            }, z.core.$strip>], "type">;
        }, z.core.$strip>]>>;
        feedbackBlocks: z.ZodArray<z.ZodObject<{
            outcomeIdentifier: z.ZodString;
            identifier: z.ZodString;
            showHide: z.ZodDefault<z.ZodEnum<{
                show: "show";
                hide: "hide";
            }>>;
            contentHtml: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>;
    responseProcessing: z.ZodObject<{
        rules: z.ZodArray<z.ZodType<ResponseRule, unknown, z.core.$ZodTypeInternals<ResponseRule, unknown>>>;
        scoring: z.ZodObject<{
            responseIdentifier: z.ZodString;
            correctScore: z.ZodNumber;
            incorrectScore: z.ZodNumber;
        }, z.core.$strip>;
    }, z.core.$strip>;
}, z.core.$strip>;
type AssessmentItem = z.infer<typeof AssessmentItemSchema>;
/**
 * Represents a QTI 3.0 Assessment Stimulus.
 * Stimuli are standalone reading materials that can be referenced by assessment items.
 */
declare const AssessmentStimulusSchema: z.ZodObject<{
    identifier: z.ZodString;
    title: z.ZodDefault<z.ZodString>;
    xmlLang: z.ZodDefault<z.ZodString>;
    bodyHtml: z.ZodString;
}, z.core.$strip>;
type AssessmentStimulus = z.infer<typeof AssessmentStimulusSchema>;

export { type AssessmentItem as A, type ChoiceInteraction as C, type DisplayAssociableChoice as D, type FeedbackBlock as F, type GapMatchInteraction as G, type InlineChoiceInteraction as I, type MatchInteraction as M, type OrderInteraction as O, type ResponseDeclaration as R, type TextEntryInteraction as T, type ValidateResult as V, type AssessmentStimulus as a, type AnyCondition as b, type AnyInteraction as c, type ResponseProcessing as d, type DisplayBlock as e, type DisplayChoice as f, type DisplayChoiceInteraction as g, type DisplayGap as h, type DisplayGapText as i, type DisplayInlineEmbed as j, type DisplayItem as k, type DisplayTextEmbed as l, type FormShape as m, AssessmentItemSchema as n, AssessmentStimulusSchema as o };