@media-quest/builder 0.0.26 → 0.0.28

package/dist/public-api.d.ts

@@ -0,0 +1,820 @@
+import { Condition, PageQueRules, SchemaDto } from '@media-quest/engine';
+
+/**
+ * Builder objects are complex objects that are embedded inside
+ * a Builder-schema, and needs to be serialized to json. Often these objects
+ * are used in collections, and that is why most of them need an id.
+ */
+type BuilderObjectType = "builder-page" | "builder-question-option" | "builder-question" | "builder-main-text" | "builder-text" | "builder-rule" | "builder-tag" | "builder-sum-score-variable" | "builder-sum-score-membership" | "builder-condition" | "builder-variable" | "builder-condition-group";
+declare abstract class BuilderObject<T extends BuilderObjectType, Dto extends {}> {
+    abstract readonly objectType: T;
+    abstract toJson(): Dto;
+    abstract clone(): Dto;
+    protected readonly originalDto: Dto;
+    protected constructor(dto: Dto);
+}
+
+interface AudioFile {
+    readonly kind: "audio-file";
+    readonly id: string;
+    readonly downloadUrl: string;
+    readonly duration: number;
+    readonly originalFileName: string;
+    readonly name: string;
+    readonly size: number;
+}
+interface VideoFile {
+    readonly kind: "video-file";
+    readonly id: string;
+    readonly downloadUrl: string;
+    readonly duration: number;
+    readonly name: string;
+    readonly size: number;
+    readonly type: string;
+    readonly originalFileName: string;
+}
+interface ImageFile {
+    readonly kind: "image-file";
+    readonly id: string;
+    readonly downloadUrl: string;
+    readonly name: string;
+    readonly size: number;
+    readonly type: string;
+}
+
+type ID<B extends string> = string & {
+    __ID__: B;
+};
+interface Id<T extends string> {
+    name: T;
+    is: (id: string) => id is ID<T>;
+    validateOrCreate: (id: string) => ID<T>;
+    validateOrThrow: (id: string) => ID<T>;
+    create: () => ID<T>;
+    dummy: {
+        a: ID<T>;
+        b: ID<T>;
+        c: ID<T>;
+        d: ID<T>;
+        e: ID<T>;
+        f: ID<T>;
+        g: ID<T>;
+        h: ID<T>;
+        i: ID<T>;
+        j: ID<T>;
+    };
+}
+/**
+ * Creates a object with helper functions for a specific ID type
+ * @param idName
+ */
+declare const createTypedIdSingleton: <const B extends string>(idName: B) => Id<B>;
+type SchemaID = ID<"SCHEMA">;
+declare const SchemaID: Id<"SCHEMA">;
+type PageID = ID<"PAGE">;
+declare const PageID: Id<"PAGE">;
+type TagID = ID<"TAG">;
+declare const TagID: Id<"TAG">;
+type OptionID = ID<"OPTION">;
+declare const OptionID: Id<"OPTION">;
+type TextID = ID<"TEXT">;
+declare const TextID: Id<"TEXT">;
+type QuestionID = ID<"QUESTION">;
+declare const QuestionID: Id<"QUESTION">;
+type SumScoreVariableID = ID<"SUM_SCORE_VARIABLE">;
+declare const SumScoreVariableID: Id<"SUM_SCORE_VARIABLE">;
+
+interface BuilderOptionDto {
+    readonly id: OptionID;
+    readonly value: number;
+    readonly label: string;
+    readonly labelAudio?: AudioFile;
+}
+declare class BuilderOption extends BuilderObject<"builder-question-option", BuilderOptionDto> {
+    readonly objectType = "builder-question-option";
+    id: OptionID;
+    value: number;
+    label: string;
+    private _labelAudioFile;
+    get labelAudioFile(): AudioFile | false;
+    set labelAudioFile(audioFile: AudioFile | false);
+    private constructor();
+    static create(value: number, label: string): BuilderOption;
+    static fromJson(dto: BuilderOptionDto): BuilderOption;
+    toJson(): BuilderOptionDto;
+    clone(): BuilderOptionDto;
+}
+
+type BuilderQuestionType = "select-one" | "select-many" | "text" | "time" | "textarea" | "date" | "numeric-range" | "duration";
+interface BuilderQuestionDto {
+    readonly id: QuestionID;
+    _type: BuilderQuestionType;
+    text: string;
+    options: ReadonlyArray<BuilderOptionDto>;
+    prefix: string;
+}
+declare class BuilderQuestion extends BuilderObject<"builder-question", BuilderQuestionDto> {
+    readonly objectType = "builder-question";
+    id: QuestionID;
+    type: BuilderQuestionType;
+    questionText: string;
+    options: BuilderOption[];
+    prefix: string;
+    static create: (type: BuilderQuestionType) => BuilderQuestion;
+    static fromJson(dto: BuilderQuestionDto): BuilderQuestion;
+    private constructor();
+    addOption(label: string, value: number, atIndex?: number): BuilderOption;
+    deleteOption(option: BuilderOption): boolean;
+    toJson(): BuilderQuestionDto;
+    clone(): BuilderQuestionDto;
+}
+
+interface BuilderMainVideoDto {
+    readonly kind: "main-video";
+    readonly file: VideoFile;
+    mode: "autoplay" | "required" | "optional" | "gif-mode";
+    preDelay: number;
+    volume: number;
+    controls: boolean;
+}
+
+interface BuilderMainImageDto {
+    readonly kind: "main-image";
+    readonly file: ImageFile;
+    readonly overlay: {
+        text: string;
+        fontsize: number;
+        xPos: number;
+        yPos: number;
+    } | false;
+}
+
+interface BuilderMainTextDto {
+    text: string;
+    audioFile: AudioFile | false;
+    autoplay: boolean;
+    autoplayDelay: number;
+}
+declare class BuilderMainText extends BuilderObject<"builder-main-text", BuilderMainTextDto> {
+    readonly objectType: "builder-main-text";
+    autoplay: boolean;
+    private _audioFile;
+    autoplayDelay: number;
+    text: string;
+    private constructor();
+    get autoplayDelayInSeconds(): string;
+    get durationTag(): string;
+    static fromJson(dto: BuilderMainTextDto): BuilderMainText;
+    static create: () => BuilderMainText;
+    clone(): BuilderMainTextDto;
+    toJson(): BuilderMainTextDto;
+    get audioFile(): AudioFile | false;
+    set audioFile(audioFile: AudioFile | false);
+}
+
+declare const BuilderOperatorSymbols: {
+    readonly equal: true;
+    readonly notEqual: true;
+    readonly lessThan: true;
+    readonly lessThanOrEqual: true;
+    readonly greaterThan: true;
+    readonly greaterThanOrEqual: true;
+    readonly between: true;
+    readonly notBetween: true;
+    readonly in: true;
+    readonly notIn: true;
+    readonly missing: true;
+    readonly notMissing: true;
+    readonly contains: true;
+    readonly notContains: true;
+    readonly empty: true;
+    readonly notEmpty: true;
+    readonly startsWith: true;
+    readonly endsWith: true;
+};
+type BuilderOperator = keyof typeof BuilderOperatorSymbols;
+declare namespace BuilderOperator {
+    const is: (symbol?: string) => symbol is "equal" | "notEqual" | "lessThan" | "lessThanOrEqual" | "greaterThan" | "greaterThanOrEqual" | "between" | "notBetween" | "in" | "notIn" | "missing" | "notMissing" | "contains" | "notContains" | "empty" | "notEmpty" | "startsWith" | "endsWith";
+}
+
+type PagePrefixValue = string & {
+    __PAGE_PREFIX__: true;
+};
+declare class PagePrefix {
+    private _value;
+    static readonly MIN_LENGTH = 1;
+    private static randomLen;
+    static readonly MAX_LENGTH = 16;
+    static create: () => PagePrefix;
+    static fromString: (value: string) => PagePrefix | false;
+    static fromStringOrThrow: (value: string) => PagePrefixValue;
+    static castOrCreateRandom: (value: string) => PagePrefix;
+    static isValid: (prefix: string | 999) => prefix is PagePrefixValue;
+    get value(): PagePrefixValue;
+    set value(value: string);
+    private constructor();
+}
+
+type SchemaPrefixValue = string & {
+    __SCHEMA_PREFIX__: true;
+};
+declare class SchemaPrefix {
+    private _value;
+    static readonly MIN_LENGTH = 1;
+    private static randomLen;
+    static readonly MAX_LENGTH = 16;
+    static fromValue: (value: SchemaPrefixValue) => SchemaPrefix;
+    static fromValueOrThrow: (value: string) => SchemaPrefix;
+    static fromString: (value: string) => SchemaPrefix | false;
+    static castOrCreateRandom: (value: string) => SchemaPrefix;
+    static isValid: (prefix: string | 999) => prefix is SchemaPrefixValue;
+    get value(): SchemaPrefixValue;
+    get isValid(): boolean;
+    set value(value: string);
+    private constructor();
+}
+
+type VarID = `${SchemaPrefixValue}_${PagePrefixValue}`;
+declare const VarID: {
+    create: (schemaPrefix: SchemaPrefixValue, pagePrefix: PagePrefixValue) => VarID;
+};
+
+/*******************************************
+ ** ONLY USE THESE TYPES IN RULE-BUILDER  **
+ ******************************************/
+declare class RuleVariableOption {
+    readonly label: string;
+    readonly value: number;
+    constructor(label: string, value: number);
+}
+declare class RuleQuestionVariable {
+    readonly varId: VarID;
+    readonly label: string;
+    readonly options: ReadonlyArray<RuleVariableOption>;
+    readonly pageNumber: number;
+    readonly kind: "question-variable";
+    constructor(varId: VarID, label: string, options: ReadonlyArray<RuleVariableOption>, pageNumber: number);
+}
+declare class RuleCustomVariable {
+    readonly varId: string;
+    readonly label: string;
+    readonly options: ReadonlyArray<RuleVariableOption>;
+    readonly kind: "configuration-variable";
+    constructor(varId: string, label: string, options: ReadonlyArray<RuleVariableOption>);
+}
+type RuleVariable = RuleQuestionVariable | RuleCustomVariable;
+
+interface ExcludeByPageAction {
+    readonly kind: "exclude-by-pageId";
+    readonly pageId: PageID;
+    readonly pagePrefix: PagePrefixValue;
+    readonly mainText: string;
+    readonly pageNumber: number;
+}
+interface JumpToPageAction {
+    readonly kind: "jump-to-page";
+    readonly pageId: PageID;
+    readonly pagePrefix: PagePrefixValue;
+    readonly mainText: string;
+    readonly pageNumber: number;
+}
+interface ExcludeByTagAction {
+    readonly kind: "exclude-by-tag";
+    readonly tag: string;
+    readonly description: string;
+    readonly pageCount: number;
+}
+
+declare abstract class SingleSelectItem<T> {
+    readonly data: T;
+    private readonly _selectLabel;
+    private readonly _toolTip;
+    private readonly _searchString;
+    get selectLabel(): string;
+    get tooltip(): string;
+    get searchString(): string;
+    protected constructor(data: T);
+    protected abstract getSelectLabel(): string;
+    protected abstract getTooltip(): string;
+    protected abstract getSearchString(): string;
+}
+declare class RuleVariableSelectItem extends SingleSelectItem<RuleVariable> {
+    readonly data: RuleVariable;
+    static create: (data: RuleVariable) => RuleVariableSelectItem;
+    readonly options: ReadonlyArray<RuleOptionSelectItem>;
+    constructor(data: RuleVariable);
+    protected getSearchString(): string;
+    getSelectLabel(): string;
+    getTooltip(): string;
+}
+declare class RuleOptionSelectItem extends SingleSelectItem<RuleVariableOption> {
+    static create: (option: RuleVariableOption) => RuleOptionSelectItem;
+    private constructor();
+    protected getSearchString(): string;
+    protected getSelectLabel(): string;
+    protected getTooltip(): string;
+}
+declare class OperatorSelectItem extends SingleSelectItem<BuilderOperator | ""> {
+    static readonly EQ: OperatorSelectItem;
+    static readonly NOT_EQ: OperatorSelectItem;
+    static readonly fromSymbol: (symbol: BuilderOperator | Omit<string, BuilderOperator>) => OperatorSelectItem | false;
+    private constructor();
+    protected getSearchString(): string;
+    protected getSelectLabel(): string;
+    protected getTooltip(): string;
+}
+declare class JumpToPageSelectItem extends SingleSelectItem<JumpToPageAction> {
+    static readonly create: (pageData: JumpToPageAction) => JumpToPageSelectItem;
+    protected constructor(pageData: JumpToPageAction);
+    protected getSearchString(): string;
+    protected getSelectLabel(): string;
+    protected getTooltip(): string;
+}
+
+interface BuilderConditionDto {
+    readonly kind: "condition";
+    readonly operator: BuilderOperator | "";
+    readonly name: string;
+    readonly variableId: string;
+    readonly value: number | string | boolean;
+}
+declare class BuilderCondition extends BuilderObject<"builder-condition", BuilderConditionDto> {
+    readonly objectType: "builder-condition";
+    static readonly NUMBER_OPERATORS: ReadonlyArray<OperatorSelectItem>;
+    private initialDto;
+    name: string;
+    static create: (variableList: ReadonlyArray<RuleVariable>) => BuilderCondition;
+    static fromDto: (dto: BuilderConditionDto, variables: ReadonlyArray<RuleVariable>) => BuilderCondition;
+    private _variable;
+    private _operator;
+    private _value;
+    private _variableList;
+    /**
+     * Can only set variables that exist in variableList.
+     * @param variable
+     */
+    set variable(variable: RuleVariable | false);
+    get variable(): RuleVariable | false;
+    set value(variableValue: RuleVariableOption | false);
+    get value(): RuleVariableOption | false;
+    validate(): {
+        isValid: true;
+    } | {
+        isValid: false;
+        message: string;
+    };
+    toEngineCondition(): Condition.Simple | false;
+    private findVariableInUniverse;
+    set operator(operator: BuilderOperator | "");
+    get operator(): BuilderOperator | "";
+    private constructor();
+    get variableSelectItemsInUniverse(): ReadonlyArray<RuleVariableSelectItem>;
+    get operatorsSelectItems(): ReadonlyArray<OperatorSelectItem>;
+    get selectValueItems(): ReadonlyArray<RuleOptionSelectItem>;
+    clone(): BuilderConditionDto;
+    private _setVariableList;
+    toJson(): BuilderConditionDto;
+}
+
+declare const ConditionGroupType: {
+    all: boolean;
+    any: boolean;
+    count: boolean;
+};
+type ConditionGroupType = keyof typeof ConditionGroupType;
+interface BuilderConditionGroupDto {
+    readonly kind: "condition-group";
+    readonly name: string;
+    readonly count?: number;
+    readonly type: ConditionGroupType;
+    readonly conditions: ReadonlyArray<BuilderConditionDto>;
+}
+declare class BuilderConditionGroup extends BuilderObject<"builder-condition-group", BuilderConditionGroupDto> {
+    static readonly isConditionGroupType: (value: string | symbol) => value is "all" | "any" | "count";
+    readonly objectType: "builder-condition-group";
+    private _type;
+    name: string;
+    private readonly _conditions;
+    private readonly _variableList;
+    static readonly fromDto: (dto: BuilderConditionGroupDto, variableList: ReadonlyArray<RuleVariable>) => BuilderConditionGroup;
+    protected constructor(dto: BuilderConditionGroupDto, variableList: ReadonlyArray<RuleVariable>);
+    get conditions(): ReadonlyArray<BuilderCondition>;
+    get conditionCount(): number;
+    addCondition(): BuilderCondition;
+    removeCondition(condition: BuilderCondition): boolean;
+    clone(): BuilderConditionGroupDto;
+    toJson(): BuilderConditionGroupDto;
+    toEngineConditionComplex(): Condition.Complex | false;
+    get type(): ConditionGroupType;
+    set type(conditionGroupType: ConditionGroupType);
+}
+
+declare abstract class MultiSelectItem<T> {
+    readonly data: T;
+    private readonly _isSelectedInitially;
+    private readonly _selectLabel;
+    private readonly _toolTip;
+    private readonly _searchString;
+    isSelected: boolean;
+    get selectLabel(): string;
+    get tooltip(): string;
+    get searchString(): string;
+    protected constructor(data: T, isSelected: boolean);
+    protected abstract getSelectLabel(): string;
+    protected abstract getTooltip(): string;
+    protected abstract getSearchString(): string;
+}
+declare class ExcludeByTagSelectItem extends MultiSelectItem<ExcludeByTagAction> {
+    static readonly create: (tagData: ExcludeByTagAction, isSelected: boolean) => ExcludeByTagSelectItem;
+    protected constructor(data: ExcludeByTagAction, isSelected: boolean);
+    protected getSearchString(): string;
+    protected getSelectLabel(): string;
+    protected getTooltip(): string;
+}
+declare class ExcludeByPageIdSelectItem extends MultiSelectItem<ExcludeByPageAction> {
+    static create: (ruleActionPage: ExcludeByPageAction, isSelected: boolean) => ExcludeByPageIdSelectItem;
+    protected constructor(data: ExcludeByPageAction, isSelected: boolean);
+    protected getSearchString(): string;
+    protected getSelectLabel(): string;
+    protected getTooltip(): string;
+}
+
+/**
+ * TODO Crate filters for "cardinality" or "order" of a sum-score;
+ * Return legal lists of variables.
+ */
+declare class RuleInput {
+    private readonly _questionVariables;
+    private readonly _customVariables;
+    private readonly _pageIdActions;
+    private readonly _tagActions;
+    private readonly _jumpActions;
+    constructor(_questionVariables: ReadonlyArray<RuleQuestionVariable>, _customVariables: ReadonlyArray<RuleCustomVariable>, _pageIdActions: ReadonlyArray<ExcludeByPageAction>, _tagActions: ReadonlyArray<ExcludeByTagAction>, _jumpActions: ReadonlyArray<JumpToPageAction>);
+    get questionVars(): ReadonlyArray<RuleVariable>;
+    getConditionInput(): ReadonlyArray<RuleVariable>;
+    getJumpToPageOptions(): ReadonlyArray<JumpToPageSelectItem>;
+    get customVars(): ReadonlyArray<RuleCustomVariable>;
+    get excludeByPageIdActions(): readonly ExcludeByPageAction[];
+    get excludeByTagActions(): readonly ExcludeByTagAction[];
+    get jumpToPageActions(): readonly JumpToPageAction[];
+}
+
+declare class JumpToActionManager {
+    private readonly validOptions;
+    private readonly initialSelection;
+    readonly options: ReadonlyArray<JumpToPageSelectItem>;
+    private _selected;
+    constructor(validOptions: RuleInput["_jumpActions"], initialSelection: string | false | undefined);
+    get selected(): JumpToPageSelectItem | false;
+    set selected(selected: JumpToPageSelectItem | false);
+    getSelectedPageId(): string | false;
+    private findSelected;
+}
+
+interface BuilderRuleDto {
+    readonly type: ConditionGroupType;
+    readonly name: string;
+    readonly conditions: ReadonlyArray<BuilderConditionDto | BuilderConditionGroupDto>;
+    readonly excludeTags: ReadonlyArray<string>;
+    readonly excludePages: ReadonlyArray<PageID>;
+    readonly jumpToPage: string | false;
+}
+declare class BuilderRule extends BuilderObject<"builder-rule", BuilderRuleDto> {
+    private readonly dto;
+    private readonly _ruleInput;
+    readonly objectType: "builder-rule";
+    private _type;
+    name: string;
+    private readonly _conditions;
+    private readonly _tagActionManager;
+    private _pageActionManager;
+    readonly jumpToActionManager: JumpToActionManager;
+    static readonly fromDto: (dto: BuilderRuleDto, input: RuleInput) => BuilderRule;
+    protected constructor(dto: BuilderRuleDto, _ruleInput: RuleInput);
+    get conditions(): ReadonlyArray<BuilderConditionGroup | BuilderCondition>;
+    getTagActions(): readonly ExcludeByTagSelectItem[];
+    getValidPageActions(): readonly ExcludeByPageIdSelectItem[];
+    get conditionCount(): number;
+    set type(type: ConditionGroupType);
+    get type(): ConditionGroupType;
+    deleteCondition(condition: BuilderCondition | BuilderConditionGroup): boolean;
+    addCondition(): BuilderCondition;
+    addConditionGroup(): BuilderConditionGroup;
+    clone(): BuilderRuleDto;
+    toJson(): BuilderRuleDto;
+    toEngineRule(): PageQueRules;
+}
+
+declare class PageActionManager {
+    readonly validOptions: RuleInput["_pageIdActions"];
+    readonly initialSelection: ReadonlyArray<string>;
+    private readonly _initialSelection;
+    readonly selectItems: ReadonlyArray<ExcludeByPageIdSelectItem>;
+    constructor(validOptions: RuleInput["_pageIdActions"], initialSelection: ReadonlyArray<string>);
+    getCurrentSelection(): ReadonlyArray<PageID>;
+    getEngineAction(): ReadonlyArray<ExcludeByPageAction>;
+}
+
+declare class TagActionManager {
+    readonly validOptions: RuleInput["_tagActions"];
+    readonly initialSelection: ReadonlyArray<string>;
+    private readonly _initialSelection;
+    readonly selectItems: ReadonlyArray<ExcludeByTagSelectItem>;
+    constructor(validOptions: RuleInput["_tagActions"], initialSelection: ReadonlyArray<string>);
+    getCurrentSelection(): ReadonlyArray<string>;
+    getEngineActions(): ReadonlyArray<ExcludeByTagAction>;
+}
+
+type BuilderPageType = "info-page" | "question";
+interface BuilderPageDto {
+    readonly id: PageID;
+    readonly prefix: PagePrefixValue;
+    _type: BuilderPageType;
+    mainText: BuilderMainTextDto;
+    nextButton: BuilderOptionDto;
+    defaultQuestion: BuilderQuestionDto;
+    mainMedia?: BuilderMainImageDto | BuilderMainVideoDto;
+    includedInSumScores: Array<{
+        sumScoreVariableId: SumScoreVariableID;
+        weight: number;
+    }>;
+    autoplaySequence: Array<string>;
+    tags: ReadonlyArray<string>;
+}
+declare class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
+    readonly objectType: "builder-page";
+    readonly id: PageID;
+    private _pageType;
+    private _prefix;
+    private readonly _tags;
+    private _backgroundColor;
+    private _includedInSumScores;
+    mainMedia: BuilderMainVideoDto | BuilderMainImageDto | false;
+    defaultQuestion: BuilderQuestion;
+    mainText: BuilderMainText;
+    nextButton: BuilderOption;
+    static create(type: BuilderPageType, _prefix: PagePrefixValue): BuilderPage;
+    static fromJson(dto: BuilderPageDto): BuilderPage;
+    private constructor();
+    addTag(tag: string): void;
+    deleteTag(tag: string): void;
+    set pageType(value: BuilderPageType);
+    get includedInSumScores(): {
+        sumScoreVariableId: SumScoreVariableID;
+        weight: number;
+        name: string;
+        description: string;
+    }[];
+    getQuestionVariables(modulePrefix: SchemaPrefix, pageNumber: number): ReadonlyArray<RuleQuestionVariable>;
+    get tags(): ReadonlyArray<string>;
+    get pageType(): BuilderPageType;
+    get prefix(): PagePrefixValue;
+    set prefix(value: PagePrefixValue);
+    toJson(): BuilderPageDto;
+    clone(): BuilderPageDto;
+    get backgroundColor(): string;
+    set backgroundColor(color: string);
+}
+
+interface BuilderTagDto {
+    readonly id: TagID;
+    readonly tag: string;
+    readonly description: string;
+}
+declare class BuilderTag extends BuilderObject<"builder-tag", BuilderTagDto> {
+    readonly objectType: "builder-tag";
+    readonly id: TagID;
+    tagText: string;
+    tagDescription: string;
+    static readonly MAX_LENGTH = 20;
+    static readonly MIN_LENGTH = 1;
+    static readonly create: (tag: string, description?: string) => BuilderTag;
+    static readonly fromDto: (dto: BuilderTagDto) => BuilderTag;
+    protected constructor(dto: BuilderTagDto);
+    clone(): BuilderTagDto;
+    toJson(): BuilderTagDto;
+}
+
+interface SumScoreVariableDto {
+    id: SumScoreVariableID;
+    name: string;
+    description: string;
+    useAvg: boolean;
+}
+declare class SumScoreVariable extends BuilderObject<"builder-sum-score-variable", SumScoreVariableDto> {
+    readonly objectType = "builder-sum-score-variable";
+    readonly id: SumScoreVariableID;
+    private _useAvg;
+    private _name;
+    private _description;
+    private _error;
+    private _usedIn;
+    get usedIn(): BuilderPage[];
+    static readonly create: (data: {
+        name: string;
+        description: string;
+        useAvg: boolean;
+    }) => SumScoreVariable;
+    get hasErrors(): boolean;
+    static fromDto: (dto: SumScoreVariableDto) => SumScoreVariable;
+    private constructor();
+    toJson(): SumScoreVariableDto;
+    clone(): SumScoreVariableDto;
+    get name(): string;
+    get description(): string;
+    get useAvg(): boolean;
+}
+
+/**
+ * Interface representing a code book question sum-score.
+ *
+ * @interface
+ */
+interface CodeBookQuestionVariable {
+    readonly kind: "codebook-question-variable";
+    readonly label: string;
+    readonly varId: string;
+    readonly pageId: PageID;
+    readonly pagePrefix: string;
+    readonly modulePrefix: string;
+    readonly pagePosition: number;
+    readonly options: ReadonlyArray<{
+        label: string;
+        value: number;
+    }>;
+    readonly includedInSumScores: ReadonlyArray<SumScoreVariableDto>;
+}
+interface CodebookPredefinedVariable {
+    readonly kind: "codebook-predefined-variable";
+    readonly modulePrefix: string;
+    readonly moduleID: string;
+    defaultValue: number;
+    options: Array<{
+        label: string;
+        value: number;
+    }>;
+}
+
+interface Codebook {
+    readonly predefinedVariables: ReadonlyArray<CodebookPredefinedVariable>;
+    readonly pageVariables: ReadonlyArray<CodeBookQuestionVariable>;
+}
+declare const _CodeBook: {
+    readonly fromSchema: (schema: BuilderSchemaDto) => Codebook;
+};
+declare const CodeBook: Readonly<{
+    readonly fromSchema: (schema: BuilderSchemaDto) => Codebook;
+}>;
+
+/**
+ * This interface is ment to define all information that a schema-admin app
+ * needs to generate a dynamic form for setting values for predefined variables.
+ */
+interface SchemaConfig {
+    readonly schemaName: string;
+    readonly schemaId: string;
+    readonly schemaPrefix: string;
+    readonly variables: ReadonlyArray<CodebookPredefinedVariable>;
+}
+declare const SchemaConfig: {
+    readonly fromSchema: (schema: BuilderSchemaDto) => SchemaConfig;
+};
+
+interface CompilerOutput {
+    schema: SchemaDto;
+    codebook: Codebook;
+    schemaConfig: SchemaConfig;
+}
+interface CompilerOption {
+    blockAutoplayQuestion: boolean;
+    blockAutoplayVideo: boolean;
+}
+
+interface BuilderSchemaDto {
+    readonly id: SchemaID;
+    readonly prefix: SchemaPrefixValue;
+    readonly mainImage: ImageFile | false;
+    readonly backgroundColor: string;
+    readonly name: string;
+    readonly pages: ReadonlyArray<BuilderPageDto>;
+    readonly baseHeight: number;
+    readonly baseWidth: number;
+    readonly predefinedVariables?: Array<CodebookPredefinedVariable>;
+    readonly sumScoreVariables?: ReadonlyArray<SumScoreVariableDto>;
+    readonly rules: ReadonlyArray<BuilderRuleDto>;
+    readonly tags: ReadonlyArray<BuilderTagDto>;
+}
+declare class BuilderSchema {
+    readonly id: SchemaID;
+    name: string;
+    readonly prefix: SchemaPrefix;
+    baseHeight: number;
+    baseWidth: number;
+    backgroundColor: string;
+    private readonly _pageCollection;
+    mainImage: ImageFile | false;
+    predefinedVariables: CodebookPredefinedVariable[];
+    private _rules;
+    private readonly _sumScoreCollection;
+    get rules(): ReadonlyArray<BuilderRule>;
+    get pages(): ReadonlyArray<BuilderPage>;
+    get sumScoreVariables(): ReadonlyArray<SumScoreVariable>;
+    private readonly _tagCollection;
+    get tags(): ReadonlyArray<BuilderTag>;
+    static create(id: SchemaID, name: string, prefix: SchemaPrefixValue): BuilderSchema;
+    static fromJson(dto: BuilderSchemaDto): BuilderSchema;
+    toJson(): BuilderSchemaDto;
+    private constructor();
+    addPage(type: BuilderPageType, atIndex?: number): BuilderPage;
+    sumScoreVariableCreate(options: {
+        name: string;
+        description: string;
+        useAvg: boolean;
+    }): SumScoreVariable;
+    sumScoreVariableAddToPage(sumScoreVariable: SumScoreVariable, page: BuilderPage, weight: number): boolean;
+    private updateSumScoreRelations;
+    sumScoreVariableUpdate(id: SumScoreVariableID, data: Partial<SumScoreVariableDto>): boolean;
+    sumScoreVariableDeleteFromPage(pageId: PageID, sumScoreVariableId: SumScoreVariableID): void;
+    insertPage(page: BuilderPage, atIndex: number): boolean;
+    private insertPageAtIndex;
+    addRule(): BuilderRule;
+    deleteRule(rule: BuilderRule): void;
+    movePage(page: BuilderPage, toIndex: number): boolean;
+    deletePage(page: BuilderPage): boolean;
+    reevaluateRules(): void;
+    getRuleInput(): RuleInput;
+    deleteTags(tags: ReadonlyArray<BuilderTag>): void;
+    addTag(builderTag: BuilderTag): void;
+    compile(options?: CompilerOption): CompilerOutput;
+    sumScoreVariableDelete(id: SumScoreVariableID): boolean;
+}
+
+interface BuilderTextDto {
+    readonly id: TextID;
+    text: string;
+    name: string;
+    translationRequired: boolean;
+}
+declare class BuilderText extends BuilderObject<"builder-text", BuilderTextDto> {
+    readonly objectType = "builder-text";
+    id: TextID;
+    text: string;
+    name: string;
+    translateRequired: boolean;
+    private constructor();
+    static create(name: string): BuilderText;
+    static fromJson(dto: BuilderTextDto): BuilderText;
+    clone(): BuilderTextDto;
+    toJson(): BuilderTextDto;
+}
+
+interface SumScoreAnswer {
+    readonly varId: string;
+    readonly varLabel: string;
+    readonly value: number;
+    readonly valueLabel: string;
+}
+
+interface SumScore {
+    sumScore: number;
+    avg: number;
+    useAvg: boolean;
+    includedAnswerCount: number;
+    missingAnswerCount: number;
+    skippedBy9Count: number;
+    basedOn: Array<{
+        varId: string;
+        value: number;
+        weight: number;
+        varLabel: string;
+    }>;
+    errorMessages: string[];
+}
+declare const SumScore: {
+    ALLOWED_VALUES: number[];
+    calculate: (sumScoreVariable: SumScoreVariableDto, basedOnVariables: Array<{
+        varId: string;
+        weight: number;
+    }>, answers: Array<SumScoreAnswer>) => SumScore;
+    calculateAll: (schemaDto: BuilderSchemaDto, answers: Array<SumScoreAnswer>) => ReadonlyArray<SumScore>;
+    isAllowedValue: (num: number) => boolean;
+    createVariable: () => SumScoreVariableDto;
+};
+
+declare class TagCollection implements Iterable<BuilderTag> {
+    private readonly _tags;
+    static readonly create: () => TagCollection;
+    [Symbol.iterator](): IterableIterator<BuilderTag>;
+    private constructor();
+    init(tags: ReadonlyArray<BuilderTagDto>): void;
+    add(tag: BuilderTag): void;
+    /**
+     * Delete this tag from collection;
+     * @param tag
+     */
+    delete(tag: BuilderTag): void;
+    toJson(): ReadonlyArray<BuilderTagDto>;
+    deleteAll(tags: Iterable<BuilderTag>): void;
+}
+
+export { type AudioFile, BuilderCondition, type BuilderConditionDto, BuilderConditionGroup, type BuilderConditionGroupDto, type BuilderMainImageDto, BuilderMainText, type BuilderMainTextDto, type BuilderMainVideoDto, BuilderOperator, BuilderOption, type BuilderOptionDto, BuilderPage, type BuilderPageDto, type BuilderPageType, BuilderQuestion, type BuilderQuestionDto, type BuilderQuestionType, BuilderRule, type BuilderRuleDto, BuilderSchema, type BuilderSchemaDto, BuilderTag, type BuilderTagDto, BuilderText, type BuilderTextDto, CodeBook, type CodeBookQuestionVariable, type Codebook, type CodebookPredefinedVariable, type CompilerOption, type CompilerOutput, ConditionGroupType, type ExcludeByPageAction, ExcludeByPageIdSelectItem, type ExcludeByTagAction, ExcludeByTagSelectItem, type ID, type ImageFile, JumpToActionManager, type JumpToPageAction, JumpToPageSelectItem, MultiSelectItem, OperatorSelectItem, OptionID, PageActionManager, PageID, PagePrefix, type PagePrefixValue, QuestionID, RuleCustomVariable, RuleInput, RuleOptionSelectItem, RuleQuestionVariable, type RuleVariable, RuleVariableOption, RuleVariableSelectItem, SchemaConfig, SchemaID, SchemaPrefix, type SchemaPrefixValue, SingleSelectItem, SumScore, type SumScoreAnswer, SumScoreVariable, type SumScoreVariableDto, SumScoreVariableID, TagActionManager, TagCollection, TagID, TextID, VarID, type VideoFile, _CodeBook, createTypedIdSingleton };