"""
This file is generated by generator/run.py based on the Chrome DevTools Protocol.

This domain exposes CSS read/write operations. All CSS objects (stylesheets, rules, and styles)
have an associated `id` used in subsequent operations on the related object. Each object type has
a specific `id` structure, and those are not interchangeable between objects of different kinds.
CSS objects can be loaded using the `get*ForNode()` calls (which accept a DOM node id). A client
can also keep track of stylesheets via the `styleSheetAdded`/`styleSheetRemoved` events and
subsequently load the required stylesheet contents using the `getStyleSheet[Text]()` methods.
https://chromedevtools.github.io/devtools-protocol/tot/CSS/

***************************************************
                    Methods
***************************************************
"""
from __future__ import annotations

from cdpkit.protocol._types import (
    CSS,
    DOM,
    Page,
)
from cdpkit.protocol.base import JSON_DICT, CDPMethod, InputModel, OutputModel


class AddRuleInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    ruleText: str
    location: CSS.SourceRange
    nodeForPropertySyntaxValidation: DOM.NodeId | None = None  # experimental


class AddRuleOutput(OutputModel):

    rule: CSS.CSSRule


class AddRule(CDPMethod[AddRuleOutput]):
    """ Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the
    position specified by `location`. """

    INPUT_VALIDATOR = AddRuleInput
    OUTPUT_VALIDATOR = AddRuleOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        rule_text: str,
        location: CSS.SourceRange,
        node_for_property_syntax_validation: DOM.NodeId | None = None
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            ruleText=rule_text,
            location=location,
            nodeForPropertySyntaxValidation=node_for_property_syntax_validation
        )


class CollectClassNamesInput(InputModel):

    styleSheetId: DOM.StyleSheetId


class CollectClassNamesOutput(OutputModel):

    classNames: list[str]


class CollectClassNames(CDPMethod[CollectClassNamesOutput]):
    """ Returns all class names from specified stylesheet. """

    INPUT_VALIDATOR = CollectClassNamesInput
    OUTPUT_VALIDATOR = CollectClassNamesOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId
    ):
        super().__init__(
            styleSheetId=style_sheet_id
        )


class CreateStyleSheetInput(InputModel):

    frameId: Page.FrameId
    force: bool | None = None


class CreateStyleSheetOutput(OutputModel):

    styleSheetId: DOM.StyleSheetId


class CreateStyleSheet(CDPMethod[CreateStyleSheetOutput]):
    """ Creates a new special "via-inspector" stylesheet in the frame with given `frameId`. """

    INPUT_VALIDATOR = CreateStyleSheetInput
    OUTPUT_VALIDATOR = CreateStyleSheetOutput

    def __init__(
        self,
        *,
        frame_id: Page.FrameId,
        force: bool | None = None
    ):
        super().__init__(
            frameId=frame_id,
            force=force
        )


class Disable(CDPMethod[None]):
    """ Disables the CSS agent for the given page. """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = None


class Enable(CDPMethod[None]):
    """ Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been
    enabled until the result of this command is received. """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = None


class ForcePseudoStateInput(InputModel):

    nodeId: DOM.NodeId
    forcedPseudoClasses: list[str]


class ForcePseudoState(CDPMethod[None]):
    """ Ensures that the given node will have specified pseudo-classes whenever its style is computed by
    the browser. """

    INPUT_VALIDATOR = ForcePseudoStateInput
    OUTPUT_VALIDATOR = None

    def __init__(
        self,
        *,
        node_id: DOM.NodeId,
        forced_pseudo_classes: list[str]
    ):
        super().__init__(
            nodeId=node_id,
            forcedPseudoClasses=forced_pseudo_classes
        )


class ForceStartingStyleInput(InputModel):

    nodeId: DOM.NodeId
    forced: bool


class ForceStartingStyle(CDPMethod[None]):
    """ Ensures that the given node is in its starting-style state. """

    INPUT_VALIDATOR = ForceStartingStyleInput
    OUTPUT_VALIDATOR = None

    def __init__(
        self,
        *,
        node_id: DOM.NodeId,
        forced: bool
    ):
        super().__init__(
            nodeId=node_id,
            forced=forced
        )


class GetBackgroundColorsInput(InputModel):

    nodeId: DOM.NodeId


class GetBackgroundColorsOutput(OutputModel):

    backgroundColors: list[str] | None = None
    computedFontSize: str | None = None
    computedFontWeight: str | None = None


class GetBackgroundColors(CDPMethod[GetBackgroundColorsOutput]):

    INPUT_VALIDATOR = GetBackgroundColorsInput
    OUTPUT_VALIDATOR = GetBackgroundColorsOutput

    def __init__(
        self,
        *,
        node_id: DOM.NodeId
    ):
        super().__init__(
            nodeId=node_id
        )


class GetComputedStyleForNodeInput(InputModel):

    nodeId: DOM.NodeId


class GetComputedStyleForNodeOutput(OutputModel):

    computedStyle: list[CSS.CSSComputedStyleProperty]
    extraFields: CSS.ComputedStyleExtraFields | None = None  # experimental


class GetComputedStyleForNode(CDPMethod[GetComputedStyleForNodeOutput]):
    """ Returns the computed style for a DOM node identified by `nodeId`. """

    INPUT_VALIDATOR = GetComputedStyleForNodeInput
    OUTPUT_VALIDATOR = GetComputedStyleForNodeOutput

    def __init__(
        self,
        *,
        node_id: DOM.NodeId
    ):
        super().__init__(
            nodeId=node_id
        )


class ResolveValuesInput(InputModel):

    values: list[str]
    nodeId: DOM.NodeId
    propertyName: str | None = None
    pseudoType: DOM.PseudoType | None = None
    pseudoIdentifier: str | None = None


class ResolveValuesOutput(OutputModel):

    results: list[str]


class ResolveValues(CDPMethod[ResolveValuesOutput]):  # experimental
    """ Resolve the specified values in the context of the provided element.
    For example, a value of '1em' is evaluated according to the computed
    'font-size' of the element and a value 'calc(1px + 2px)' will be
    resolved to '3px'.
    If the `propertyName` was specified the `values` are resolved as if
    they were property's declaration. If a value cannot be parsed according
    to the provided property syntax, the value is parsed using combined
    syntax as if null `propertyName` was provided. If the value cannot be
    resolved even then, return the provided value without any changes. """

    INPUT_VALIDATOR = ResolveValuesInput
    OUTPUT_VALIDATOR = ResolveValuesOutput

    def __init__(
        self,
        *,
        values: list[str],
        node_id: DOM.NodeId,
        property_name: str | None = None,
        pseudo_type: DOM.PseudoType | None = None,
        pseudo_identifier: str | None = None
    ):
        super().__init__(
            values=values,
            nodeId=node_id,
            propertyName=property_name,
            pseudoType=pseudo_type,
            pseudoIdentifier=pseudo_identifier
        )


class GetLonghandPropertiesInput(InputModel):

    shorthandName: str
    value: str


class GetLonghandPropertiesOutput(OutputModel):

    longhandProperties: list[CSS.CSSProperty]


class GetLonghandProperties(CDPMethod[GetLonghandPropertiesOutput]):  # experimental

    INPUT_VALIDATOR = GetLonghandPropertiesInput
    OUTPUT_VALIDATOR = GetLonghandPropertiesOutput

    def __init__(
        self,
        *,
        shorthand_name: str,
        value: str
    ):
        super().__init__(
            shorthandName=shorthand_name,
            value=value
        )


class GetInlineStylesForNodeInput(InputModel):

    nodeId: DOM.NodeId


class GetInlineStylesForNodeOutput(OutputModel):

    inlineStyle: CSS.CSSStyle | None = None
    attributesStyle: CSS.CSSStyle | None = None


class GetInlineStylesForNode(CDPMethod[GetInlineStylesForNodeOutput]):
    """ Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM
    attributes) for a DOM node identified by `nodeId`. """

    INPUT_VALIDATOR = GetInlineStylesForNodeInput
    OUTPUT_VALIDATOR = GetInlineStylesForNodeOutput

    def __init__(
        self,
        *,
        node_id: DOM.NodeId
    ):
        super().__init__(
            nodeId=node_id
        )


class GetAnimatedStylesForNodeInput(InputModel):

    nodeId: DOM.NodeId


class GetAnimatedStylesForNodeOutput(OutputModel):

    animationStyles: list[CSS.CSSAnimationStyle] | None = None
    transitionsStyle: CSS.CSSStyle | None = None
    inherited: list[CSS.InheritedAnimatedStyleEntry] | None = None


class GetAnimatedStylesForNode(CDPMethod[GetAnimatedStylesForNodeOutput]):  # experimental
    """ Returns the styles coming from animations & transitions
    including the animation & transition styles coming from inheritance chain. """

    INPUT_VALIDATOR = GetAnimatedStylesForNodeInput
    OUTPUT_VALIDATOR = GetAnimatedStylesForNodeOutput

    def __init__(
        self,
        *,
        node_id: DOM.NodeId
    ):
        super().__init__(
            nodeId=node_id
        )


class GetMatchedStylesForNodeInput(InputModel):

    nodeId: DOM.NodeId


class GetMatchedStylesForNodeOutput(OutputModel):

    inlineStyle: CSS.CSSStyle | None = None
    attributesStyle: CSS.CSSStyle | None = None
    matchedCSSRules: list[CSS.RuleMatch] | None = None
    pseudoElements: list[CSS.PseudoElementMatches] | None = None
    inherited: list[CSS.InheritedStyleEntry] | None = None
    inheritedPseudoElements: list[CSS.InheritedPseudoElementMatches] | None = None
    cssKeyframesRules: list[CSS.CSSKeyframesRule] | None = None
    cssPositionTryRules: list[CSS.CSSPositionTryRule] | None = None
    activePositionFallbackIndex: int | None = None
    cssPropertyRules: list[CSS.CSSPropertyRule] | None = None
    cssPropertyRegistrations: list[CSS.CSSPropertyRegistration] | None = None
    cssAtRules: list[CSS.CSSAtRule] | None = None
    parentLayoutNodeId: DOM.NodeId | None = None  # experimental
    cssFunctionRules: list[CSS.CSSFunctionRule] | None = None  # experimental


class GetMatchedStylesForNode(CDPMethod[GetMatchedStylesForNodeOutput]):
    """ Returns requested styles for a DOM node identified by `nodeId`. """

    INPUT_VALIDATOR = GetMatchedStylesForNodeInput
    OUTPUT_VALIDATOR = GetMatchedStylesForNodeOutput

    def __init__(
        self,
        *,
        node_id: DOM.NodeId
    ):
        super().__init__(
            nodeId=node_id
        )


class GetEnvironmentVariablesOutput(OutputModel):

    environmentVariables: JSON_DICT


class GetEnvironmentVariables(CDPMethod[GetEnvironmentVariablesOutput]):  # experimental
    """ Returns the values of the default UA-defined environment variables used in env() """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = GetEnvironmentVariablesOutput


class GetMediaQueriesOutput(OutputModel):

    medias: list[CSS.CSSMedia]


class GetMediaQueries(CDPMethod[GetMediaQueriesOutput]):
    """ Returns all media queries parsed by the rendering engine. """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = GetMediaQueriesOutput


class GetPlatformFontsForNodeInput(InputModel):

    nodeId: DOM.NodeId


class GetPlatformFontsForNodeOutput(OutputModel):

    fonts: list[CSS.PlatformFontUsage]


class GetPlatformFontsForNode(CDPMethod[GetPlatformFontsForNodeOutput]):
    """ Requests information about platform fonts which we used to render child TextNodes in the given
    node. """

    INPUT_VALIDATOR = GetPlatformFontsForNodeInput
    OUTPUT_VALIDATOR = GetPlatformFontsForNodeOutput

    def __init__(
        self,
        *,
        node_id: DOM.NodeId
    ):
        super().__init__(
            nodeId=node_id
        )


class GetStyleSheetTextInput(InputModel):

    styleSheetId: DOM.StyleSheetId


class GetStyleSheetTextOutput(OutputModel):

    text: str


class GetStyleSheetText(CDPMethod[GetStyleSheetTextOutput]):
    """ Returns the current textual content for a stylesheet. """

    INPUT_VALIDATOR = GetStyleSheetTextInput
    OUTPUT_VALIDATOR = GetStyleSheetTextOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId
    ):
        super().__init__(
            styleSheetId=style_sheet_id
        )


class GetLayersForNodeInput(InputModel):

    nodeId: DOM.NodeId


class GetLayersForNodeOutput(OutputModel):

    rootLayer: CSS.CSSLayerData


class GetLayersForNode(CDPMethod[GetLayersForNodeOutput]):  # experimental
    """ Returns all layers parsed by the rendering engine for the tree scope of a node.
    Given a DOM element identified by nodeId, getLayersForNode returns the root
    layer for the nearest ancestor document or shadow root. The layer root contains
    the full layer tree for the tree scope and their ordering. """

    INPUT_VALIDATOR = GetLayersForNodeInput
    OUTPUT_VALIDATOR = GetLayersForNodeOutput

    def __init__(
        self,
        *,
        node_id: DOM.NodeId
    ):
        super().__init__(
            nodeId=node_id
        )


class GetLocationForSelectorInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    selectorText: str


class GetLocationForSelectorOutput(OutputModel):

    ranges: list[CSS.SourceRange]


class GetLocationForSelector(CDPMethod[GetLocationForSelectorOutput]):  # experimental
    """ Given a CSS selector text and a style sheet ID, getLocationForSelector
    returns an array of locations of the CSS selector in the style sheet. """

    INPUT_VALIDATOR = GetLocationForSelectorInput
    OUTPUT_VALIDATOR = GetLocationForSelectorOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        selector_text: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            selectorText=selector_text
        )


class TrackComputedStyleUpdatesForNodeInput(InputModel):

    nodeId: DOM.NodeId | None = None


class TrackComputedStyleUpdatesForNode(CDPMethod[None]):  # experimental
    """ Starts tracking the given node for the computed style updates
    and whenever the computed style is updated for node, it queues
    a `computedStyleUpdated` event with throttling.
    There can only be 1 node tracked for computed style updates
    so passing a new node id removes tracking from the previous node.
    Pass `undefined` to disable tracking. """

    INPUT_VALIDATOR = TrackComputedStyleUpdatesForNodeInput
    OUTPUT_VALIDATOR = None

    def __init__(
        self,
        *,
        node_id: DOM.NodeId | None = None
    ):
        super().__init__(
            nodeId=node_id
        )


class TrackComputedStyleUpdatesInput(InputModel):

    propertiesToTrack: list[CSS.CSSComputedStyleProperty]


class TrackComputedStyleUpdates(CDPMethod[None]):  # experimental
    """ Starts tracking the given computed styles for updates. The specified array of properties
    replaces the one previously specified. Pass empty array to disable tracking.
    Use takeComputedStyleUpdates to retrieve the list of nodes that had properties modified.
    The changes to computed style properties are only tracked for nodes pushed to the front-end
    by the DOM agent. If no changes to the tracked properties occur after the node has been pushed
    to the front-end, no updates will be issued for the node. """

    INPUT_VALIDATOR = TrackComputedStyleUpdatesInput
    OUTPUT_VALIDATOR = None

    def __init__(
        self,
        *,
        properties_to_track: list[CSS.CSSComputedStyleProperty]
    ):
        super().__init__(
            propertiesToTrack=properties_to_track
        )


class TakeComputedStyleUpdatesOutput(OutputModel):

    nodeIds: list[DOM.NodeId]


class TakeComputedStyleUpdates(CDPMethod[TakeComputedStyleUpdatesOutput]):  # experimental
    """ Polls the next batch of computed style updates. """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = TakeComputedStyleUpdatesOutput


class SetEffectivePropertyValueForNodeInput(InputModel):

    nodeId: DOM.NodeId
    propertyName: str
    value: str


class SetEffectivePropertyValueForNode(CDPMethod[None]):
    """ Find a rule with the given active property for the given node and set the new value for this
    property """

    INPUT_VALIDATOR = SetEffectivePropertyValueForNodeInput
    OUTPUT_VALIDATOR = None

    def __init__(
        self,
        *,
        node_id: DOM.NodeId,
        property_name: str,
        value: str
    ):
        super().__init__(
            nodeId=node_id,
            propertyName=property_name,
            value=value
        )


class SetPropertyRulePropertyNameInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    range: CSS.SourceRange
    propertyName: str


class SetPropertyRulePropertyNameOutput(OutputModel):

    propertyName: CSS.Value


class SetPropertyRulePropertyName(CDPMethod[SetPropertyRulePropertyNameOutput]):
    """ Modifies the property rule property name. """

    INPUT_VALIDATOR = SetPropertyRulePropertyNameInput
    OUTPUT_VALIDATOR = SetPropertyRulePropertyNameOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        range_: CSS.SourceRange,
        property_name: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            range=range_,
            propertyName=property_name
        )


class SetKeyframeKeyInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    range: CSS.SourceRange
    keyText: str


class SetKeyframeKeyOutput(OutputModel):

    keyText: CSS.Value


class SetKeyframeKey(CDPMethod[SetKeyframeKeyOutput]):
    """ Modifies the keyframe rule key text. """

    INPUT_VALIDATOR = SetKeyframeKeyInput
    OUTPUT_VALIDATOR = SetKeyframeKeyOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        range_: CSS.SourceRange,
        key_text: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            range=range_,
            keyText=key_text
        )


class SetMediaTextInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    range: CSS.SourceRange
    text: str


class SetMediaTextOutput(OutputModel):

    media: CSS.CSSMedia


class SetMediaText(CDPMethod[SetMediaTextOutput]):
    """ Modifies the rule selector. """

    INPUT_VALIDATOR = SetMediaTextInput
    OUTPUT_VALIDATOR = SetMediaTextOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        range_: CSS.SourceRange,
        text: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            range=range_,
            text=text
        )


class SetContainerQueryTextInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    range: CSS.SourceRange
    text: str


class SetContainerQueryTextOutput(OutputModel):

    containerQuery: CSS.CSSContainerQuery


class SetContainerQueryText(CDPMethod[SetContainerQueryTextOutput]):  # experimental
    """ Modifies the expression of a container query. """

    INPUT_VALIDATOR = SetContainerQueryTextInput
    OUTPUT_VALIDATOR = SetContainerQueryTextOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        range_: CSS.SourceRange,
        text: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            range=range_,
            text=text
        )


class SetSupportsTextInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    range: CSS.SourceRange
    text: str


class SetSupportsTextOutput(OutputModel):

    supports: CSS.CSSSupports


class SetSupportsText(CDPMethod[SetSupportsTextOutput]):  # experimental
    """ Modifies the expression of a supports at-rule. """

    INPUT_VALIDATOR = SetSupportsTextInput
    OUTPUT_VALIDATOR = SetSupportsTextOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        range_: CSS.SourceRange,
        text: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            range=range_,
            text=text
        )


class SetScopeTextInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    range: CSS.SourceRange
    text: str


class SetScopeTextOutput(OutputModel):

    scope: CSS.CSSScope


class SetScopeText(CDPMethod[SetScopeTextOutput]):  # experimental
    """ Modifies the expression of a scope at-rule. """

    INPUT_VALIDATOR = SetScopeTextInput
    OUTPUT_VALIDATOR = SetScopeTextOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        range_: CSS.SourceRange,
        text: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            range=range_,
            text=text
        )


class SetRuleSelectorInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    range: CSS.SourceRange
    selector: str


class SetRuleSelectorOutput(OutputModel):

    selectorList: CSS.SelectorList


class SetRuleSelector(CDPMethod[SetRuleSelectorOutput]):
    """ Modifies the rule selector. """

    INPUT_VALIDATOR = SetRuleSelectorInput
    OUTPUT_VALIDATOR = SetRuleSelectorOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        range_: CSS.SourceRange,
        selector: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            range=range_,
            selector=selector
        )


class SetStyleSheetTextInput(InputModel):

    styleSheetId: DOM.StyleSheetId
    text: str


class SetStyleSheetTextOutput(OutputModel):

    sourceMapURL: str | None = None


class SetStyleSheetText(CDPMethod[SetStyleSheetTextOutput]):
    """ Sets the new stylesheet text. """

    INPUT_VALIDATOR = SetStyleSheetTextInput
    OUTPUT_VALIDATOR = SetStyleSheetTextOutput

    def __init__(
        self,
        *,
        style_sheet_id: DOM.StyleSheetId,
        text: str
    ):
        super().__init__(
            styleSheetId=style_sheet_id,
            text=text
        )


class SetStyleTextsInput(InputModel):

    edits: list[CSS.StyleDeclarationEdit]
    nodeForPropertySyntaxValidation: DOM.NodeId | None = None  # experimental


class SetStyleTextsOutput(OutputModel):

    styles: list[CSS.CSSStyle]


class SetStyleTexts(CDPMethod[SetStyleTextsOutput]):
    """ Applies specified style edits one after another in the given order. """

    INPUT_VALIDATOR = SetStyleTextsInput
    OUTPUT_VALIDATOR = SetStyleTextsOutput

    def __init__(
        self,
        *,
        edits: list[CSS.StyleDeclarationEdit],
        node_for_property_syntax_validation: DOM.NodeId | None = None
    ):
        super().__init__(
            edits=edits,
            nodeForPropertySyntaxValidation=node_for_property_syntax_validation
        )


class StartRuleUsageTracking(CDPMethod[None]):
    """ Enables the selector recording. """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = None


class StopRuleUsageTrackingOutput(OutputModel):

    ruleUsage: list[CSS.RuleUsage]


class StopRuleUsageTracking(CDPMethod[StopRuleUsageTrackingOutput]):
    """ Stop tracking rule usage and return the list of rules that were used since last call to
    `takeCoverageDelta` (or since start of coverage instrumentation). """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = StopRuleUsageTrackingOutput


class TakeCoverageDeltaOutput(OutputModel):

    coverage: list[CSS.RuleUsage]
    timestamp: float


class TakeCoverageDelta(CDPMethod[TakeCoverageDeltaOutput]):
    """ Obtain list of rules that became used since last call to this method (or since start of coverage
    instrumentation). """

    INPUT_VALIDATOR = None
    OUTPUT_VALIDATOR = TakeCoverageDeltaOutput


class SetLocalFontsEnabledInput(InputModel):

    enabled: bool


class SetLocalFontsEnabled(CDPMethod[None]):  # experimental
    """ Enables/disables rendering of local CSS fonts (enabled by default). """

    INPUT_VALIDATOR = SetLocalFontsEnabledInput
    OUTPUT_VALIDATOR = None

    def __init__(
        self,
        *,
        enabled: bool
    ):
        super().__init__(
            enabled=enabled
        )
