arelle-release 2.37.13__tar.gz → 2.37.14__tar.gz

{arelle_release-2.37.13/arelle_release.egg-info → arelle_release-2.37.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arelle-release
-Version: 2.37.13
+Version: 2.37.14
 Summary: An open source XBRL platform.
 Author-email: "arelle.org" <support@arelle.org>
 License: Apache-2.0

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/ModelTestcaseObject.py

@@ -353,6 +353,13 @@ class ModelTestcaseVariation(ModelObject):
 
         return None
 
+    @property
+    def expectedWarnings(self):
+        warningElements = XmlUtil.descendants(self, None, "warning")
+        if isinstance(warningElements, list) and len(warningElements) > 0:
+            return [w.stringValue for w in warningElements]
+        return None
+
     @property
     def match(self) -> str | None:
         resultElement = XmlUtil.descendant(self, None, "result")

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/Validate.py

@@ -710,6 +710,7 @@ class Validate:
         testcaseExpectedErrors = self.modelXbrl.modelManager.formulaOptions.testcaseExpectedErrors or {}
         matchAllExpected = testcaseResultOptions == "match-all" or modelTestcaseVariation.match == 'all'
         expectedReportCount = modelTestcaseVariation.expectedReportCount
+        expectedWarnings = modelTestcaseVariation.expectedWarnings if self.modelXbrl.modelManager.formulaOptions.testcaseResultsCaptureWarnings else []
         if expectedReportCount is not None and validateModelCount is not None and expectedReportCount != validateModelCount:
             errors.append("conf:testcaseExpectedReportCountError")
         _blockedMessageCodes = modelTestcaseVariation.blockedMessageCodes # restricts codes examined when provided
@@ -750,10 +751,21 @@ class Validate:
             status = "fail" if numErrors == 0 else "pass"
         elif expected in (None, []) and numErrors == 0:
             status = "pass"
-        elif isinstance(expected,(QName,str,dict,list)): # string or assertion id counts dict
+        elif isinstance(expected, (QName, str, dict, list)) or expectedWarnings:
             status = "fail"
             _passCount = 0
-            _expectedList = expected.copy() if isinstance(expected, list) else [expected]
+            if isinstance(expected, list):
+                _expectedList = expected.copy()
+            elif not expected:
+                _expectedList = []
+            else:
+                _expectedList = [expected]
+            if expectedWarnings:
+                _expectedList.extend(expectedWarnings)
+                if expectedCount is not None:
+                    expectedCount += len(expectedWarnings)
+                else:
+                    expectedCount = len(expectedWarnings)
             if not isinstance(expected, list):
                 expected = [expected]
             for testErr in _errors:

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/ValidateDuplicateFacts.py

@@ -380,7 +380,7 @@ def areFactsValueEqual(factA: ModelFact, factB: ModelFact) -> bool:
 
 
 def getAspectEqualFacts(
-    hashEquivalentFacts: list[ModelFact], includeSingles: bool
+    hashEquivalentFacts: list[ModelFact], includeSingles: bool, useLang: bool = True
 ) -> Iterator[list[ModelFact]]:
     """
     Given a list of concept/context/unit hash-equivalent facts,
@@ -389,20 +389,14 @@ def getAspectEqualFacts(
     :param includeSingles: Whether to include lists of single facts (with no duplicates).
     :return: Lists of aspect-equal facts.
     """
-    aspectEqualFacts: dict[
-        tuple[QName, str | None], dict[tuple[ModelContext, ModelUnit], list[ModelFact]]
-    ] = defaultdict(dict)
-    for (
-        fact
-    ) in (
-        hashEquivalentFacts
-    ):  # check for hash collision by value checks on context and unit
+    aspectEqualFacts: dict[tuple[QName, str | None], dict[tuple[ModelContext, ModelUnit], list[ModelFact]]] = defaultdict(dict)
+    for fact in hashEquivalentFacts:  # check for hash collision by value checks on context and unit
         contextUnitDict = aspectEqualFacts[
             (
                 fact.qname,
                 (
                     cast(str, fact.xmlLang or "").lower()
-                    if fact.concept.type.isWgnStringFactType
+                    if useLang and fact.concept.type.isWgnStringFactType
                     else None
                 ),
             )

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.37.13'
-__version_tuple__ = version_tuple = (2, 37, 13)
+__version__ = version = '2.37.14'
+__version_tuple__ = version_tuple = (2, 37, 14)

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/plugin/validate/DBA/PluginValidationDataExtension.py

@@ -13,6 +13,7 @@ from arelle.ModelInstanceObject import ModelFact, ModelContext
 from arelle.ModelValue import QName
 from arelle.ModelXbrl import ModelXbrl
 from arelle.utils.PluginData import PluginData
+from arelle.XmlValidateConst import VALID
 
 
 @dataclass
@@ -47,7 +48,6 @@ class PluginValidationDataExtension(PluginData):
     consolidatedSoloDimensionQn: QName
     cpr_regex: regex.regex.Pattern[str]
     dateOfApprovalOfAnnualReportQn: QName
-    dateOfApprovalOfReportQn: QName
     dateOfExtraordinaryDividendDistributedAfterEndOfReportingPeriod: QName
     dateOfGeneralMeetingQn: QName
     descriptionOfQualificationsOfAssuranceEngagementPerformedQn: QName
@@ -157,3 +157,11 @@ class PluginValidationDataExtension(PluginData):
             contexts.append(context)
         self._reportingPeriodContexts = sorted(contexts, key=lambda c: c.endDatetime)
         return self._reportingPeriodContexts
+
+    def isAnnualReport(self, modelXbrl: ModelXbrl) -> bool:
+        """
+        :return: Return True if Type of Submitted Report value is in the annual report types
+        """
+        reportTypeFacts = modelXbrl.factsByQname.get(self.informationOnTypeOfSubmittedReportQn, set())
+        filteredReportTypeFacts = [f for f in reportTypeFacts if f.xValid >= VALID and f.xValue in self.annualReportTypes]
+        return len(filteredReportTypeFacts) > 0

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/plugin/validate/DBA/ValidationPluginExtension.py

@@ -161,7 +161,10 @@ class ValidationPluginExtension(ValidationPlugin):
             annualReportTypes=frozenset([
                 'Årsrapport',
                 'årsrapport',
-                'Annual report'
+                'Annual report',
+                'Likvidationsregnskab',
+                'likvidationsregnskab',
+                'Liquidation accounts',
             ]),
             assetsQn=qname(f'{{{NAMESPACE_FSA}}}Assets'),
             auditedAssuranceReportsDanish='Andre erklæringer med sikkerhed',
@@ -282,7 +285,6 @@ class ValidationPluginExtension(ValidationPlugin):
             consolidatedSoloDimensionQn=qname(f'{{{NAMESPACE_CMN}}}ConsolidatedSoloDimension'),
             cpr_regex=re.compile(r'^([0-2][0-9]|3[0-1])(0[1-9]|1[0-2])[0-9]{2}-[0-9]{4}'),
             dateOfApprovalOfAnnualReportQn=qname(f'{{{NAMESPACE_SOB}}}DateOfApprovalOfAnnualReport'),
-            dateOfApprovalOfReportQn=qname(f'{{{NAMESPACE_GSD}}}DateOfApprovalOfReport'),
             dateOfExtraordinaryDividendDistributedAfterEndOfReportingPeriod=qname(f'{{{NAMESPACE_FSA}}}DateOfExtraordinaryDividendDistributedAfterEndOfReportingPeriod'),
             dateOfGeneralMeetingQn=qname(f'{{{NAMESPACE_GSD}}}DateOfGeneralMeeting'),
             declarationObligationQns=frozenset([

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/plugin/validate/DBA/rules/fr.py

@@ -1266,29 +1266,26 @@ def rule_fr89(
     Regnskabsklasse D // Reporting class D
     Then TypeOfAuditorAssistance should be: Revisionspåtegning // Auditor's report on audited financial statements
     """
-    modelXbrl = val.modelXbrl
-    auditorFacts = modelXbrl.factsByQname.get(pluginData.typeOfAuditorAssistanceQn)
-    if auditorFacts is not None:
+    if pluginData.isAnnualReport(val.modelXbrl):
+        auditorFacts = val.modelXbrl.factsByQname.get(pluginData.typeOfAuditorAssistanceQn, set())
         for auditorFact in auditorFacts:
             if auditorFact.xValid >= VALID and auditorFact.xValue in [
                 pluginData.auditedFinancialStatementsDanish,
                 pluginData.auditedFinancialStatementsEnglish
             ]:
                 return
-    classFacts = []
-    facts = modelXbrl.factsByQname.get(pluginData.classOfReportingEntityQn)
-    if facts is not None:
+        classFacts = []
+        facts = val.modelXbrl.factsByQname.get(pluginData.classOfReportingEntityQn, set())
         for fact in facts:
-            if fact.xValid >= VALID:
-                if fact.xValue in [
-                    pluginData.reportingClassCLargeDanish,
-                    pluginData.reportingClassCLargeEnglish,
-                    pluginData.reportingClassCMediumDanish,
-                    pluginData.reportingClassCMediumEnglish,
-                    pluginData.reportingClassDDanish,
-                    pluginData.reportingClassDEnglish,
-                ]:
-                    classFacts.append(fact)
+            if fact.xValid >= VALID and fact.xValue in [
+                pluginData.reportingClassCLargeDanish,
+                pluginData.reportingClassCLargeEnglish,
+                pluginData.reportingClassCMediumDanish,
+                pluginData.reportingClassCMediumEnglish,
+                pluginData.reportingClassDDanish,
+                pluginData.reportingClassDEnglish
+            ]:
+                classFacts.append(fact)
         if len(classFacts) > 0:
             yield Validation.error(
                 codes='DBA.FR89',
@@ -1313,22 +1310,23 @@ def rule_fr91(
 ) -> Iterable[Validation]:
     """
     DBA.FR91: If the annual report contains information about both the general meeting date
-    (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfReport), the values must be the same.
-    """
-    approvalOfReportFact = None
-    generalMeetingFact = None
-    approvalFacts = (val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfReportQn, set()))
-    if len(approvalFacts) > 0:
-        approvalOfReportFact = next(iter(approvalFacts), None)
-    meetingFacts = val.modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
-    if len(meetingFacts) > 0:
-        generalMeetingFact = next(iter(meetingFacts), None)
-    if generalMeetingFact is not None and generalMeetingFact.xValid >= VALID and approvalOfReportFact is not None and approvalOfReportFact.xValid >= VALID and generalMeetingFact.xValue != approvalOfReportFact.xValue:
-        yield Validation.error(
-            codes='DBA.FR91',
-            msg=_("The annual report contains information about both the general meeting date (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfReport), the values must be the same."),
-            modelObject=[generalMeetingFact, approvalOfReportFact]
-        )
+    (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfAnnualReport), the values must be the same.
+    """
+    if pluginData.isAnnualReport(val.modelXbrl):
+        approvalOfReportFact = None
+        generalMeetingFact = None
+        approvalFacts = (val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfAnnualReportQn, set()))
+        if len(approvalFacts) > 0:
+            approvalOfReportFact = next(iter(approvalFacts), None)
+        meetingFacts = val.modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
+        if len(meetingFacts) > 0:
+            generalMeetingFact = next(iter(meetingFacts), None)
+        if generalMeetingFact is not None and generalMeetingFact.xValid >= VALID and approvalOfReportFact is not None and approvalOfReportFact.xValid >= VALID and generalMeetingFact.xValue != approvalOfReportFact.xValue:
+            yield Validation.error(
+                codes='DBA.FR91',
+                msg=_("The annual report contains information about both the general meeting date (gsd:DateOfGeneralMeeting) and the annual accounts meeting date (gsd:DateOfApprovalOfAnnualReport), the values must be the same."),
+                modelObject=[generalMeetingFact, approvalOfReportFact]
+            )
 
 
 @validation(

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/plugin/validate/DBA/rules/tm.py

@@ -239,16 +239,16 @@ def rule_tm29(
         **kwargs: Any,
 ) -> Iterable[Validation]:
     """
-    DBA.TM29: Either gsd:DateOfGeneralMeeting or gsd:DateOfApprovalOfReport must be specified
+    DBA.TM29: Either gsd:DateOfGeneralMeeting or gsd:DateOfApprovalOfAnnualReport must be specified
     """
-    modelXbrl = val.modelXbrl
-    meeting_facts = modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
-    approval_facts = modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfReportQn, set())
-    if len(meeting_facts) == 0 and len(approval_facts) == 0:
-        yield Validation.error(
-            'DBA.TM29',
-            _('Either DateOfGeneralMeeting or DateOfApprovalOfReport must be tagged in the document.')
-        )
+    if pluginData.isAnnualReport(val.modelXbrl):
+        meeting_facts = val.modelXbrl.factsByQname.get(pluginData.dateOfGeneralMeetingQn, set())
+        approval_facts = val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfAnnualReportQn, set())
+        if len(meeting_facts) == 0 and len(approval_facts) == 0:
+            yield Validation.error(
+                'DBA.TM29',
+                _('Either DateOfGeneralMeeting or DateOfApprovalOfReport must be tagged in the document.')
+            )
 
 
 @validation(
@@ -276,9 +276,19 @@ def rule_tm31(
         **kwargs: Any,
 ) -> Iterable[Validation]:
     """
-    DBA.TM31: gsd:DateOfApprovalOfReport must only be tagged once if tagged
-    """
-    return errorOnMultipleFacts(val.modelXbrl, pluginData.dateOfApprovalOfReportQn, 'DBA.TM31')
+    DBA.TM31: gsd:DateOfApprovalOfAnnualReport must only be tagged once if tagged
+    """
+    if pluginData.isAnnualReport(val.modelXbrl):
+        dateFacts = val.modelXbrl.factsByQname.get(pluginData.dateOfApprovalOfAnnualReportQn, set())
+        if len(dateFacts) > 1:
+            yield Validation.error(
+                'DBA.TM31',
+                _('{} must only be tagged once. {} facts were found.').format(
+                    pluginData.dateOfApprovalOfAnnualReportQn.localName,
+                    len(dateFacts)
+                ),
+                modelObject=dateFacts
+            )
 
 
 @validation(

{arelle_release-2.37.13 → arelle_release-2.37.14}/arelle/plugin/validate/NL/PluginValidationDataExtension.py

@@ -6,20 +6,23 @@ from __future__ import annotations
 from collections import defaultdict
 from dataclasses import dataclass
 from functools import lru_cache
+from pathlib import Path
 from typing import Any, TYPE_CHECKING, cast
 
 import regex as re
 from lxml.etree import _Comment, _ElementTree, _Entity, _ProcessingInstruction
 
 from arelle.FunctionIxt import ixtNamespaces
-from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelInlineFootnote, ModelUnit
+from arelle.ModelInstanceObject import ModelContext, ModelFact, ModelInlineFootnote, ModelUnit, ModelInlineFact
 from arelle.ModelObject import ModelObject
 from arelle.ModelValue import QName
 from arelle.ModelXbrl import ModelXbrl
 from arelle.typing import assert_type
 from arelle.utils.PluginData import PluginData
 from arelle.utils.validate.ValidationUtil import etreeIterWithDepth
+from arelle.XbrlConst import ixbrl11
 from arelle.XmlValidate import lexicalPatterns
+from arelle.XmlValidateConst import VALID
 
 XBRLI_IDENTIFIER_PATTERN = re.compile(r"^(?!00)\d{8}$")
 XBRLI_IDENTIFIER_SCHEMA = 'http://www.kvk.nl/kvk-id'
@@ -29,6 +32,25 @@ DISALLOWED_IXT_NAMESPACES = frozenset((
     ixtNamespaces["ixt v2"],
     ixtNamespaces["ixt v3"],
 ))
+UNTRANSFORMABLE_TYPES = frozenset((
+"anyURI",
+"base64Binary",
+"duration",
+"hexBinary",
+"NOTATION",
+"QName",
+"time",
+"token",
+"language",
+))
+STYLE_IX_HIDDEN_PATTERN = re.compile(r"(.*[^\w]|^)ix-hidden\s*:\s*([\w.-]+).*")
+
+ALLOWABLE_LANGUAGES = frozenset((
+    'nl',
+    'en',
+    'de',
+    'fr'
+))
 
 @dataclass(frozen=True)
 class ContextData:
@@ -38,10 +60,18 @@ class ContextData:
     contextsWithSegments: list[ModelContext | None]
 
 @dataclass(frozen=True)
-class FootnoteData:
-    factLangFootnotes: dict[ModelObject, set[str]]
+class HiddenElementsData:
+    eligibleForTransformHiddenFacts: set[ModelInlineFact]
+    hiddenFactsOutsideHiddenSection: set[ModelInlineFact]
+    requiredToDisplayFacts: set[ModelInlineFact]
+
+@dataclass(frozen=True)
+class InlineHTMLData:
     noMatchLangFootnotes: set[ModelInlineFootnote]
     orphanedFootnotes: set[ModelInlineFootnote]
+    tupleElements: set[tuple[Any]]
+    factLangFootnotes: dict[ModelInlineFootnote, set[str]]
+    fractionElements: set[Any]
 
 @dataclass
 class PluginValidationDataExtension(PluginData):
@@ -103,33 +133,83 @@ class PluginValidationDataExtension(PluginData):
         )
 
     @lru_cache(1)
-    def checkFootnotes(self, modelXbrl: ModelXbrl) -> FootnoteData:
+    def checkHiddenElements(self, modelXbrl: ModelXbrl) -> HiddenElementsData:
+        eligibleForTransformHiddenFacts = set()
+        hiddenEltIds = {}
+        hiddenFactsOutsideHiddenSection = set()
+        presentedHiddenEltIds = defaultdict(list)
+        requiredToDisplayFacts = set()
+        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            for ixHiddenElt in ixdsHtmlRootElt.iterdescendants(tag=ixNStag + "hidden"):
+                for tag in (ixNStag + "nonNumeric", ixNStag+"nonFraction"):
+                    for ixElt in ixHiddenElt.iterdescendants(tag=tag):
+                        if getattr(ixElt, "xValid", 0) >= VALID:
+                            if ixElt.concept.baseXsdType not in UNTRANSFORMABLE_TYPES and not ixElt.isNil:
+                                eligibleForTransformHiddenFacts.add(ixElt)
+                        if ixElt.id:
+                            hiddenEltIds[ixElt.id] = ixElt
+        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+            for ixElt in ixdsHtmlRootElt.getroottree().iterfind(".//{http://www.w3.org/1999/xhtml}*[@style]"):
+                styleValue = ixElt.get("style","")
+                hiddenFactRefMatch = STYLE_IX_HIDDEN_PATTERN.match(styleValue)
+                if hiddenFactRefMatch:
+                    hiddenFactRef = hiddenFactRefMatch.group(2)
+                    if hiddenFactRef not in hiddenEltIds:
+                        hiddenFactsOutsideHiddenSection.add(ixElt)
+                    else:
+                        presentedHiddenEltIds[hiddenFactRef].append(ixElt)
+        for hiddenEltId, ixElt in hiddenEltIds.items():
+            if (hiddenEltId not in presentedHiddenEltIds and
+                    getattr(ixElt, "xValid", 0) >= VALID and # may not be validated
+                    (ixElt.concept.baseXsdType in UNTRANSFORMABLE_TYPES or ixElt.isNil)):
+                requiredToDisplayFacts.add(ixElt)
+        return HiddenElementsData(
+            eligibleForTransformHiddenFacts=eligibleForTransformHiddenFacts,
+            hiddenFactsOutsideHiddenSection=hiddenFactsOutsideHiddenSection,
+            requiredToDisplayFacts=requiredToDisplayFacts,
+        )
+
+    @lru_cache(1)
+    def checkInlineHTMLElements(self, modelXbrl: ModelXbrl) -> InlineHTMLData:
         factLangs = self.factLangs(modelXbrl)
         footnotesRelationshipSet = modelXbrl.relationshipSet("XBRL-footnotes")
         factLangFootnotes = defaultdict(set)
-        orphanedFootnotes = set()
+        fractionElements = set()
         noMatchLangFootnotes = set()
-        for elts in modelXbrl.ixdsEltById.values():   # type: ignore[attr-defined]
-            for elt in elts:
-                if isinstance(elt, ModelInlineFootnote):
-                    if elt.textValue is not None:
-                        if not any(isinstance(rel.fromModelObject, ModelFact)
-                                   for rel in footnotesRelationshipSet.toModelObject(elt)):
-                            orphanedFootnotes.add(elt)
-                        if elt.xmlLang not in factLangs:
-                            noMatchLangFootnotes.add(elt)
-                        if elt.xmlLang is not None:
-                            for rel in footnotesRelationshipSet.toModelObject(elt):
-                                if rel.fromModelObject is not None:
-                                    fromObj = cast(ModelObject, rel.fromModelObject)
-                                    lang = cast(str, elt.xmlLang)
-                                    factLangFootnotes[fromObj].add(lang)
+        tupleElements = set()
+        orphanedFootnotes = set()
+        for ixdsHtmlRootElt in modelXbrl.ixdsHtmlElements:
+            ixNStag = getattr(ixdsHtmlRootElt.modelDocument, "ixNStag", ixbrl11)
+            ixTupleTag = ixNStag + "tuple"
+            ixFractionTag = ixNStag + "fraction"
+            for elts in modelXbrl.ixdsEltById.values():   # type: ignore[attr-defined]
+                for elt in elts:
+                    if isinstance(elt, ModelInlineFootnote):
+                        if elt.textValue is not None:
+                            if not any(isinstance(rel.fromModelObject, ModelFact)
+                                       for rel in footnotesRelationshipSet.toModelObject(elt)):
+                                orphanedFootnotes.add(elt)
+                            if elt.xmlLang not in factLangs:
+                                noMatchLangFootnotes.add(elt)
+                            if elt.xmlLang is not None:
+                                for rel in footnotesRelationshipSet.toModelObject(elt):
+                                    if rel.fromModelObject is not None:
+                                        fromObj = cast(ModelObject, rel.fromModelObject)
+                                        lang = cast(str, elt.xmlLang)
+                                        factLangFootnotes[fromObj].add(lang)
+                    if elt.tag == ixTupleTag:
+                        tupleElements.add(elt)
+                    if elt.tag == ixFractionTag:
+                        fractionElements.add(elt)
         factLangFootnotes.default_factory = None
         assert_type(factLangFootnotes, defaultdict[ModelObject, set[str]])
-        return FootnoteData(
-            factLangFootnotes=cast(dict[ModelObject, set[str]], factLangFootnotes),
+        return InlineHTMLData(
+            factLangFootnotes=cast(dict[ModelInlineFootnote, set[str]], factLangFootnotes),
+            fractionElements=fractionElements,
             noMatchLangFootnotes=noMatchLangFootnotes,
             orphanedFootnotes=orphanedFootnotes,
+            tupleElements=tupleElements,
         )
 
     @lru_cache(1)
@@ -164,14 +244,57 @@ class PluginValidationDataExtension(PluginData):
     def getContextsWithSegments(self, modelXbrl: ModelXbrl) -> list[ModelContext | None]:
         return self.checkContexts(modelXbrl).contextsWithSegments
 
-    def getFactLangFootnotes(self, modelXbrl: ModelXbrl) -> dict[ModelObject, set[str]]:
-        return self.checkFootnotes(modelXbrl).factLangFootnotes
+    def getEligibleForTransformHiddenFacts(self, modelXbrl: ModelXbrl) -> set[ModelInlineFact]:
+        return self.checkHiddenElements(modelXbrl).eligibleForTransformHiddenFacts
+
+    def getFactLangFootnotes(self, modelXbrl: ModelXbrl) -> dict[ModelInlineFootnote, set[str]]:
+        return self.checkInlineHTMLElements(modelXbrl).factLangFootnotes
+
+    def getFractionElements(self, modelXbrl: ModelXbrl) -> set[Any]:
+        return self.checkInlineHTMLElements(modelXbrl).fractionElements
+
+    def getHiddenFactsOutsideHiddenSection(self, modelXbrl: ModelXbrl) -> set[ModelInlineFact]:
+        return self.checkHiddenElements(modelXbrl).hiddenFactsOutsideHiddenSection
+
+    @lru_cache(1)
+    def getFilenameAllowedCharactersPattern(self) -> re.Pattern[str]:
+        return re.compile(
+            r"^[\w\.-]*$",
+            flags=re.ASCII
+        )
+
+    @lru_cache(1)
+    def getFilenameFormatPattern(self) -> re.Pattern[str]:
+        return re.compile(
+            r"^(?<base>[^-]*)"
+            r"-(?<year>\d{4})-(?<month>0[1-9]|1[012])-(?<day>0?[1-9]|[12][0-9]|3[01])"
+            r"-(?<lang>[^-]*)"
+            r"\.(?<extension>html|htm|xhtml)$",
+            flags=re.ASCII
+        )
+
+    @lru_cache(1)
+    def getFilenameParts(self, filename: str) -> dict[str, Any] | None:
+        match = self.getFilenameFormatPattern().match(filename)
+        if match:
+            return match.groupdict()
+        return None
+
+    @lru_cache(1)
+    def getIxdsDocBasenames(self, modelXbrl: ModelXbrl) -> set[str]:
+        return set(Path(url).name for url in modelXbrl.ixdsDocUrls)
 
     def getNoMatchLangFootnotes(self, modelXbrl: ModelXbrl) -> set[ModelInlineFootnote]:
-        return self.checkFootnotes(modelXbrl).noMatchLangFootnotes
+        return self.checkInlineHTMLElements(modelXbrl).noMatchLangFootnotes
 
     def getOrphanedFootnotes(self, modelXbrl: ModelXbrl) -> set[ModelInlineFootnote]:
-        return self.checkFootnotes(modelXbrl).orphanedFootnotes
+        return self.checkInlineHTMLElements(modelXbrl).orphanedFootnotes
+
+    def getRequiredToDisplayFacts(self, modelXbrl: ModelXbrl) -> set[ModelInlineFact]:
+        return self.checkHiddenElements(modelXbrl).requiredToDisplayFacts
+
+    def getTupleElements(self, modelXbrl: ModelXbrl) -> set[tuple[Any]]:
+        return self.checkInlineHTMLElements(modelXbrl).tupleElements
 
     @lru_cache(1)
     def getReportXmlLang(self, modelXbrl: ModelXbrl) -> str | None:
@@ -188,6 +311,11 @@ class PluginValidationDataExtension(PluginData):
                         firstRootmostXmlLangDepth = depth
         return reportXmlLang
 
+    @lru_cache(1)
+    def isFilenameValidCharacters(self, filename: str) -> bool:
+        match = self.getFilenameAllowedCharactersPattern().match(filename)
+        return match is not None
+
     @lru_cache(1)
     def unitsByDocument(self, modelXbrl: ModelXbrl) -> dict[str, list[ModelUnit]]:
         unitsByDocument = defaultdict(list)