arelle-release 2.37.61__py3-none-any.whl → 2.37.62__py3-none-any.whl

arelle/plugin/validate/EDINET/PluginValidationDataExtension.py

@@ -16,8 +16,9 @@ from typing import Callable, Hashable, Iterable, cast
 import os
 import regex
 
+from arelle import XbrlConst
 from arelle.LinkbaseType import LinkbaseType
-from arelle.ModelDocument import Type as ModelDocumentType, ModelDocument
+from arelle.ModelDocument import Type as ModelDocumentType, ModelDocument, load as modelDocumentLoad
 from arelle.ModelDtsObject import ModelConcept
 from arelle.ModelInstanceObject import ModelFact, ModelUnit, ModelContext, ModelInlineFact
 from arelle.ModelObject import ModelObject
@@ -32,12 +33,14 @@ from arelle.typing import TypeGetText
 from arelle.utils.PluginData import PluginData
 from .Constants import xhtmlDtdExtension, PROHIBITED_HTML_TAGS, PROHIBITED_HTML_ATTRIBUTES
 from .ControllerPluginData import ControllerPluginData
-from .CoverPageRequirements import CoverPageRequirements, COVER_PAGE_ITEM_LOCAL_NAMES
+from .CoverItemRequirements import CoverItemRequirements
+from .DeiRequirements import DeiRequirements, DEI_LOCAL_NAMES
 from .FilingFormat import FilingFormat, FILING_FORMATS
 from .FormType import FormType
 from .ManifestInstance import ManifestInstance
+from .ReportFolderType import HTML_EXTENSIONS
 from .Statement import Statement, STATEMENTS, BalanceSheet, StatementInstance, StatementType
-from .UploadContents import UploadContents
+from .UploadContents import UploadContents, UploadPathInfo
 
 _: TypeGetText
 
@@ -57,6 +60,7 @@ STANDARD_TAXONOMY_URL_PREFIXES = frozenset((
     'https://www.w3.org/1999/xlink'
 ))
 
+
 @dataclass(frozen=True)
 class UriReference:
     attributeName: str
@@ -67,27 +71,41 @@ class UriReference:
 
 @dataclass
 class PluginValidationDataExtension(PluginData):
+    # Namespaces
+    jpcrpEsrNamespace: str
+    jpcrpNamespace: str
+    jpctlNamespace: str
+    jpcrpSbrNamespace: str
+    jpdeiNamespace: str
+    jpigpNamespace: str
+    jplvhNamespace: str
+    jppfsNamespace: str
+    jpspsEsrNamespace: str
+    jpspsSbrNamespace: str
+    jpspsNamespace: str
+    jptoiNamespace: str
+    jptooPstNamespace: str
+    jptooToaNamespace: str
+    jptooTonNamespace: str
+    jptooTorNamespace: str
+    jptooWtoNamespace: str
+
     accountingStandardsDeiQn: QName
     assetsIfrsQn: QName
     consolidatedOrNonConsolidatedAxisQn: QName
     documentTypeDeiQn: QName
     jpcrpEsrFilingDateCoverPageQn: QName
-    jpcrpEsrNamespace: str
     jpcrpFilingDateCoverPageQn: QName
-    jpcrpNamespace: str
-    jpdeiNamespace: str
-    jpigpNamespace: str
-    jppfsNamespace: str
     jpspsFilingDateCoverPageQn: QName
-    jpspsNamespace: str
     nonConsolidatedMemberQn: QName
     ratioOfFemaleDirectorsAndOtherOfficersQn: QName
 
-    contextIdPattern: regex.Pattern[str]
-    coverPageItems: tuple[QName, ...]
-    coverPageRequirementsPath: Path
+    coverItemRequirementsPath: Path
     coverPageTitleQns: tuple[QName, ...]
+    deiItems: tuple[QName, ...]
+    deiRequirementsPath: Path
 
+    _namespaceMap: dict[str, str]
     _uriReferences: list[UriReference]
 
     def __init__(self, name: str, validateXbrl: ValidateXbrl):
@@ -96,10 +114,40 @@ class PluginValidationDataExtension(PluginData):
         # Namespaces
         self.jpcrpEsrNamespace = "http://disclosure.edinet-fsa.go.jp/taxonomy/jpcrp-esr/2024-11-01/jpcrp-esr_cor"
         self.jpcrpNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jpcrp/2024-11-01/jpcrp_cor'
+        self.jpcrpSbrNamespace = "http://disclosure.edinet-fsa.go.jp/taxonomy/jpcrp-sbr/2024-11-01/jpcrp-sbr_cor"
+        self.jpctlNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jpctl/2024-11-01/jpctl_cor'
         self.jpdeiNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jpdei/2013-08-31/jpdei_cor'
         self.jpigpNamespace = "http://disclosure.edinet-fsa.go.jp/taxonomy/jpigp/2024-11-01/jpigp_cor"
+        self.jplvhNamespace = "http://disclosure.edinet-fsa.go.jp/taxonomy/jplvh/2024-11-01/jplvh_cor"
         self.jppfsNamespace = "http://disclosure.edinet-fsa.go.jp/taxonomy/jppfs/2024-11-01/jppfs_cor"
+        self.jpspsEsrNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jpsps-esr/2024-11-01/jpsps-esr_cor'
+        self.jpspsSbrNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jpsps-sbr/2024-11-01/jpsps-sbr_cor'
         self.jpspsNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jpsps/2024-11-01/jpsps_cor'
+        self.jptoiNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jptoi/2024-11-01/jptoi_cor'
+        self.jptooPstNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jptoo-pst/2024-11-01/jptoo-pst_cor'
+        self.jptooToaNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jptoo-toa/2024-11-01/jptoo-toa_cor'
+        self.jptooTonNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jptoo-ton/2024-11-01/jptoo-ton_cor'
+        self.jptooTorNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jptoo-tor/2024-11-01/jptoo-tor_cor'
+        self.jptooWtoNamespace = 'http://disclosure.edinet-fsa.go.jp/taxonomy/jptoo-wto/2024-11-01/jptoo-wto_cor'
+        self._namespaceMap = {
+            "jpcrp-esr_cor": self.jpcrpEsrNamespace,
+            "jpcrp-sbr_cor": self.jpcrpSbrNamespace,
+            "jpcrp_cor": self.jpcrpNamespace,
+            "jpctl_cor": self.jpctlNamespace,
+            "jpdei_cor": self.jpdeiNamespace,
+            "jpigp_cor": self.jpigpNamespace,
+            "jplvh_cor": self.jplvhNamespace,
+            "jppfs_cor": self.jppfsNamespace,
+            "jpsps_cor": self.jpspsNamespace,
+            "jpsps-esr_cor": self.jpspsEsrNamespace,
+            "jpsps-sbr_cor": self.jpspsSbrNamespace,
+            "jptoi_cor": self.jptoiNamespace,
+            "jptoo-pst_cor": self.jptooPstNamespace,
+            "jptoo-toa_cor": self.jptooToaNamespace,
+            "jptoo-ton_cor": self.jptooTonNamespace,
+            "jptoo-tor_cor": self.jptooPstNamespace,
+            "jptoo-wto_cor": self.jptooWtoNamespace,
+        }
 
         # QNames
         self.accountingStandardsDeiQn = qname(self.jpdeiNamespace, 'AccountingStandardsDEI')
@@ -113,18 +161,18 @@ class PluginValidationDataExtension(PluginData):
         self.nonConsolidatedMemberQn = qname(self.jppfsNamespace, "NonConsolidatedMember")
         self.ratioOfFemaleDirectorsAndOtherOfficersQn = qname(self.jpcrpNamespace, "RatioOfFemaleDirectorsAndOtherOfficers")
 
-        self.contextIdPattern = regex.compile(r'(Prior[1-9]Year|CurrentYear|Prior[1-9]Interim|Interim)(Duration|Instant)')
-        self.coverPageItems = tuple(
-            qname(self.jpdeiNamespace, localName)
-            for localName in COVER_PAGE_ITEM_LOCAL_NAMES
-        )
-        self.coverPageRequirementsPath = Path(__file__).parent / "resources" / "cover-page-requirements.csv"
+        self.coverItemRequirementsPath = Path(__file__).parent / "resources" / "cover-item-requirements.json"
         self.coverPageTitleQns = (
             qname(self.jpspsNamespace, "DocumentTitleAnnualSecuritiesReportCoverPage"),
             qname(self.jpcrpNamespace, "DocumentTitleCoverPage"),
             qname(self.jpcrpEsrNamespace, "DocumentTitleCoverPage"),
             qname(self.jpspsNamespace, "DocumentTitleCoverPage"),
         )
+        self.deiItems = tuple(
+            qname(self.jpdeiNamespace, localName)
+            for localName in DEI_LOCAL_NAMES
+        )
+        self.deiRequirementsPath = Path(__file__).parent / "resources" / "dei-requirements.csv"
 
         self._uriReferences = []
         self._initialize(validateXbrl.modelXbrl)
@@ -148,27 +196,62 @@ class PluginValidationDataExtension(PluginData):
         contextIsConsolidated = memberValue != self.nonConsolidatedMemberQn
         return bool(statement.isConsolidated == contextIsConsolidated)
 
+    def _initializeDocument(self, uri: str, modelDocument: ModelDocument, modelXbrl: ModelXbrl) -> None:
+        docPath = Path(uri)
+        basePath = Path(str(modelXbrl.fileSource.basefile))
+        if not docPath.is_relative_to(basePath):
+            return
+        controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
+        controllerPluginData.addUsedFilepath(docPath.relative_to(basePath))
+        for elt, name, value in self.getUriAttributeValues(modelDocument):
+            self._uriReferences.append(UriReference(
+                attributeName=name,
+                attributeValue=value,
+                document=modelDocument,
+                element=elt,
+            ))
+            fullPath = (Path(modelDocument.uri).parent / value).resolve()
+            if fullPath.is_relative_to(basePath):
+                fileSourcePath = fullPath.relative_to(basePath)
+                controllerPluginData.addUsedFilepath(fileSourcePath)
+            referenceUri = str(fullPath)
+            if (
+                    fullPath.suffix in HTML_EXTENSIONS and
+                    referenceUri not in modelXbrl.urlDocs and
+                    modelXbrl.fileSource.exists(referenceUri)
+            ):
+                referenceModelDocument = modelDocumentLoad(
+                    modelXbrl,
+                    referenceUri,
+                    referringElement=elt
+                )
+                if referenceModelDocument is not None:
+                    self._initializeDocument(referenceUri, referenceModelDocument, modelXbrl)
+
     def _initialize(self, modelXbrl: ModelXbrl) -> None:
         if not isinstance(modelXbrl.fileSource.basefile, str):
             return
+        # Additional documents may be loaded, so make a copy to iterate over.
+        urlDocs = list(modelXbrl.urlDocs.items())
+        for uri, modelDocument in urlDocs:
+            self._initializeDocument(uri, modelDocument, modelXbrl)
+
+    def addToTableOfContents(self, modelXbrl: ModelXbrl) -> None:
+        uploadContents = self.getUploadContents(modelXbrl)
+        if uploadContents is None:
+            return
         controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
-        basePath = Path(modelXbrl.fileSource.basefile)
-        for uri, doc in modelXbrl.urlDocs.items():
-            docPath = Path(uri)
-            if not docPath.is_relative_to(basePath):
+        tocBuilder = controllerPluginData.getTableOfContentsBuilder()
+        for modelDocument in modelXbrl.urlDocs.values():
+            path = Path(modelDocument.uri)
+            if modelDocument.type != ModelDocumentType.INLINEXBRL:
                 continue
-            controllerPluginData.addUsedFilepath(docPath.relative_to(basePath))
-            for elt, name, value in self.getUriAttributeValues(doc):
-                self._uriReferences.append(UriReference(
-                    attributeName=name,
-                    attributeValue=value,
-                    document=doc,
-                    element=elt,
-                ))
-                fullPath = Path(doc.uri).parent / value
-                if fullPath.is_relative_to(basePath):
-                    fileSourcePath = fullPath.relative_to(basePath)
-                    controllerPluginData.addUsedFilepath(fileSourcePath)
+            pathInfo = uploadContents.uploadPathsByFullPath.get(path)
+            if pathInfo is not None and not pathInfo.isCoverPage:
+                tocBuilder.addDocument(modelDocument)
+
+    def qname(self, prefix: str, localName: str) -> QName:
+        return qname(self._namespaceMap[prefix], localName)
 
     @lru_cache(1)
     def isCorporateForm(self, modelXbrl: ModelXbrl) -> bool:
@@ -202,10 +285,22 @@ class PluginValidationDataExtension(PluginData):
         extensionConcepts = []
         for concepts in modelXbrl.nameConcepts.values():
             for concept in concepts:
-                if self.isExtensionUri(concept.qname.namespaceURI, modelXbrl):
+                if self.isExtensionUri(concept.document.uri, modelXbrl):
                     extensionConcepts.append(concept)
         return extensionConcepts
 
+    @lru_cache(1)
+    def getUsedConcepts(self, modelXbrl: ModelXbrl) -> set[ModelConcept]:
+        """
+        Returns a set of concepts used on facts and in explicit dimensions
+        """
+        usedConcepts = {fact.concept for fact in modelXbrl.facts if fact.concept is not None}
+        for context in modelXbrl.contextsInUse:
+            for dim in context.scenDimValues.values():
+                if dim.isExplicit:
+                    usedConcepts.update([dim.dimension, dim.member])
+        return usedConcepts
+
     def getBalanceSheets(self, modelXbrl: ModelXbrl, statement: Statement) -> list[BalanceSheet]:
         """
         :return: Balance sheet data for each context/unit pairing the given statement.
@@ -261,9 +356,60 @@ class PluginValidationDataExtension(PluginData):
             )
         return balanceSheets
 
-    def getCoverPageRequirements(self, modelXbrl: ModelXbrl) -> CoverPageRequirements:
+    @lru_cache(1)
+    def getCoverItemRequirements(self, modelXbrl: ModelXbrl) -> list[QName] | None:
+        manifestInstance = self.getManifestInstance(modelXbrl)
+        if manifestInstance is None:
+            return None
+        if any(e is not None and e.startswith('EDINET.EC5800E') for e in modelXbrl.errors):
+            # Manifest TOC parsing failed, so cannot determine cover items.
+            return None
+        assert len(manifestInstance.tocItems) == 1, _("Only one TOC item should be associated with this instance.")
+        roleUri = manifestInstance.tocItems[0].extrole
+        roleUri = roleUri.replace("_std_", "_")
+        controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
+        coverItemRequirements = controllerPluginData.getCoverItemRequirements(self.coverItemRequirementsPath)
+        coverItems = coverItemRequirements.get(roleUri)
+        return [
+            self.qname(prefix, localName)
+            for prefix, localName in
+            [name.split(':') for name in coverItems]
+        ]
+
+    @lru_cache(1)
+    def getCoverItems(self, modelXbrl: ModelXbrl) -> frozenset[QName]:
+        controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
+        coverItemRequirements = controllerPluginData.getCoverItemRequirements(self.coverItemRequirementsPath)
+        coverItems = coverItemRequirements.all()
+        return frozenset(
+            self.qname(prefix, localName)
+            for prefix, localName in
+            [name.split(':') for name in coverItems]
+        )
+
+    def getDeiRequirements(self, modelXbrl: ModelXbrl) -> DeiRequirements:
         controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
-        return controllerPluginData.getCoverPageRequirements(self.coverPageRequirementsPath, self.coverPageItems, FILING_FORMATS)
+        return controllerPluginData.getDeiRequirements(self.deiRequirementsPath, self.deiItems, FILING_FORMATS)
+
+    @lru_cache(1)
+    def getExtensionSchemas(self, modelXbrl: ModelXbrl) -> dict[str, UploadPathInfo]:
+        namespacePathInfos: dict[str, UploadPathInfo] = {}
+        uploadContents = self.getUploadContents(modelXbrl)
+        if uploadContents is None:
+            return namespacePathInfos
+        for modelDocument in modelXbrl.urlDocs.values():
+            if modelDocument.type != ModelDocumentType.SCHEMA:
+                continue # Not a schema
+            if modelDocument.targetNamespace is None:
+                continue # No target namespace
+            if not self.isExtensionUri(modelDocument.uri, modelXbrl):
+                continue # Not an extension schema
+            path = Path(modelDocument.uri)
+            pathInfo = uploadContents.uploadPathsByFullPath.get(path)
+            if pathInfo is None or pathInfo.reportFolderType is None:
+                continue # Not part of the filing, error will be caught elsewhere
+            namespacePathInfos[modelDocument.targetNamespace] = pathInfo
+        return namespacePathInfos
 
     def getProblematicTextBlocks(self, modelXbrl: ModelXbrl) -> list[ModelInlineFact]:
         problematicTextBlocks: list[ModelInlineFact] = []
@@ -356,10 +502,9 @@ class PluginValidationDataExtension(PluginData):
         # values assigned to the various FilingFormats. This may only be by coincidence or convention.
         # If it doesn't end up being reliable, we may need to find another way to identify the form.
         # For example, by disclosure system selection or CLI argument.
-        documentTitleFacts = []
+        documentTitleFacts: list[ModelFact] = []
         for qname in self.coverPageTitleQns:
-            for fact in self.iterValidNonNilFacts(modelXbrl, qname):
-                documentTitleFacts.append(fact)
+            documentTitleFacts.extend(self.iterValidNonNilFacts(modelXbrl, qname))
         formTypes = self.getFormTypes(modelXbrl)
         filingFormats = []
         for filingFormatIndex, filingFormat in enumerate(FILING_FORMATS):
@@ -367,7 +512,7 @@ class PluginValidationDataExtension(PluginData):
                 continue
             prefixes = {taxonomy.value for taxonomy in filingFormat.taxonomies}
             if not any(
-                str(fact.xValue).startswith(filingFormat.documentType.value) and
+                str(fact.xValue).strip().startswith(filingFormat.documentType.value) and
                 fact.concept.qname.prefix.split('_')[0] in prefixes
                 for fact in documentTitleFacts
             ):
@@ -378,7 +523,7 @@ class PluginValidationDataExtension(PluginData):
                 "arelle:NoMatchingEdinetFormat",
                 _("No matching EDINET filing formats could be identified based on form "
                   "type (%(formTypes)s) and title."),
-                formTypes=formTypes,
+                formTypes=", ".join(t.value for t in formTypes),
                 modelObject=documentTitleFacts,
             )
             return None
@@ -451,6 +596,20 @@ class PluginValidationDataExtension(PluginData):
                 elts.append(elt)
         return elts
 
+    def getStandardTaxonomyExtensionLinks(self, linkbaseType: LinkbaseType, modelXbrl: ModelXbrl) -> list[ModelObject]:
+        elts: list[ModelObject] = []
+        for modelDocument in modelXbrl.urlDocs.values():
+            if self.isStandardTaxonomyUrl(modelDocument.uri, modelXbrl) or not modelDocument.type == ModelDocumentType.SCHEMA:
+                continue
+            rootElt = modelDocument.xmlRootElement
+            for elt in rootElt.iterdescendants(XbrlConst.qnLinkLinkbaseRef.clarkNotation):
+                uri = elt.attrib.get(XbrlConst.qnXlinkHref.clarkNotation)
+                role = elt.attrib.get(XbrlConst.qnXlinkRole.clarkNotation)
+                if not role == linkbaseType.getRefUri() or self.isExtensionUri(uri, modelXbrl):
+                    continue
+                elts.append(elt)
+        return elts
+
     def getUploadContents(self, modelXbrl: ModelXbrl) -> UploadContents | None:
         controllerPluginData = ControllerPluginData.get(modelXbrl.modelManager.cntlr, self.name)
         return controllerPluginData.getUploadContents()
@@ -458,9 +617,16 @@ class PluginValidationDataExtension(PluginData):
     @lru_cache(1)
     def getUriAttributeValues(self, modelDocument: ModelDocument) -> list[tuple[ModelObject, str, str]]:
         results: list[tuple[ModelObject, str, str]] = []
-        if modelDocument.type not in (ModelDocumentType.INLINEXBRL, ModelDocumentType.HTML):
+        modelDocumentType = modelDocument.type
+        # Normal document parsing does not assign the HTML type to HTML files.
+        # Use ModelDocumentType.identify to check for HTML files.
+        if modelDocumentType == ModelDocumentType.UnknownXML:
+            modelDocumentType = ModelDocumentType.identify(modelDocument.modelXbrl.fileSource, modelDocument.uri)
+        if modelDocumentType not in (ModelDocumentType.INLINEXBRL, ModelDocumentType.HTML):
             return results
         for elt in modelDocument.xmlRootElement.iter():
+            if not isinstance(elt, ModelObject):
+                continue
             for name in htmlEltUriAttrs.get(elt.localName, ()):
                 value = elt.get(name)
                 if value is not None:

arelle/plugin/validate/EDINET/ReportFolderType.py

@@ -7,6 +7,10 @@ from enum import Enum
 from functools import cached_property, lru_cache
 from pathlib import Path
 
+from regex import Pattern
+
+from . import Constants
+
 
 class ReportFolderType(Enum):
     ATTACH_DOC = "AttachDoc"
@@ -30,6 +34,10 @@ class ReportFolderType(Enum):
     def isAttachment(self) -> bool:
         return "Attach" in self.value
 
+    @cached_property
+    def ixbrlFilenamePatterns(self) -> list[Pattern[str]]:
+        return IXBRL_FILENAME_PATTERNS.get(self, [])
+
     @cached_property
     def manifestName(self) -> str:
         return f'manifest_{self.value}.xml'
@@ -38,10 +46,22 @@ class ReportFolderType(Enum):
     def manifestPath(self) -> Path:
         return self.xbrlDirectory / self.manifestName
 
+    @cached_property
+    def namespaceUriPatterns(self) -> list[Pattern[str]]:
+        return NAMESPACE_URI_PATTERNS.get(self, [])
+
+    @cached_property
+    def prefixPatterns(self) -> list[Pattern[str]]:
+        return PREFIX_PATTERNS.get(self, [])
+
     @cached_property
     def xbrlDirectory(self) -> Path:
         return Path('XBRL') / str(self.value)
 
+    @cached_property
+    def xbrlFilenamePatterns(self) -> list[Pattern[str]]:
+        return XBRL_FILENAME_PATTERNS.get(self, [])
+
     @lru_cache(1)
     def getValidExtensions(self, isAmendment: bool, isSubdirectory: bool) -> frozenset[str] | None:
         if self.extensionCategory is None:
@@ -99,3 +119,44 @@ VALID_EXTENSIONS = {
         },
     },
 }
+
+IXBRL_FILENAME_PATTERNS = {
+    ReportFolderType.AUDIT_DOC: [
+        Constants.AUDIT_IXBRL_FILENAME_PATTERN,
+        Constants.AUDIT_LINKBASE_FILENAME_PATTERN,
+        Constants.AUDIT_SCHEMA_FILENAME_PATTERN,
+    ],
+    ReportFolderType.PUBLIC_DOC: [
+        Constants.REPORT_COVER_FILENAME_PATTERN,
+        Constants.REPORT_IXBRL_FILENAME_PATTERN,
+        Constants.REPORT_LINKBASE_FILENAME_PATTERN,
+        Constants.REPORT_SCHEMA_FILENAME_PATTERN,
+    ]
+}
+
+NAMESPACE_URI_PATTERNS = {
+    ReportFolderType.AUDIT_DOC: [
+        Constants.AUDIT_NAMESPACE_URI_PATTERN,
+    ],
+    ReportFolderType.PUBLIC_DOC: [
+        Constants.REPORT_NAMESPACE_URI_PATTERN,
+    ],
+}
+
+PREFIX_PATTERNS = {
+    ReportFolderType.AUDIT_DOC: [
+        Constants.AUDIT_PREFIX_PATTERN,
+    ],
+    ReportFolderType.PUBLIC_DOC: [
+        Constants.REPORT_PREFIX_PATTERN,
+    ],
+}
+
+XBRL_FILENAME_PATTERNS = {
+    ReportFolderType.AUDIT_DOC: [
+        Constants.AUDIT_XBRL_FILENAME_PATTERN,
+    ],
+    ReportFolderType.PUBLIC_DOC: [
+        Constants.REPORT_XBRL_FILENAME_PATTERN,
+    ],
+}