optolith-database-schema 0.17.0 → 0.18.1

package/lib/types/magicalActions/DominationRitual.d.ts

@@ -1,145 +1,200 @@
-/**
- * @main DominationRitual
- */
-import { TypeConfig } from "../../typeConfig.js";
-import { CheckResultBasedDuration, DurationUnit, IndefiniteDurationTranslation } from "../_ActivatableSkillDuration.js";
-import { Effect } from "../_ActivatableSkillEffect.js";
-import { LocaleMap } from "../_LocaleMap.js";
-import { NonEmptyString } from "../_NonEmptyString.js";
-import { ResponsiveText } from "../_ResponsiveText.js";
-import { PropertyReference } from "../_SimpleReferences.js";
-import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js";
-import { Errata } from "../source/_Erratum.js";
-import { PublicationRefs } from "../source/_PublicationRef.js";
-/**
- * @title Domination Ritual
- */
-export type DominationRitual = {
-    /**
-     * The domination ritual's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    /**
-     * Lists the linked three attributes used to make a skill check.
-     */
-    check: SkillCheck;
-    /**
-     * In some cases, the target's Spirit or Toughness is applied as a penalty.
-     */
-    check_penalty?: SkillCheckPenalty;
-    /**
-     * Measurable parameters of a curse.
-     */
-    parameters: DominationRitualPerformanceParameters;
-    /**
-     * The associated property.
-     */
-    property: PropertyReference;
-    src: PublicationRefs;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<DominationRitualTranslation>;
-};
-export type DominationRitualTranslation = {
-    /**
-     * The name of the domination ritual.
-     */
-    name: NonEmptyString;
-    /**
-     * The effect description may be either a plain text or a text that is
-     * divided by a list of effects for each quality level. It may also be a
-     * list for each two quality levels.
-     */
-    effect: Effect;
-    /**
-     * @deprecated
-     */
-    cost: {
-        full: string;
-        abbr: string;
-    };
-    /**
-     * @deprecated
-     */
-    duration: {
-        full: string;
-        abbr: string;
-    };
-    errata?: Errata;
-};
-/**
- * Measurable parameters of a curse.
- */
-export type DominationRitualPerformanceParameters = {
-    /**
-     * The AE cost.
-     */
-    cost: DominationRitualCost;
-    /**
-     * The duration.
-     */
-    duration: DominationRitualDuration;
-};
-export type DominationRitualCost = {
-    /**
-     * The initial skill modification identifier/level.
-     * @integer
-     * @minimum 1
-     * @maximum 6
-     */
-    initial_modification_level: number;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     * @minProperties 1
-     */
-    translations?: LocaleMap<DominationRitualCostTranslation>;
-};
-export type DominationRitualCostTranslation = {
-    /**
-     * AE cost in addition to the normal AE cost.
-     */
-    additional: ResponsiveText;
-};
-export type DominationRitualDuration = {
-    tag: "Fixed";
-    fixed: FixedDominationRitualDuration;
-} | {
-    tag: "CheckResultBased";
-    check_result_based: CheckResultBasedDuration;
-} | {
-    tag: "Indefinite";
-    indefinite: IndefiniteDominationRitualDuration;
-};
-export type FixedDominationRitualDuration = {
-    /**
-     * The (unitless) duration value.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-    /**
-     * The unit of the `value`.
-     */
-    unit: DurationUnit;
-};
-export type IndefiniteDominationRitualDuration = {
-    /**
-     * Specified if the duration has a maximum time span.
-     */
-    maximum?: MaximumIndefiniteCurseDuration;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<IndefiniteDurationTranslation>;
-};
-export type MaximumIndefiniteCurseDuration = {
-    tag: "Fixed";
-    fixed: FixedDominationRitualDuration;
-} | {
-    tag: "CheckResultBased";
-    check_result_based: CheckResultBasedDuration;
-};
-export declare const config: TypeConfig<DominationRitual, DominationRitual["id"], "DominationRitual">;
+import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const DominationRitual: Entity<"DominationRitual", {
+    check: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SkillCheck", import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, true>;
+    check_penalty: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SkillCheckPenalty", {
+        Spirit: EnumCase<null>;
+        HalfOfSpirit: EnumCase<null>;
+        Toughness: EnumCase<null>;
+        HigherOfSpiritAndToughness: EnumCase<null>;
+        SummoningDifficulty: EnumCase<null>;
+        CreationDifficulty: EnumCase<null>;
+    }, []>>, false>;
+    parameters: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DominationRitualPerformanceParameters", Object<{
+        cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DominationRitualCost", Object<{
+            initial_modification_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"DominationRitualCostTranslation", {
+                additional: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveText", Object<{
+                    full: import("tsondb/schema/def").MemberDecl<String, true>;
+                    compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+                }>, []>>, true>;
+            }>, false>;
+        }>, []>>, true>;
+        duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DominationRitualDuration", {
+            Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedDominationRitualDuration", Object<{
+                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
+                    Seconds: EnumCase<null>;
+                    Minutes: EnumCase<null>;
+                    Hours: EnumCase<null>;
+                    Days: EnumCase<null>;
+                    Weeks: EnumCase<null>;
+                    Months: EnumCase<null>;
+                    Years: EnumCase<null>;
+                    Centuries: EnumCase<null>;
+                    Actions: EnumCase<null>;
+                    CombatRounds: EnumCase<null>;
+                }, []>>, true>;
+            }>, []>>>;
+            CheckResultBased: EnumCase<IncludeIdentifier<[], TypeAlias<"CheckResultBasedDuration", Object<{
+                is_maximum: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, false>;
+                base: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultValue", {
+                    QualityLevels: EnumCase<null>;
+                    SkillPoints: EnumCase<null>;
+                }, []>>, true>;
+                modifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CheckResultBasedModifier", Object<{
+                    arithmetic: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultArithmetic", {
+                        Multiply: EnumCase<null>;
+                        Divide: EnumCase<null>;
+                    }, []>>, true>;
+                    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, []>>, false>;
+                unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
+                    Seconds: EnumCase<null>;
+                    Minutes: EnumCase<null>;
+                    Hours: EnumCase<null>;
+                    Days: EnumCase<null>;
+                    Weeks: EnumCase<null>;
+                    Months: EnumCase<null>;
+                    Years: EnumCase<null>;
+                    Centuries: EnumCase<null>;
+                    Actions: EnumCase<null>;
+                    CombatRounds: EnumCase<null>;
+                }, []>>, true>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CheckResultBasedDurationTranslation", {
+                    replacement: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextReplace", Object<{
+                        full: import("tsondb/schema/def").MemberDecl<String, true>;
+                        compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Indefinite: EnumCase<IncludeIdentifier<[], TypeAlias<"IndefiniteDominationRitualDuration", Object<{
+                maximum: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"MaximumIndefiniteDominationRitualDuration", {
+                    Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedDominationRitualDuration", Object<{
+                        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
+                            Seconds: EnumCase<null>;
+                            Minutes: EnumCase<null>;
+                            Hours: EnumCase<null>;
+                            Days: EnumCase<null>;
+                            Weeks: EnumCase<null>;
+                            Months: EnumCase<null>;
+                            Years: EnumCase<null>;
+                            Centuries: EnumCase<null>;
+                            Actions: EnumCase<null>;
+                            CombatRounds: EnumCase<null>;
+                        }, []>>, true>;
+                    }>, []>>>;
+                    CheckResultBased: EnumCase<IncludeIdentifier<[], TypeAlias<"CheckResultBasedDuration", Object<{
+                        is_maximum: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, false>;
+                        base: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultValue", {
+                            QualityLevels: EnumCase<null>;
+                            SkillPoints: EnumCase<null>;
+                        }, []>>, true>;
+                        modifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CheckResultBasedModifier", Object<{
+                            arithmetic: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultArithmetic", {
+                                Multiply: EnumCase<null>;
+                                Divide: EnumCase<null>;
+                            }, []>>, true>;
+                            value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                        }>, []>>, false>;
+                        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
+                            Seconds: EnumCase<null>;
+                            Minutes: EnumCase<null>;
+                            Hours: EnumCase<null>;
+                            Days: EnumCase<null>;
+                            Weeks: EnumCase<null>;
+                            Months: EnumCase<null>;
+                            Years: EnumCase<null>;
+                            Centuries: EnumCase<null>;
+                            Actions: EnumCase<null>;
+                            CombatRounds: EnumCase<null>;
+                        }, []>>, true>;
+                        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CheckResultBasedDurationTranslation", {
+                            replacement: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextReplace", Object<{
+                                full: import("tsondb/schema/def").MemberDecl<String, true>;
+                                compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+                            }>, []>>, false>;
+                        }>, false>;
+                    }>, []>>>;
+                }, []>>, false>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"IndefiniteDominationRitualDurationTranslation", {
+                    description: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveText", Object<{
+                        full: import("tsondb/schema/def").MemberDecl<String, true>;
+                        compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+                    }>, []>>, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, true>;
+    }>, []>>, true>;
+    property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
+        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
+                printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
+                pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], Enum<"Revision", {
+                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                    pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"DominationRitualTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        effect: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ActivatableSkillEffect", {
+            Plain: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillPlainEffect", Object<{
+                text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, []>>>;
+            ForEachQualityLevel: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillEffectForEachQualityLevel", Object<{
+                text_before: import("tsondb/schema/def").MemberDecl<String, true>;
+                quality_levels: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<String>, true>;
+                text_after: import("tsondb/schema/def").MemberDecl<String, false>;
+            }>, []>>>;
+            ForEachTwoQualityLevels: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillEffectForEachTwoQualityLevels", Object<{
+                text_before: import("tsondb/schema/def").MemberDecl<String, true>;
+                quality_levels: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<String>, true>;
+                text_after: import("tsondb/schema/def").MemberDecl<String, false>;
+            }>, []>>>;
+        }, []>>, true>;
+        cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"OldParameter", Object<{
+            full: import("tsondb/schema/def").MemberDecl<String, true>;
+            abbr: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>, false>;
+        duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"OldParameter", Object<{
+            full: import("tsondb/schema/def").MemberDecl<String, true>;
+            abbr: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>, false>;
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
+            description: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

package/lib/types/magicalActions/DominationRitual.js

@@ -1,14 +1,127 @@
-/**
- * @main DominationRitual
- */
-import { todo } from "../../validation/builders/integrity.js";
-import { validateEntityFileName } from "../../validation/builders/naming.js";
-import { createSchemaValidator } from "../../validation/builders/schema.js";
-import { getFilenamePrefixAsNumericId } from "../../validation/filename.js";
-export const config = {
+import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { OldParameter } from "../_ActivatableSkill.js";
+import { CheckResultBasedDuration, DurationUnit } from "../_ActivatableSkillDuration.js";
+import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
+import { PropertyIdentifier, SkillModificationLevelIdentifier } from "../_Identifier.js";
+import { ResponsiveText } from "../_ResponsiveText.js";
+import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js";
+import { NestedLocaleMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { src } from "../source/_PublicationRef.js";
+export const DominationRitual = Entity(import.meta.url, {
     name: "DominationRitual",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("DominationRitual"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "DominationRituals",
+    type: () => Object({
+        check: Required({
+            comment: "Lists the linked three attributes used to make a skill check.",
+            type: IncludeIdentifier(SkillCheck),
+        }),
+        check_penalty: Optional({
+            comment: "In some cases, the target's Spirit or Toughness is applied as a penalty.",
+            type: IncludeIdentifier(SkillCheckPenalty),
+        }),
+        parameters: Required({
+            comment: "Measurable parameters of a domination ritual.",
+            type: IncludeIdentifier(DominationRitualPerformanceParameters),
+        }),
+        property: Required({
+            comment: "The associated property.",
+            type: PropertyIdentifier(),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "DominationRitualTranslation", Object({
+            name: Required({
+                comment: "The domination ritual’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            effect: Required({
+                comment: "The effect description may be either a plain text or a text that is divided by a list of effects for each quality level. It may also be a list for each two quality levels.",
+                type: IncludeIdentifier(ActivatableSkillEffect),
+            }),
+            cost: Optional({
+                isDeprecated: true,
+                type: IncludeIdentifier(OldParameter),
+            }),
+            duration: Optional({
+                isDeprecated: true,
+                type: IncludeIdentifier(OldParameter),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+const DominationRitualPerformanceParameters = TypeAlias(import.meta.url, {
+    name: "DominationRitualPerformanceParameters",
+    comment: "Measurable parameters of a domination ritual.",
+    type: () => Object({
+        cost: Required({
+            comment: "The AE cost.",
+            type: IncludeIdentifier(DominationRitualCost),
+        }),
+        duration: Required({
+            comment: "The duration.",
+            type: IncludeIdentifier(DominationRitualDuration),
+        }),
+    }),
+});
+const DominationRitualCost = TypeAlias(import.meta.url, {
+    name: "DominationRitualCost",
+    type: () => Object({
+        initial_modification_level: Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+        translations: NestedLocaleMap(Optional, "DominationRitualCostTranslation", Object({
+            additional: Required({
+                comment: "AE cost in addition to the normal AE cost.",
+                type: IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
+const DominationRitualDuration = Enum(import.meta.url, {
+    name: "DominationRitualDuration",
+    values: () => ({
+        Fixed: EnumCase({ type: IncludeIdentifier(FixedDominationRitualDuration) }),
+        CheckResultBased: EnumCase({ type: IncludeIdentifier(CheckResultBasedDuration) }),
+        Indefinite: EnumCase({ type: IncludeIdentifier(IndefiniteDominationRitualDuration) }),
+    }),
+});
+const FixedDominationRitualDuration = TypeAlias(import.meta.url, {
+    name: "FixedDominationRitualDuration",
+    type: () => Object({
+        value: Required({
+            comment: "The (unitless) duration.",
+            type: Integer({ minimum: 1 }),
+        }),
+        unit: Required({
+            comment: "The duration unit.",
+            type: IncludeIdentifier(DurationUnit),
+        }),
+    }),
+});
+const IndefiniteDominationRitualDuration = TypeAlias(import.meta.url, {
+    name: "IndefiniteDominationRitualDuration",
+    type: () => Object({
+        maximum: Optional({
+            comment: "Specified if the duration has a maximum time span.",
+            type: IncludeIdentifier(MaximumIndefiniteDominationRitualDuration),
+        }),
+        translations: NestedLocaleMap(Required, "IndefiniteDominationRitualDurationTranslation", Object({
+            description: Required({
+                comment: "A description of the duration.",
+                type: IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
+const MaximumIndefiniteDominationRitualDuration = Enum(import.meta.url, {
+    name: "MaximumIndefiniteDominationRitualDuration",
+    values: () => ({
+        Fixed: EnumCase({ type: IncludeIdentifier(FixedDominationRitualDuration) }),
+        CheckResultBased: EnumCase({ type: IncludeIdentifier(CheckResultBasedDuration) }),
+    }),
+});