# {py:mod}`arelle.ModelFormulaObject`

```{py:module} arelle.ModelFormulaObject
```

```{autodoc2-docstring} arelle.ModelFormulaObject
:allowtitles:
```

## Module Contents

### Classes

````{list-table}
:class: autosummary longtable
:align: left

* - {py:obj}`FormulaOptions <arelle.ModelFormulaObject.FormulaOptions>`
  - ```{autodoc2-docstring} arelle.ModelFormulaObject.FormulaOptions
    :summary:
    ```
* - {py:obj}`Trace <arelle.ModelFormulaObject.Trace>`
  - ```{autodoc2-docstring} arelle.ModelFormulaObject.Trace
    :summary:
    ```
* - {py:obj}`ModelFormulaResource <arelle.ModelFormulaObject.ModelFormulaResource>`
  -
* - {py:obj}`ModelAssertionSet <arelle.ModelFormulaObject.ModelAssertionSet>`
  -
* - {py:obj}`ModelVariableSet <arelle.ModelFormulaObject.ModelVariableSet>`
  -
* - {py:obj}`ModelFormulaRules <arelle.ModelFormulaObject.ModelFormulaRules>`
  - ```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules
    :summary:
    ```
* - {py:obj}`ModelFormula <arelle.ModelFormulaObject.ModelFormula>`
  -
* - {py:obj}`ModelTuple <arelle.ModelFormulaObject.ModelTuple>`
  -
* - {py:obj}`ModelVariableSetAssertion <arelle.ModelFormulaObject.ModelVariableSetAssertion>`
  -
* - {py:obj}`ModelExistenceAssertion <arelle.ModelFormulaObject.ModelExistenceAssertion>`
  -
* - {py:obj}`ModelValueAssertion <arelle.ModelFormulaObject.ModelValueAssertion>`
  -
* - {py:obj}`ModelConsistencyAssertion <arelle.ModelFormulaObject.ModelConsistencyAssertion>`
  -
* - {py:obj}`ModelParameter <arelle.ModelFormulaObject.ModelParameter>`
  -
* - {py:obj}`ModelInstance <arelle.ModelFormulaObject.ModelInstance>`
  -
* - {py:obj}`ModelVariable <arelle.ModelFormulaObject.ModelVariable>`
  -
* - {py:obj}`ModelFactVariable <arelle.ModelFormulaObject.ModelFactVariable>`
  -
* - {py:obj}`ModelGeneralVariable <arelle.ModelFormulaObject.ModelGeneralVariable>`
  -
* - {py:obj}`ModelPrecondition <arelle.ModelFormulaObject.ModelPrecondition>`
  -
* - {py:obj}`ModelFilter <arelle.ModelFormulaObject.ModelFilter>`
  -
* - {py:obj}`ModelTestFilter <arelle.ModelFormulaObject.ModelTestFilter>`
  -
* - {py:obj}`ModelPatternFilter <arelle.ModelFormulaObject.ModelPatternFilter>`
  -
* - {py:obj}`ModelAspectCover <arelle.ModelFormulaObject.ModelAspectCover>`
  -
* - {py:obj}`ModelBooleanFilter <arelle.ModelFormulaObject.ModelBooleanFilter>`
  -
* - {py:obj}`ModelAndFilter <arelle.ModelFormulaObject.ModelAndFilter>`
  -
* - {py:obj}`ModelOrFilter <arelle.ModelFormulaObject.ModelOrFilter>`
  -
* - {py:obj}`ModelConceptName <arelle.ModelFormulaObject.ModelConceptName>`
  -
* - {py:obj}`ModelConceptPeriodType <arelle.ModelFormulaObject.ModelConceptPeriodType>`
  -
* - {py:obj}`ModelConceptBalance <arelle.ModelFormulaObject.ModelConceptBalance>`
  -
* - {py:obj}`ModelConceptFilterWithQnameExpression <arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression>`
  -
* - {py:obj}`ModelConceptCustomAttribute <arelle.ModelFormulaObject.ModelConceptCustomAttribute>`
  -
* - {py:obj}`ModelConceptDataType <arelle.ModelFormulaObject.ModelConceptDataType>`
  -
* - {py:obj}`ModelConceptSubstitutionGroup <arelle.ModelFormulaObject.ModelConceptSubstitutionGroup>`
  -
* - {py:obj}`ModelConceptRelation <arelle.ModelFormulaObject.ModelConceptRelation>`
  -
* - {py:obj}`ModelEntityIdentifier <arelle.ModelFormulaObject.ModelEntityIdentifier>`
  -
* - {py:obj}`ModelEntitySpecificIdentifier <arelle.ModelFormulaObject.ModelEntitySpecificIdentifier>`
  -
* - {py:obj}`ModelEntityScheme <arelle.ModelFormulaObject.ModelEntityScheme>`
  -
* - {py:obj}`ModelEntityRegexpIdentifier <arelle.ModelFormulaObject.ModelEntityRegexpIdentifier>`
  -
* - {py:obj}`ModelEntityRegexpScheme <arelle.ModelFormulaObject.ModelEntityRegexpScheme>`
  -
* - {py:obj}`ModelGeneral <arelle.ModelFormulaObject.ModelGeneral>`
  -
* - {py:obj}`ModelMatchFilter <arelle.ModelFormulaObject.ModelMatchFilter>`
  -
* - {py:obj}`ModelPeriod <arelle.ModelFormulaObject.ModelPeriod>`
  -
* - {py:obj}`ModelDateTimeFilter <arelle.ModelFormulaObject.ModelDateTimeFilter>`
  -
* - {py:obj}`ModelPeriodStart <arelle.ModelFormulaObject.ModelPeriodStart>`
  -
* - {py:obj}`ModelPeriodEnd <arelle.ModelFormulaObject.ModelPeriodEnd>`
  -
* - {py:obj}`ModelPeriodInstant <arelle.ModelFormulaObject.ModelPeriodInstant>`
  -
* - {py:obj}`ModelForever <arelle.ModelFormulaObject.ModelForever>`
  -
* - {py:obj}`ModelInstantDuration <arelle.ModelFormulaObject.ModelInstantDuration>`
  -
* - {py:obj}`MemberModel <arelle.ModelFormulaObject.MemberModel>`
  - ```{autodoc2-docstring} arelle.ModelFormulaObject.MemberModel
    :summary:
    ```
* - {py:obj}`ModelExplicitDimension <arelle.ModelFormulaObject.ModelExplicitDimension>`
  -
* - {py:obj}`ModelTypedDimension <arelle.ModelFormulaObject.ModelTypedDimension>`
  -
* - {py:obj}`ModelRelativeFilter <arelle.ModelFormulaObject.ModelRelativeFilter>`
  -
* - {py:obj}`ModelSegmentFilter <arelle.ModelFormulaObject.ModelSegmentFilter>`
  -
* - {py:obj}`ModelScenarioFilter <arelle.ModelFormulaObject.ModelScenarioFilter>`
  -
* - {py:obj}`ModelAncestorFilter <arelle.ModelFormulaObject.ModelAncestorFilter>`
  -
* - {py:obj}`ModelParentFilter <arelle.ModelFormulaObject.ModelParentFilter>`
  -
* - {py:obj}`ModelLocationFilter <arelle.ModelFormulaObject.ModelLocationFilter>`
  -
* - {py:obj}`ModelSiblingFilter <arelle.ModelFormulaObject.ModelSiblingFilter>`
  -
* - {py:obj}`ModelGeneralMeasures <arelle.ModelFormulaObject.ModelGeneralMeasures>`
  -
* - {py:obj}`ModelSingleMeasure <arelle.ModelFormulaObject.ModelSingleMeasure>`
  -
* - {py:obj}`ModelNilFilter <arelle.ModelFormulaObject.ModelNilFilter>`
  -
* - {py:obj}`ModelPrecisionFilter <arelle.ModelFormulaObject.ModelPrecisionFilter>`
  -
* - {py:obj}`ModelEqualityDefinition <arelle.ModelFormulaObject.ModelEqualityDefinition>`
  -
* - {py:obj}`ModelMessage <arelle.ModelFormulaObject.ModelMessage>`
  -
* - {py:obj}`ModelAssertionSeverity <arelle.ModelFormulaObject.ModelAssertionSeverity>`
  -
* - {py:obj}`ModelCustomFunctionSignature <arelle.ModelFormulaObject.ModelCustomFunctionSignature>`
  -
* - {py:obj}`ModelCustomFunctionImplementation <arelle.ModelFormulaObject.ModelCustomFunctionImplementation>`
  -
````

### API

`````{py:class} FormulaOptions(savedValues: dict[str, typing.Any] | None = None)
:canonical: arelle.ModelFormulaObject.FormulaOptions

```{autodoc2-docstring} arelle.ModelFormulaObject.FormulaOptions
```

```{rubric} Initialization
```

```{autodoc2-docstring} arelle.ModelFormulaObject.FormulaOptions.__init__
```

````{py:method} typedParameters(prefixedNamespaces: dict[str, str] | None = None) -> dict[arelle.ModelValue.QName | None, typing.Any]
:canonical: arelle.ModelFormulaObject.FormulaOptions.typedParameters

```{autodoc2-docstring} arelle.ModelFormulaObject.FormulaOptions.typedParameters
```

````

````{py:method} traceSource(traceType: int | None) -> bool
:canonical: arelle.ModelFormulaObject.FormulaOptions.traceSource

```{autodoc2-docstring} arelle.ModelFormulaObject.FormulaOptions.traceSource
```

````

````{py:method} traceEvaluation(traceType: int | None) -> bool
:canonical: arelle.ModelFormulaObject.FormulaOptions.traceEvaluation

```{autodoc2-docstring} arelle.ModelFormulaObject.FormulaOptions.traceEvaluation
```

````

`````

`````{py:class} Trace
:canonical: arelle.ModelFormulaObject.Trace

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace
```

````{py:attribute} PARAMETER
:canonical: arelle.ModelFormulaObject.Trace.PARAMETER
:value: >
   1

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.PARAMETER
```

````

````{py:attribute} VARIABLE_SET
:canonical: arelle.ModelFormulaObject.Trace.VARIABLE_SET
:value: >
   2

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.VARIABLE_SET
```

````

````{py:attribute} MESSAGE
:canonical: arelle.ModelFormulaObject.Trace.MESSAGE
:value: >
   3

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.MESSAGE
```

````

````{py:attribute} FORMULA_RULES
:canonical: arelle.ModelFormulaObject.Trace.FORMULA_RULES
:value: >
   4

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.FORMULA_RULES
```

````

````{py:attribute} VARIABLE
:canonical: arelle.ModelFormulaObject.Trace.VARIABLE
:value: >
   5

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.VARIABLE
```

````

````{py:attribute} CUSTOM_FUNCTION
:canonical: arelle.ModelFormulaObject.Trace.CUSTOM_FUNCTION
:value: >
   6

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.CUSTOM_FUNCTION
```

````

````{py:attribute} CALL
:canonical: arelle.ModelFormulaObject.Trace.CALL
:value: >
   7

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.CALL
```

````

````{py:attribute} TEST
:canonical: arelle.ModelFormulaObject.Trace.TEST
:value: >
   8

```{autodoc2-docstring} arelle.ModelFormulaObject.Trace.TEST
```

````

`````

`````{py:class} ModelFormulaResource
:canonical: arelle.ModelFormulaObject.ModelFormulaResource

Bases: {py:obj}`arelle.ModelDtsObject.ModelResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaResource.init
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.descendantArcroles
:type: tuple[]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaResource.descendantArcroles
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaResource.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaResource.variableRefs
```

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.logLabel

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaResource.logLabel
```

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelFormulaResource.dereference

````

`````

`````{py:class} ModelAssertionSet
:canonical: arelle.ModelFormulaObject.ModelAssertionSet

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSet.init
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.descendantArcroles
:type: tuple[str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSet.descendantArcroles
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSet.propertyView
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelAssertionSet.dereference

````

`````

`````{py:class} ModelVariableSet
:canonical: arelle.ModelFormulaObject.ModelVariableSet

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelVariableSet.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSet.init
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelVariableSet.descendantArcroles
:type: tuple[str, str, str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSet.descendantArcroles
```

````

````{py:property} aspectModel
:canonical: arelle.ModelFormulaObject.ModelVariableSet.aspectModel
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSet.aspectModel
```

````

````{py:property} implicitFiltering
:canonical: arelle.ModelFormulaObject.ModelVariableSet.implicitFiltering
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSet.implicitFiltering
```

````

````{py:property} groupFilterRelationships
:canonical: arelle.ModelFormulaObject.ModelVariableSet.groupFilterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSet.groupFilterRelationships
```

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelVariableSet.xmlElementView
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSet.xmlElementView
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelVariableSet.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSet.propertyView
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelVariableSet.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelVariableSet.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelVariableSet.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelVariableSet.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelVariableSet.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelVariableSet.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelVariableSet.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelVariableSet.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelVariableSet.dereference

````

`````

`````{py:class} ModelFormulaRules
:canonical: arelle.ModelFormulaObject.ModelFormulaRules

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules
```

````{py:attribute} isSubclassOfModelVariableSet
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.isSubclassOfModelVariableSet
:type: bool
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.isSubclassOfModelVariableSet
```

````

````{py:attribute} valueProg
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.valueProg
:type: arelle.formula.XPathParser.ExpressionStack | None
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.valueProg
```

````

````{py:attribute} hasPrecision
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.hasPrecision
:type: bool
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.hasPrecision
```

````

````{py:attribute} hasDecimals
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.hasDecimals
:type: bool
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.hasDecimals
```

````

````{py:attribute} aspectValues
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.aspectValues
:type: collections.defaultdict[int | arelle.ModelValue.QName, list[arelle.ModelValue.QName] | arelle.ModelValue.QName | arelle.ModelObject.ModelObject | str | None]
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.aspectValues
```

````

````{py:attribute} aspectProgs
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.aspectProgs
:type: collections.defaultdict[int | arelle.ModelValue.QName, list[arelle.formula.XPathParser.ExpressionStack | None]]
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.aspectProgs
```

````

````{py:attribute} typedDimProgAspects
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.typedDimProgAspects
:type: set[arelle.ModelValue.QName]
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.typedDimProgAspects
```

````

````{py:attribute} modelXbrl
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.modelXbrl
:type: arelle.ModelXbrl.ModelXbrl
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.modelXbrl
```

````

````{py:attribute} aspectModel
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.aspectModel
:type: str
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.aspectModel
```

````

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.variableRefs
```

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.evaluate

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.evaluate
```

````

````{py:method} evaluateRule(xpCtx: arelle.formula.XPathContext.XPathContext | None, aspect: int | arelle.ModelValue.QName) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.evaluateRule

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.evaluateRule
```

````

````{py:method} hasRule(aspect: int | arelle.ModelValue.QName) -> bool
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.hasRule

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.hasRule
```

````

````{py:property} value
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.value
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.value
```

````

````{py:property} expression
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.expression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.expression
```

````

````{py:method} source(aspect: int | arelle.ModelValue.QName | None = None, ruleElement: arelle.ModelObject.ModelObject | None = None, acceptFormulaSource: bool = True) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.source

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.source
```

````

````{py:method} aspectRuleElements(aspect: int | arelle.ModelValue.QName | None) -> collections.abc.Sequence[arelle.ModelObject.ModelObject]
:canonical: arelle.ModelFormulaObject.ModelFormulaRules.aspectRuleElements

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormulaRules.aspectRuleElements
```

````

`````

`````{py:class} ModelFormula
:canonical: arelle.ModelFormulaObject.ModelFormula

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaRules`, {py:obj}`arelle.ModelFormulaObject.ModelVariableSet`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelFormula.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormula.init
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelFormula.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormula.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelFormula.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFormula.viewExpression
```

````

````{py:attribute} isSubclassOfModelVariableSet
:canonical: arelle.ModelFormulaObject.ModelFormula.isSubclassOfModelVariableSet
:type: bool
:value: >
   None

````

````{py:attribute} valueProg
:canonical: arelle.ModelFormulaObject.ModelFormula.valueProg
:type: arelle.formula.XPathParser.ExpressionStack | None
:value: >
   None

````

````{py:attribute} hasPrecision
:canonical: arelle.ModelFormulaObject.ModelFormula.hasPrecision
:type: bool
:value: >
   None

````

````{py:attribute} hasDecimals
:canonical: arelle.ModelFormulaObject.ModelFormula.hasDecimals
:type: bool
:value: >
   None

````

````{py:attribute} aspectValues
:canonical: arelle.ModelFormulaObject.ModelFormula.aspectValues
:type: collections.defaultdict[int | arelle.ModelValue.QName, list[arelle.ModelValue.QName] | arelle.ModelValue.QName | arelle.ModelObject.ModelObject | str | None]
:value: >
   None

````

````{py:attribute} aspectProgs
:canonical: arelle.ModelFormulaObject.ModelFormula.aspectProgs
:type: collections.defaultdict[int | arelle.ModelValue.QName, list[arelle.formula.XPathParser.ExpressionStack | None]]
:value: >
   None

````

````{py:attribute} typedDimProgAspects
:canonical: arelle.ModelFormulaObject.ModelFormula.typedDimProgAspects
:type: set[arelle.ModelValue.QName]
:value: >
   None

````

````{py:attribute} modelXbrl
:canonical: arelle.ModelFormulaObject.ModelFormula.modelXbrl
:type: arelle.ModelXbrl.ModelXbrl
:value: >
   None

````

````{py:attribute} aspectModel
:canonical: arelle.ModelFormulaObject.ModelFormula.aspectModel
:type: str
:value: >
   None

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelFormula.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelFormula.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelFormula.variableRefs

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelFormula.evaluate

````

````{py:method} evaluateRule(xpCtx: arelle.formula.XPathContext.XPathContext | None, aspect: int | arelle.ModelValue.QName) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelFormula.evaluateRule

````

````{py:method} hasRule(aspect: int | arelle.ModelValue.QName) -> bool
:canonical: arelle.ModelFormulaObject.ModelFormula.hasRule

````

````{py:property} value
:canonical: arelle.ModelFormulaObject.ModelFormula.value
:type: str | None

````

````{py:property} expression
:canonical: arelle.ModelFormulaObject.ModelFormula.expression
:type: str

````

````{py:method} source(aspect: int | arelle.ModelValue.QName | None = None, ruleElement: arelle.ModelObject.ModelObject | None = None, acceptFormulaSource: bool = True) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelFormula.source

````

````{py:method} aspectRuleElements(aspect: int | arelle.ModelValue.QName | None) -> collections.abc.Sequence[arelle.ModelObject.ModelObject]
:canonical: arelle.ModelFormulaObject.ModelFormula.aspectRuleElements

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelFormula.descendantArcroles
:type: tuple[str, str, str]

````

````{py:property} implicitFiltering
:canonical: arelle.ModelFormulaObject.ModelFormula.implicitFiltering
:type: str | None

````

````{py:property} groupFilterRelationships
:canonical: arelle.ModelFormulaObject.ModelFormula.groupFilterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelFormula.xmlElementView
:type: str

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFormula.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelFormula.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelFormula.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelFormula.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFormula.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelFormula.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelFormula.dereference

````

`````

`````{py:class} ModelTuple
:canonical: arelle.ModelFormulaObject.ModelTuple

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormula`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelTuple.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTuple.init
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelTuple.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelTuple.viewExpression
:type: str | None

````

````{py:attribute} isSubclassOfModelVariableSet
:canonical: arelle.ModelFormulaObject.ModelTuple.isSubclassOfModelVariableSet
:type: bool
:value: >
   None

````

````{py:attribute} valueProg
:canonical: arelle.ModelFormulaObject.ModelTuple.valueProg
:type: arelle.formula.XPathParser.ExpressionStack | None
:value: >
   None

````

````{py:attribute} hasPrecision
:canonical: arelle.ModelFormulaObject.ModelTuple.hasPrecision
:type: bool
:value: >
   None

````

````{py:attribute} hasDecimals
:canonical: arelle.ModelFormulaObject.ModelTuple.hasDecimals
:type: bool
:value: >
   None

````

````{py:attribute} aspectValues
:canonical: arelle.ModelFormulaObject.ModelTuple.aspectValues
:type: collections.defaultdict[int | arelle.ModelValue.QName, list[arelle.ModelValue.QName] | arelle.ModelValue.QName | arelle.ModelObject.ModelObject | str | None]
:value: >
   None

````

````{py:attribute} aspectProgs
:canonical: arelle.ModelFormulaObject.ModelTuple.aspectProgs
:type: collections.defaultdict[int | arelle.ModelValue.QName, list[arelle.formula.XPathParser.ExpressionStack | None]]
:value: >
   None

````

````{py:attribute} typedDimProgAspects
:canonical: arelle.ModelFormulaObject.ModelTuple.typedDimProgAspects
:type: set[arelle.ModelValue.QName]
:value: >
   None

````

````{py:attribute} modelXbrl
:canonical: arelle.ModelFormulaObject.ModelTuple.modelXbrl
:type: arelle.ModelXbrl.ModelXbrl
:value: >
   None

````

````{py:attribute} aspectModel
:canonical: arelle.ModelFormulaObject.ModelTuple.aspectModel
:type: str
:value: >
   None

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelTuple.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelTuple.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelTuple.variableRefs

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelTuple.evaluate

````

````{py:method} evaluateRule(xpCtx: arelle.formula.XPathContext.XPathContext | None, aspect: int | arelle.ModelValue.QName) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelTuple.evaluateRule

````

````{py:method} hasRule(aspect: int | arelle.ModelValue.QName) -> bool
:canonical: arelle.ModelFormulaObject.ModelTuple.hasRule

````

````{py:property} value
:canonical: arelle.ModelFormulaObject.ModelTuple.value
:type: str | None

````

````{py:property} expression
:canonical: arelle.ModelFormulaObject.ModelTuple.expression
:type: str

````

````{py:method} source(aspect: int | arelle.ModelValue.QName | None = None, ruleElement: arelle.ModelObject.ModelObject | None = None, acceptFormulaSource: bool = True) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelTuple.source

````

````{py:method} aspectRuleElements(aspect: int | arelle.ModelValue.QName | None) -> collections.abc.Sequence[arelle.ModelObject.ModelObject]
:canonical: arelle.ModelFormulaObject.ModelTuple.aspectRuleElements

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelTuple.descendantArcroles
:type: tuple[str, str, str]

````

````{py:property} implicitFiltering
:canonical: arelle.ModelFormulaObject.ModelTuple.implicitFiltering
:type: str | None

````

````{py:property} groupFilterRelationships
:canonical: arelle.ModelFormulaObject.ModelTuple.groupFilterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelTuple.xmlElementView
:type: str

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelTuple.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelTuple.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelTuple.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelTuple.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelTuple.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelTuple.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelTuple.dereference

````

`````

`````{py:class} ModelVariableSetAssertion
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion

Bases: {py:obj}`arelle.ModelFormulaObject.ModelVariableSet`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.variableRefs
```

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.test
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.test
```

````

````{py:property} expression
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.expression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.expression
```

````

````{py:method} message(satisfied: bool, preferredMessage: str = '*', lang: str | None = None) -> str | arelle.ModelObject.ModelObject | list[str] | list[arelle.ModelObject.ModelObject] | None
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.message

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.message
```

````

````{py:method} unsatisfiedSeverity(xpCtx: arelle.formula.XPathContext.XPathContext, contextItem: arelle.formula.XPathContext.ContextItem = None) -> str | None
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.unsatisfiedSeverity

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.unsatisfiedSeverity
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariableSetAssertion.viewExpression
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.descendantArcroles
:type: tuple[str, str, str]

````

````{py:property} aspectModel
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.aspectModel
:type: str | None

````

````{py:property} implicitFiltering
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.implicitFiltering
:type: str | None

````

````{py:property} groupFilterRelationships
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.groupFilterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.xmlElementView
:type: str

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelVariableSetAssertion.dereference

````

`````

`````{py:class} ModelExistenceAssertion
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion

Bases: {py:obj}`arelle.ModelFormulaObject.ModelVariableSetAssertion`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExistenceAssertion.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.test
:type: str | None

````

````{py:property} expression
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.expression
:type: str

````

````{py:method} message(satisfied: bool, preferredMessage: str = '*', lang: str | None = None) -> str | arelle.ModelObject.ModelObject | list[str] | list[arelle.ModelObject.ModelObject] | None
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.message

````

````{py:method} unsatisfiedSeverity(xpCtx: arelle.formula.XPathContext.XPathContext, contextItem: arelle.formula.XPathContext.ContextItem = None) -> str | None
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.unsatisfiedSeverity

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.viewExpression
:type: str | None

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.descendantArcroles
:type: tuple[str, str, str]

````

````{py:property} aspectModel
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.aspectModel
:type: str | None

````

````{py:property} implicitFiltering
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.implicitFiltering
:type: str | None

````

````{py:property} groupFilterRelationships
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.groupFilterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.xmlElementView
:type: str

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelExistenceAssertion.dereference

````

`````

`````{py:class} ModelValueAssertion
:canonical: arelle.ModelFormulaObject.ModelValueAssertion

Bases: {py:obj}`arelle.ModelFormulaObject.ModelVariableSetAssertion`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelValueAssertion.init
```

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext) -> arelle.formula.XPathContext.ResultStack | None
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.evaluate

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelValueAssertion.evaluate
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.test
:type: str | None

````

````{py:property} expression
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.expression
:type: str

````

````{py:method} message(satisfied: bool, preferredMessage: str = '*', lang: str | None = None) -> str | arelle.ModelObject.ModelObject | list[str] | list[arelle.ModelObject.ModelObject] | None
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.message

````

````{py:method} unsatisfiedSeverity(xpCtx: arelle.formula.XPathContext.XPathContext, contextItem: arelle.formula.XPathContext.ContextItem = None) -> str | None
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.unsatisfiedSeverity

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.viewExpression
:type: str | None

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.descendantArcroles
:type: tuple[str, str, str]

````

````{py:property} aspectModel
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.aspectModel
:type: str | None

````

````{py:property} implicitFiltering
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.implicitFiltering
:type: str | None

````

````{py:property} groupFilterRelationships
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.groupFilterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.xmlElementView
:type: str

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelValueAssertion.dereference

````

`````

`````{py:class} ModelConsistencyAssertion
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.compile
```

````

````{py:method} evalRadius(xpCtx: arelle.formula.XPathContext.XPathContext, factValue: arelle.formula.XPathContext.ContextItem) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.evalRadius

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.evalRadius
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.descendantArcroles
:type: tuple[str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.descendantArcroles
```

````

````{py:property} hasProportionalAcceptanceRadius
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.hasProportionalAcceptanceRadius
:type: bool

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.hasProportionalAcceptanceRadius
```

````

````{py:property} hasAbsoluteAcceptanceRadius
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.hasAbsoluteAcceptanceRadius
:type: bool

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.hasAbsoluteAcceptanceRadius
```

````

````{py:property} isStrict
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.isStrict
:type: bool

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.isStrict
```

````

````{py:method} message(satisfied: bool, preferredMessage: str = '*', lang: str | None = None) -> str | arelle.ModelObject.ModelObject | list[str] | list[arelle.ModelObject.ModelObject] | None
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.message

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.message
```

````

````{py:property} radiusExpression
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.radiusExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.radiusExpression
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.viewExpression
```

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.xmlElementView
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.xmlElementView
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConsistencyAssertion.propertyView
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConsistencyAssertion.dereference

````

`````

`````{py:class} ModelParameter
:canonical: arelle.ModelFormulaObject.ModelParameter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelParameter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelParameter.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelParameter.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelParameter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.variableRefs
```

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext, typeQname: arelle.ModelValue.QName | str) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelParameter.evaluate

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.evaluate
```

````

````{py:property} name
:canonical: arelle.ModelFormulaObject.ModelParameter.name
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.name
```

````

````{py:property} parameterQname
:canonical: arelle.ModelFormulaObject.ModelParameter.parameterQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.parameterQname
```

````

````{py:property} select
:canonical: arelle.ModelFormulaObject.ModelParameter.select
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.select
```

````

````{py:property} isRequired
:canonical: arelle.ModelFormulaObject.ModelParameter.isRequired
:type: bool

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.isRequired
```

````

````{py:property} asType
:canonical: arelle.ModelFormulaObject.ModelParameter.asType
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.asType
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelParameter.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelParameter.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParameter.viewExpression
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelParameter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelParameter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelParameter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelParameter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelParameter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelParameter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelParameter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelParameter.dereference

````

`````

`````{py:class} ModelInstance
:canonical: arelle.ModelFormulaObject.ModelInstance

Bases: {py:obj}`arelle.ModelFormulaObject.ModelParameter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelInstance.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstance.init
```

````

````{py:property} instanceQname
:canonical: arelle.ModelFormulaObject.ModelInstance.instanceQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstance.instanceQname
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelInstance.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelInstance.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelInstance.variableRefs

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext, typeQname: arelle.ModelValue.QName | str) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelInstance.evaluate

````

````{py:property} name
:canonical: arelle.ModelFormulaObject.ModelInstance.name
:type: str | None

````

````{py:property} parameterQname
:canonical: arelle.ModelFormulaObject.ModelInstance.parameterQname
:type: arelle.ModelValue.QName | None

````

````{py:property} select
:canonical: arelle.ModelFormulaObject.ModelInstance.select
:type: str | None

````

````{py:property} isRequired
:canonical: arelle.ModelFormulaObject.ModelInstance.isRequired
:type: bool

````

````{py:property} asType
:canonical: arelle.ModelFormulaObject.ModelInstance.asType
:type: arelle.ModelValue.QName | None

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelInstance.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelInstance.viewExpression
:type: str | None

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelInstance.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelInstance.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelInstance.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelInstance.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelInstance.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelInstance.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelInstance.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelInstance.dereference

````

`````

`````{py:class} ModelVariable
:canonical: arelle.ModelFormulaObject.ModelVariable

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelVariable.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariable.init
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelVariable.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariable.compile
```

````

````{py:property} bindAsSequence
:canonical: arelle.ModelFormulaObject.ModelVariable.bindAsSequence
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelVariable.bindAsSequence
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelVariable.descendantArcroles
:type: tuple[]

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelVariable.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelVariable.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelVariable.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelVariable.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelVariable.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelVariable.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelVariable.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelVariable.dereference

````

`````

`````{py:class} ModelFactVariable
:canonical: arelle.ModelFormulaObject.ModelFactVariable

Bases: {py:obj}`arelle.ModelFormulaObject.ModelVariable`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelFactVariable.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelFactVariable.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelFactVariable.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelFactVariable.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.variableRefs
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelFactVariable.descendantArcroles
:type: tuple[str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.descendantArcroles
```

````

````{py:property} nils
:canonical: arelle.ModelFormulaObject.ModelFactVariable.nils
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.nils
```

````

````{py:property} matches
:canonical: arelle.ModelFormulaObject.ModelFactVariable.matches
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.matches
```

````

````{py:property} fallbackValue
:canonical: arelle.ModelFormulaObject.ModelFactVariable.fallbackValue
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.fallbackValue
```

````

````{py:property} filterRelationships
:canonical: arelle.ModelFormulaObject.ModelFactVariable.filterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship | arelle.ModelFormulaObject.ModelConceptName]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.filterRelationships
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelFactVariable.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelFactVariable.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFactVariable.viewExpression
```

````

````{py:property} bindAsSequence
:canonical: arelle.ModelFormulaObject.ModelFactVariable.bindAsSequence
:type: str | None

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFactVariable.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelFactVariable.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelFactVariable.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelFactVariable.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFactVariable.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelFactVariable.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelFactVariable.dereference

````

`````

`````{py:class} ModelGeneralVariable
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable

Bases: {py:obj}`arelle.ModelFormulaObject.ModelVariable`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralVariable.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralVariable.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralVariable.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralVariable.variableRefs
```

````

````{py:property} select
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.select
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralVariable.select
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralVariable.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralVariable.viewExpression
```

````

````{py:property} bindAsSequence
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.bindAsSequence
:type: str | None

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelGeneralVariable.dereference

````

`````

`````{py:class} ModelPrecondition
:canonical: arelle.ModelFormulaObject.ModelPrecondition

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelPrecondition.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelPrecondition.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelPrecondition.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelPrecondition.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.variableRefs
```

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelPrecondition.test
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.test
```

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelPrecondition.evalTest

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.evalTest
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelPrecondition.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelPrecondition.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecondition.viewExpression
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelPrecondition.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPrecondition.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelPrecondition.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelPrecondition.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelPrecondition.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPrecondition.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelPrecondition.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelPrecondition.dereference

````

`````

`````{py:class} ModelFilter
:canonical: arelle.ModelFormulaObject.ModelFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFilter.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFilter.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFilter.filter
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelFilter.hasNoFilterVariableDependencies

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFilter.hasNoFilterVariableDependencies
```

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelFilter.isFilterShared
:type: bool

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFilter.isFilterShared
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelFilter.propertyView
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelFilter.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelFilter.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelFilter.dereference

````

`````

`````{py:class} ModelTestFilter
:canonical: arelle.ModelFormulaObject.ModelTestFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelTestFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelTestFilter.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelTestFilter.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelTestFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.variableRefs
```

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelTestFilter.test
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.test
```

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelTestFilter.evalTest

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.evalTest
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelTestFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelTestFilter.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTestFilter.viewExpression
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelTestFilter.aspectsCovered

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelTestFilter.filter

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelTestFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelTestFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelTestFilter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelTestFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelTestFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelTestFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelTestFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelTestFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelTestFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelTestFilter.dereference

````

`````

`````{py:class} ModelPatternFilter
:canonical: arelle.ModelFormulaObject.ModelPatternFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPatternFilter.init
```

````

````{py:property} pattern
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.pattern
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPatternFilter.pattern
```

````

````{py:property} rePattern
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.rePattern
:type: regex.Pattern[str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPatternFilter.rePattern
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPatternFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPatternFilter.viewExpression
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.aspectsCovered

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.filter

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelPatternFilter.dereference

````

`````

`````{py:class} ModelAspectCover
:canonical: arelle.ModelFormulaObject.ModelAspectCover

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:attribute} isAll
:canonical: arelle.ModelFormulaObject.ModelAspectCover.isAll
:type: bool
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.isAll
```

````

````{py:attribute} allDimensions
:canonical: arelle.ModelFormulaObject.ModelAspectCover.allDimensions
:type: bool
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.allDimensions
```

````

````{py:attribute} includedDimQnameProgs
:canonical: arelle.ModelFormulaObject.ModelAspectCover.includedDimQnameProgs
:type: list[arelle.formula.XPathParser.ExpressionStack | None]
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.includedDimQnameProgs
```

````

````{py:attribute} excludedDimQnameProgs
:canonical: arelle.ModelFormulaObject.ModelAspectCover.excludedDimQnameProgs
:type: list[arelle.formula.XPathParser.ExpressionStack | None]
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.excludedDimQnameProgs
```

````

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelAspectCover.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelAspectCover.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding, xpCtx: arelle.formula.XPathContext.XPathContext = None) -> set[int | arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelAspectCover.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.aspectsCovered
```

````

````{py:method} dimAspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelAspectCover.dimAspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.dimAspectsCovered
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelAspectCover.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelAspectCover.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.variableRefs
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelAspectCover.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAspectCover.viewExpression
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelAspectCover.filter

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelAspectCover.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelAspectCover.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelAspectCover.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelAspectCover.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAspectCover.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelAspectCover.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelAspectCover.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelAspectCover.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAspectCover.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelAspectCover.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelAspectCover.dereference

````

`````

`````{py:class} ModelBooleanFilter
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelBooleanFilter.init
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.descendantArcroles
:type: tuple[str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelBooleanFilter.descendantArcroles
```

````

````{py:property} filterRelationships
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.filterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelBooleanFilter.filterRelationships
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelBooleanFilter.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.filter

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelBooleanFilter.dereference

````

`````

`````{py:class} ModelAndFilter
:canonical: arelle.ModelFormulaObject.ModelAndFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelBooleanFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelAndFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAndFilter.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelAndFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAndFilter.filter
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelAndFilter.descendantArcroles
:type: tuple[str]

````

````{py:property} filterRelationships
:canonical: arelle.ModelFormulaObject.ModelAndFilter.filterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelAndFilter.aspectsCovered

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelAndFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelAndFilter.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelAndFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelAndFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelAndFilter.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAndFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelAndFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelAndFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelAndFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAndFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelAndFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelAndFilter.dereference

````

`````

`````{py:class} ModelOrFilter
:canonical: arelle.ModelFormulaObject.ModelOrFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelBooleanFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelOrFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelOrFilter.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelOrFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelOrFilter.filter
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelOrFilter.descendantArcroles
:type: tuple[str]

````

````{py:property} filterRelationships
:canonical: arelle.ModelFormulaObject.ModelOrFilter.filterRelationships
:type: list[arelle.ModelDtsObject.ModelRelationship]

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelOrFilter.aspectsCovered

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelOrFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelOrFilter.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelOrFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelOrFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelOrFilter.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelOrFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelOrFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelOrFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelOrFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelOrFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelOrFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelOrFilter.dereference

````

`````

`````{py:class} ModelConceptName
:canonical: arelle.ModelFormulaObject.ModelConceptName

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:attribute} qnameExpressionProgs
:canonical: arelle.ModelFormulaObject.ModelConceptName.qnameExpressionProgs
:type: list[arelle.formula.XPathParser.ExpressionStack | None]
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.qnameExpressionProgs
```

````

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptName.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptName.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptName.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.aspectsCovered
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptName.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptName.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.variableRefs
```

````

````{py:property} conceptQnames
:canonical: arelle.ModelFormulaObject.ModelConceptName.conceptQnames
:type: set[arelle.ModelValue.QName | None]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.conceptQnames
```

````

````{py:property} qnameExpressions
:canonical: arelle.ModelFormulaObject.ModelConceptName.qnameExpressions
:type: list[str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.qnameExpressions
```

````

````{py:method} evalQnames(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> set[typing.Any]
:canonical: arelle.ModelFormulaObject.ModelConceptName.evalQnames

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.evalQnames
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptName.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptName.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConceptName.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptName.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptName.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptName.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptName.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptName.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptName.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptName.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptName.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptName.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptName.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptName.dereference

````

`````

`````{py:class} ModelConceptPeriodType
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptPeriodType.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptPeriodType.aspectsCovered
```

````

````{py:property} periodType
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.periodType
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptPeriodType.periodType
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptPeriodType.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptPeriodType.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptPeriodType.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptPeriodType.dereference

````

`````

`````{py:class} ModelConceptBalance
:canonical: arelle.ModelFormulaObject.ModelConceptBalance

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptBalance.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptBalance.aspectsCovered
```

````

````{py:property} balance
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.balance
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptBalance.balance
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptBalance.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptBalance.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptBalance.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptBalance.dereference

````

`````

`````{py:class} ModelConceptFilterWithQnameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.aspectsCovered
```

````

````{py:property} filterQname
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.filterQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.filterQname
```

````

````{py:property} qnameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.qnameExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.qnameExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.variableRefs
```

````

````{py:method} evalQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.evalQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.evalQname
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.filter

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression.dereference

````

`````

`````{py:class} ModelConceptCustomAttribute
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute

Bases: {py:obj}`arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.clear
```

````

````{py:property} value
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.value
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.value
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.variableRefs
```

````

````{py:method} evalValue(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.evalValue

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.evalValue
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptCustomAttribute.viewExpression
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.aspectsCovered

````

````{py:property} filterQname
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.filterQname
:type: arelle.ModelValue.QName | None

````

````{py:property} qnameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.qnameExpression
:type: str | None

````

````{py:method} evalQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.evalQname

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptCustomAttribute.dereference

````

`````

`````{py:class} ModelConceptDataType
:canonical: arelle.ModelFormulaObject.ModelConceptDataType

Bases: {py:obj}`arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptDataType.init
```

````

````{py:property} strict
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.strict
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptDataType.strict
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptDataType.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptDataType.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptDataType.viewExpression
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.clear

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.aspectsCovered

````

````{py:property} filterQname
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.filterQname
:type: arelle.ModelValue.QName | None

````

````{py:property} qnameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.qnameExpression
:type: str | None

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.variableRefs

````

````{py:method} evalQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.evalQname

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptDataType.dereference

````

`````

`````{py:class} ModelConceptSubstitutionGroup
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup

Bases: {py:obj}`arelle.ModelFormulaObject.ModelConceptFilterWithQnameExpression`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.init
```

````

````{py:property} strict
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.strict
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.strict
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.viewExpression
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.clear

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.aspectsCovered

````

````{py:property} filterQname
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.filterQname
:type: arelle.ModelValue.QName | None

````

````{py:property} qnameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.qnameExpression
:type: str | None

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.variableRefs

````

````{py:method} evalQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.evalQname

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptSubstitutionGroup.dereference

````

`````

`````{py:class} ModelConceptRelation
:canonical: arelle.ModelFormulaObject.ModelConceptRelation

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.aspectsCovered
```

````

````{py:property} variable
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.variable
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.variable
```

````

````{py:property} sourceQname
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.sourceQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.sourceQname
```

````

````{py:property} linkrole
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.linkrole
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.linkrole
```

````

````{py:property} linkQname
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.linkQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.linkQname
```

````

````{py:property} arcrole
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.arcrole
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.arcrole
```

````

````{py:property} axis
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.axis
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.axis
```

````

````{py:property} generations
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.generations
:type: int

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.generations
```

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.test
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.test
```

````

````{py:property} arcQname
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.arcQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.arcQname
```

````

````{py:property} sourceQnameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.sourceQnameExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.sourceQnameExpression
```

````

````{py:property} linkroleExpression
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.linkroleExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.linkroleExpression
```

````

````{py:property} linknameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.linknameExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.linknameExpression
```

````

````{py:property} arcroleExpression
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.arcroleExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.arcroleExpression
```

````

````{py:property} arcnameExpression
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.arcnameExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.arcnameExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.variableRefs
```

````

````{py:method} evalSourceQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact | None) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.evalSourceQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.evalSourceQname
```

````

````{py:method} evalLinkrole(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact | None) -> str | None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.evalLinkrole

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.evalLinkrole
```

````

````{py:method} evalLinkQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact | None) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.evalLinkQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.evalLinkQname
```

````

````{py:method} evalArcrole(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact | None) -> str | None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.evalArcrole

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.evalArcrole
```

````

````{py:method} evalArcQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact | None) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.evalArcQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.evalArcQname
```

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool | None
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.evalTest

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.evalTest
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.filter
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.viewExpression
```

````

````{py:property} xmlElementView
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.xmlElementView
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelConceptRelation.xmlElementView
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelConceptRelation.dereference

````

`````

`````{py:class} ModelEntityIdentifier
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityIdentifier.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityIdentifier.filter
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityIdentifier.aspectsCovered
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.test
:type: str | None

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.evalTest

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.viewExpression
:type: str | None

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelEntityIdentifier.dereference

````

`````

`````{py:class} ModelEntitySpecificIdentifier
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.aspectsCovered
```

````

````{py:property} scheme
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.scheme
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.scheme
```

````

````{py:property} value
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.value
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.value
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.variableRefs
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelEntitySpecificIdentifier.dereference

````

`````

`````{py:class} ModelEntityScheme
:canonical: arelle.ModelFormulaObject.ModelEntityScheme

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.aspectsCovered
```

````

````{py:property} scheme
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.scheme
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.scheme
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.variableRefs
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityScheme.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelEntityScheme.dereference

````

`````

`````{py:class} ModelEntityRegexpIdentifier
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier

Bases: {py:obj}`arelle.ModelFormulaObject.ModelPatternFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.filter
```

````

````{py:property} pattern
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.pattern
:type: str | None

````

````{py:property} rePattern
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.rePattern
:type: regex.Pattern[str]

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.viewExpression
:type: str | None

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpIdentifier.dereference

````

`````

`````{py:class} ModelEntityRegexpScheme
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme

Bases: {py:obj}`arelle.ModelFormulaObject.ModelPatternFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityRegexpScheme.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityRegexpScheme.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEntityRegexpScheme.filter
```

````

````{py:property} pattern
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.pattern
:type: str | None

````

````{py:property} rePattern
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.rePattern
:type: regex.Pattern[str]

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.viewExpression
:type: str | None

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelEntityRegexpScheme.dereference

````

`````

`````{py:class} ModelGeneral
:canonical: arelle.ModelFormulaObject.ModelGeneral

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelGeneral.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneral.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelGeneral.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneral.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelGeneral.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelGeneral.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelGeneral.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelGeneral.test
:type: str | None

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelGeneral.evalTest

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelGeneral.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelGeneral.viewExpression
:type: str | None

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelGeneral.aspectsCovered

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelGeneral.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelGeneral.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelGeneral.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelGeneral.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelGeneral.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelGeneral.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelGeneral.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelGeneral.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelGeneral.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelGeneral.dereference

````

`````

`````{py:class} ModelMatchFilter
:canonical: arelle.ModelFormulaObject.ModelMatchFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.init
```

````

````{py:property} aspectName
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.aspectName
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.aspectName
```

````

````{py:property} dimension
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.dimension
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.dimension
```

````

````{py:property} matchAny
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.matchAny
:type: bool

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.matchAny
```

````

````{py:property} aspect
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.aspect
:type: int | arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.aspect
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int | arelle.ModelValue.QName | None]
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.aspectsCovered
```

````

````{py:property} variable
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.variable
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.variable
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.variableRefs
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.viewExpression
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMatchFilter.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.compile

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelMatchFilter.dereference

````

`````

`````{py:class} ModelPeriod
:canonical: arelle.ModelFormulaObject.ModelPeriod

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelPeriod.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriod.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelPeriod.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriod.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelPeriod.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriod.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriod.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriod.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelPeriod.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelPeriod.test
:type: str | None

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelPeriod.evalTest

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelPeriod.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelPeriod.viewExpression
:type: str | None

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelPeriod.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelPeriod.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelPeriod.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriod.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelPeriod.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelPeriod.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelPeriod.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriod.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelPeriod.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelPeriod.dereference

````

`````

`````{py:class} ModelDateTimeFilter
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.aspectsCovered
```

````

````{py:property} date
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.date
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.date
```

````

````{py:property} time
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.time
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.time
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.variableRefs
```

````

````{py:method} evalDatetime(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact, addOneDay: bool = False) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.evalDatetime

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.evalDatetime
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelDateTimeFilter.viewExpression
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.filter

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelDateTimeFilter.dereference

````

`````

`````{py:class} ModelPeriodStart
:canonical: arelle.ModelFormulaObject.ModelPeriodStart

Bases: {py:obj}`arelle.ModelFormulaObject.ModelDateTimeFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriodStart.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriodStart.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.clear

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.aspectsCovered

````

````{py:property} date
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.date
:type: str | None

````

````{py:property} time
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.time
:type: str | None

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.variableRefs

````

````{py:method} evalDatetime(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact, addOneDay: bool = False) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.evalDatetime

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.viewExpression
:type: str

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelPeriodStart.dereference

````

`````

`````{py:class} ModelPeriodEnd
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd

Bases: {py:obj}`arelle.ModelFormulaObject.ModelDateTimeFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriodEnd.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriodEnd.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.clear

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.aspectsCovered

````

````{py:property} date
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.date
:type: str | None

````

````{py:property} time
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.time
:type: str | None

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.variableRefs

````

````{py:method} evalDatetime(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact, addOneDay: bool = False) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.evalDatetime

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.viewExpression
:type: str

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelPeriodEnd.dereference

````

`````

`````{py:class} ModelPeriodInstant
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant

Bases: {py:obj}`arelle.ModelFormulaObject.ModelDateTimeFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriodInstant.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPeriodInstant.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.clear

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.aspectsCovered

````

````{py:property} date
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.date
:type: str | None

````

````{py:property} time
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.time
:type: str | None

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.variableRefs

````

````{py:method} evalDatetime(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact, addOneDay: bool = False) -> typing.Any
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.evalDatetime

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.viewExpression
:type: str

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelPeriodInstant.dereference

````

`````

`````{py:class} ModelForever
:canonical: arelle.ModelFormulaObject.ModelForever

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelForever.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelForever.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelForever.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelForever.filter
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelForever.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelForever.aspectsCovered
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelForever.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelForever.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelForever.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelForever.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelForever.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelForever.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelForever.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelForever.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelForever.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelForever.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelForever.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelForever.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelForever.dereference

````

`````

`````{py:class} ModelInstantDuration
:canonical: arelle.ModelFormulaObject.ModelInstantDuration

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.aspectsCovered
```

````

````{py:property} variable
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.variable
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.variable
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName | None] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.variableRefs
```

````

````{py:property} boundary
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.boundary
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.boundary
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelInstantDuration.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.compile

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelInstantDuration.dereference

````

`````

````{py:class} MemberModel(qname: arelle.ModelValue.QName, qnameExprProg: arelle.formula.XPathParser.ExpressionStack | None, variable: arelle.ModelValue.QName, linkrole: str, arcrole: str, axis: str)
:canonical: arelle.ModelFormulaObject.MemberModel

```{autodoc2-docstring} arelle.ModelFormulaObject.MemberModel
```

```{rubric} Initialization
```

```{autodoc2-docstring} arelle.ModelFormulaObject.MemberModel.__init__
```

````

`````{py:class} ModelExplicitDimension
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[arelle.ModelValue.QName | None]
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.aspectsCovered
```

````

````{py:method} dimQname() -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.dimQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.dimQname
```

````

````{py:method} dimQnameExpression() -> str | None
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.dimQnameExpression

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.dimQnameExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.variableRefs
```

````

````{py:method} evalDimQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.evalDimQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.evalDimQname
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelExplicitDimension.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelExplicitDimension.dereference

````

`````

`````{py:class} ModelTypedDimension
:canonical: arelle.ModelFormulaObject.ModelTypedDimension

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[arelle.ModelValue.QName | None]
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.aspectsCovered
```

````

````{py:method} dimQname() -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.dimQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.dimQname
```

````

````{py:method} dimQnameExpression() -> str | None
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.dimQnameExpression

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.dimQnameExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.variableRefs
```

````

````{py:method} evalDimQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.evalDimQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.evalDimQname
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.filter
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelTypedDimension.viewExpression
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.clear

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.test
:type: str | None

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.evalTest

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelTypedDimension.dereference

````

`````

`````{py:class} ModelRelativeFilter
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelRelativeFilter.init
```

````

````{py:property} variable
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.variable
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelRelativeFilter.variable
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelRelativeFilter.variableRefs
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelRelativeFilter.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelRelativeFilter.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelRelativeFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelRelativeFilter.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.compile

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelRelativeFilter.dereference

````

`````

`````{py:class} ModelSegmentFilter
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSegmentFilter.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSegmentFilter.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSegmentFilter.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.test
:type: str | None

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.evalTest

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.viewExpression
:type: str | None

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelSegmentFilter.dereference

````

`````

`````{py:class} ModelScenarioFilter
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelScenarioFilter.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelScenarioFilter.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelScenarioFilter.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.test
:type: str | None

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.evalTest

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.viewExpression
:type: str | None

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelScenarioFilter.dereference

````

`````

`````{py:class} ModelAncestorFilter
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.aspectsCovered
```

````

````{py:property} ancestorQname
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.ancestorQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.ancestorQname
```

````

````{py:property} qnameExpression
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.qnameExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.qnameExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.variableRefs
```

````

````{py:method} evalQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.evalQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.evalQname
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.viewExpression
:type: str | arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAncestorFilter.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelAncestorFilter.dereference

````

`````

`````{py:class} ModelParentFilter
:canonical: arelle.ModelFormulaObject.ModelParentFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelParentFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelParentFilter.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelParentFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.aspectsCovered
```

````

````{py:property} parentQname
:canonical: arelle.ModelFormulaObject.ModelParentFilter.parentQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.parentQname
```

````

````{py:property} qnameExpression
:canonical: arelle.ModelFormulaObject.ModelParentFilter.qnameExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.qnameExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelParentFilter.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelParentFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.variableRefs
```

````

````{py:method} evalQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelParentFilter.evalQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.evalQname
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelParentFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelParentFilter.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelParentFilter.viewExpression
:type: str | arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelParentFilter.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelParentFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelParentFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelParentFilter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelParentFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelParentFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelParentFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelParentFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelParentFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelParentFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelParentFilter.dereference

````

`````

`````{py:class} ModelLocationFilter
:canonical: arelle.ModelFormulaObject.ModelLocationFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.aspectsCovered
```

````

````{py:property} location
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.location
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.location
```

````

````{py:property} variable
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.variable
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.variable
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.variableRefs
```

````

````{py:method} evalLocation(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> set[typing.Any]
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.evalLocation

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.evalLocation
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelLocationFilter.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelLocationFilter.dereference

````

`````

`````{py:class} ModelSiblingFilter
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSiblingFilter.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSiblingFilter.aspectsCovered
```

````

````{py:property} variable
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.variable
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSiblingFilter.variable
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSiblingFilter.variableRefs
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSiblingFilter.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSiblingFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSiblingFilter.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.compile

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelSiblingFilter.dereference

````

`````

`````{py:class} ModelGeneralMeasures
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralMeasures.init
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralMeasures.aspectsCovered
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelGeneralMeasures.filter
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.test
:type: str | None

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> bool
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.evalTest

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.viewExpression
:type: str | None

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelGeneralMeasures.dereference

````

`````

`````{py:class} ModelSingleMeasure
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.clear
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.aspectsCovered

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.aspectsCovered
```

````

````{py:property} measureQname
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.measureQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.measureQname
```

````

````{py:property} qnameExpression
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.qnameExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.qnameExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.variableRefs
```

````

````{py:method} evalQname(xpCtx: arelle.formula.XPathContext.XPathContext, fact: arelle.ModelInstanceObject.ModelFact) -> arelle.ModelValue.QName | None
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.evalQname

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.evalQname
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.viewExpression
:type: str | arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelSingleMeasure.viewExpression
```

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelSingleMeasure.dereference

````

`````

`````{py:class} ModelNilFilter
:canonical: arelle.ModelFormulaObject.ModelNilFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelNilFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelNilFilter.init
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelNilFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelNilFilter.filter
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelNilFilter.aspectsCovered

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelNilFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelNilFilter.isFilterShared
:type: bool

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelNilFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelNilFilter.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelNilFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelNilFilter.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelNilFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelNilFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelNilFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelNilFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelNilFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelNilFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelNilFilter.dereference

````

`````

`````{py:class} ModelPrecisionFilter
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecisionFilter.init
```

````

````{py:property} minimum
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.minimum
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecisionFilter.minimum
```

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.filter

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecisionFilter.filter
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecisionFilter.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelPrecisionFilter.viewExpression
```

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.aspectsCovered

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.descendantArcroles
:type: tuple[]

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelPrecisionFilter.dereference

````

`````

`````{py:class} ModelEqualityDefinition
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition

Bases: {py:obj}`arelle.ModelFormulaObject.ModelTestFilter`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEqualityDefinition.init
```

````

````{py:method} evalTest(xpCtx: arelle.formula.XPathContext.XPathContext, facta: arelle.ModelXbrl.ModelXbrl | arelle.ModelObject.ModelObject | int | str, factb: arelle.ModelXbrl.ModelXbrl | arelle.ModelObject.ModelObject | int | str) -> bool
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.evalTest

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelEqualityDefinition.evalTest
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.clear

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.variableRefs

````

````{py:property} test
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.test
:type: str | None

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.propertyView
:type: tuple[tuple[str, str | None], ...]

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.viewExpression
:type: str | None

````

````{py:method} aspectsCovered(varBinding: arelle.formula.FormulaEvaluator.VariableBinding) -> set[int]
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.aspectsCovered

````

````{py:method} filter(xpCtx: arelle.formula.XPathContext.XPathContext, varBinding: arelle.formula.FormulaEvaluator.VariableBinding, facts: set[arelle.ModelInstanceObject.ModelFact], cmplmt: bool) -> set[arelle.ModelInstanceObject.ModelFact]
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.filter

````

````{py:method} hasNoFilterVariableDependencies(xpCtx: arelle.formula.XPathContext.XPathContext) -> bool
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.hasNoFilterVariableDependencies

````

````{py:property} isFilterShared
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.isFilterShared
:type: bool

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelEqualityDefinition.dereference

````

`````

`````{py:class} ModelMessage
:canonical: arelle.ModelFormulaObject.ModelMessage

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelMessage.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelMessage.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.clear
```

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelMessage.xmlLang
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.xmlLang
```

````

````{py:property} separator
:canonical: arelle.ModelFormulaObject.ModelMessage.separator
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.separator
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelMessage.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelMessage.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.variableRefs
```

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext, contextItem: arelle.formula.XPathContext.ContextItem = None) -> str
:canonical: arelle.ModelFormulaObject.ModelMessage.evaluate

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.evaluate
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelMessage.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelMessage.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelMessage.viewExpression
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelMessage.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelMessage.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelMessage.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelMessage.xlinkLabel
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelMessage.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelMessage.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelMessage.dereference

````

`````

`````{py:class} ModelAssertionSeverity
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.clear
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.compile
```

````

````{py:method} evaluate(xpCtx: arelle.formula.XPathContext.XPathContext, contextItem: arelle.formula.XPathContext.ContextItem = None) -> str | None
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.evaluate

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.evaluate
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.variableRefs
```

````

````{py:property} isStatic
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.isStatic
:type: bool

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.isStatic
```

````

````{py:property} level
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.level
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.level
```

````

````{py:property} severity
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.severity
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.severity
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.propertyView
:type: tuple[tuple[str, str | None] | tuple[], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.viewExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelAssertionSeverity.viewExpression
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelAssertionSeverity.dereference

````

`````

`````{py:class} ModelCustomFunctionSignature
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:attribute} customFunctionImplementation
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.customFunctionImplementation
:type: ModelCustomFunctionImplementation | None
:value: >
   None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.customFunctionImplementation
```

````

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.init
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.descendantArcroles
:type: tuple[str]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.descendantArcroles
```

````

````{py:property} name
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.name
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.name
```

````

````{py:property} functionQname
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.functionQname
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.functionQname
```

````

````{py:property} outputType
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.outputType
:type: arelle.ModelValue.QName | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.outputType
```

````

````{py:property} inputTypes
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.inputTypes
:type: list[arelle.ModelValue.QName | None]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.inputTypes
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.propertyView
:type: tuple[tuple[str, str | arelle.ModelValue.QName | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionSignature.viewExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.compile

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens | None = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.variableRefs

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionSignature.dereference

````

`````

`````{py:class} ModelCustomFunctionImplementation
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation

Bases: {py:obj}`arelle.ModelFormulaObject.ModelFormulaResource`

````{py:method} init(modelDocument: arelle.ModelDocument.ModelDocument) -> None
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.init

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.init
```

````

````{py:method} clear() -> None
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.clear

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.clear
```

````

````{py:property} inputNames
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.inputNames
:type: list[arelle.ModelValue.QName | None]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.inputNames
```

````

````{py:property} stepExpressions
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.stepExpressions
:type: list[tuple[arelle.ModelValue.QName | None, str | None]]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.stepExpressions
```

````

````{py:property} outputExpression
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.outputExpression
:type: str | None

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.outputExpression
```

````

````{py:method} compile() -> None
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.compile

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.compile
```

````

````{py:method} variableRefs(progs: arelle.formula.XPathParser.RecursiveFormulaTokens = [], varRefSet: set[arelle.ModelValue.QName] | None = None) -> set[arelle.ModelValue.QName]
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.variableRefs

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.variableRefs
```

````

````{py:property} propertyView
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.propertyView
:type: tuple[tuple[str, str | None], ...]

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.propertyView
```

````

````{py:property} viewExpression
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.viewExpression
:type: str

```{autodoc2-docstring} arelle.ModelFormulaObject.ModelCustomFunctionImplementation.viewExpression
```

````

````{py:property} descendantArcroles
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.descendantArcroles
:type: tuple[]

````

````{py:method} logLabel(preferredRole: str = '*', lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.logLabel

````

````{py:property} role
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.role
:type: str | None

````

````{py:property} xlinkLabel
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.xlinkLabel
:type: str | None

````

````{py:property} xmlLang
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.xmlLang
:type: str | None

````

````{py:method} viewText(labelrole: str | None = None, lang: str | None = None) -> str
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.viewText

````

````{py:method} roleRefPartSortKey() -> str
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.roleRefPartSortKey

````

````{py:method} dereference() -> typing_extensions.Self
:canonical: arelle.ModelFormulaObject.ModelCustomFunctionImplementation.dereference

````

`````