chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/accessibility/methods/service.py

@@ -0,0 +1,109 @@
+"""CDP Accessibility Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class AccessibilityMethods:
+    """
+    Methods for the Accessibility domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Accessibility methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables the accessibility domain.    
+        Args:
+            params (None, optional): Parameters for the disable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disable call.
+        """
+        return await self.client.send(method="Accessibility.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls. This turns on accessibility for the page, which can impact performance until accessibility is disabled.    
+        Args:
+            params (None, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="Accessibility.enable", params=params,session_id=session_id)
+    async def get_partial_ax_tree(self, params: Optional[getPartialAXTreeParameters]=None,session_id: Optional[str] = None) -> getPartialAXTreeReturns:
+        """
+    Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.    
+        Args:
+            params (getPartialAXTreeParameters, optional): Parameters for the getPartialAXTree method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getPartialAXTreeReturns: The result of the getPartialAXTree call.
+        """
+        return await self.client.send(method="Accessibility.getPartialAXTree", params=params,session_id=session_id)
+    async def get_full_ax_tree(self, params: Optional[getFullAXTreeParameters]=None,session_id: Optional[str] = None) -> getFullAXTreeReturns:
+        """
+    Fetches the entire accessibility tree for the root Document    
+        Args:
+            params (getFullAXTreeParameters, optional): Parameters for the getFullAXTree method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getFullAXTreeReturns: The result of the getFullAXTree call.
+        """
+        return await self.client.send(method="Accessibility.getFullAXTree", params=params,session_id=session_id)
+    async def get_root_ax_node(self, params: Optional[getRootAXNodeParameters]=None,session_id: Optional[str] = None) -> getRootAXNodeReturns:
+        """
+    Fetches the root node. Requires `enable()` to have been called previously.    
+        Args:
+            params (getRootAXNodeParameters, optional): Parameters for the getRootAXNode method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getRootAXNodeReturns: The result of the getRootAXNode call.
+        """
+        return await self.client.send(method="Accessibility.getRootAXNode", params=params,session_id=session_id)
+    async def get_ax_node_and_ancestors(self, params: Optional[getAXNodeAndAncestorsParameters]=None,session_id: Optional[str] = None) -> getAXNodeAndAncestorsReturns:
+        """
+    Fetches a node and all ancestors up to and including the root. Requires `enable()` to have been called previously.    
+        Args:
+            params (getAXNodeAndAncestorsParameters, optional): Parameters for the getAXNodeAndAncestors method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getAXNodeAndAncestorsReturns: The result of the getAXNodeAndAncestors call.
+        """
+        return await self.client.send(method="Accessibility.getAXNodeAndAncestors", params=params,session_id=session_id)
+    async def get_child_ax_nodes(self, params: Optional[getChildAXNodesParameters]=None,session_id: Optional[str] = None) -> getChildAXNodesReturns:
+        """
+    Fetches a particular accessibility node by AXNodeId. Requires `enable()` to have been called previously.    
+        Args:
+            params (getChildAXNodesParameters, optional): Parameters for the getChildAXNodes method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getChildAXNodesReturns: The result of the getChildAXNodes call.
+        """
+        return await self.client.send(method="Accessibility.getChildAXNodes", params=params,session_id=session_id)
+    async def query_ax_tree(self, params: Optional[queryAXTreeParameters]=None,session_id: Optional[str] = None) -> queryAXTreeReturns:
+        """
+    Query a DOM node's accessibility subtree for accessible name and role. This command computes the name and role for all nodes in the subtree, including those that are ignored for accessibility, and returns those that match the specified name and role. If no DOM node is specified, or the DOM node does not exist, the command returns an error. If neither `accessibleName` or `role` is specified, it returns all the accessibility nodes in the subtree.    
+        Args:
+            params (queryAXTreeParameters, optional): Parameters for the queryAXTree method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    queryAXTreeReturns: The result of the queryAXTree call.
+        """
+        return await self.client.send(method="Accessibility.queryAXTree", params=params,session_id=session_id)

cdp/protocol/accessibility/methods/types.py

@@ -0,0 +1,70 @@
+"""CDP Accessibility Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.accessibility.types import AXNode
+    from cdp.protocol.accessibility.types import AXNodeId
+    from cdp.protocol.dom.types import BackendNodeId
+    from cdp.protocol.dom.types import NodeId
+    from cdp.protocol.page.types import FrameId
+    from cdp.protocol.runtime.types import RemoteObjectId
+
+
+
+class getPartialAXTreeParameters(TypedDict, total=False):
+    nodeId: NotRequired['NodeId']
+    """Identifier of the node to get the partial accessibility tree for."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """Identifier of the backend node to get the partial accessibility tree for."""
+    objectId: NotRequired['RemoteObjectId']
+    """JavaScript object id of the node wrapper to get the partial accessibility tree for."""
+    fetchRelatives: NotRequired['bool']
+    """Whether to fetch this node's ancestors, siblings and children. Defaults to true."""
+class getFullAXTreeParameters(TypedDict, total=False):
+    depth: NotRequired['int']
+    """The maximum depth at which descendants of the root node should be retrieved. If omitted, the full tree is returned."""
+    frameId: NotRequired['FrameId']
+    """The frame for whose document the AX tree should be retrieved. If omitted, the root frame is used."""
+class getRootAXNodeParameters(TypedDict, total=False):
+    frameId: NotRequired['FrameId']
+    """The frame in whose document the node resides. If omitted, the root frame is used."""
+class getAXNodeAndAncestorsParameters(TypedDict, total=False):
+    nodeId: NotRequired['NodeId']
+    """Identifier of the node to get."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """Identifier of the backend node to get."""
+    objectId: NotRequired['RemoteObjectId']
+    """JavaScript object id of the node wrapper to get."""
+class getChildAXNodesParameters(TypedDict, total=True):
+    id: 'AXNodeId'
+    frameId: NotRequired['FrameId']
+    """The frame in whose document the node resides. If omitted, the root frame is used."""
+class queryAXTreeParameters(TypedDict, total=False):
+    nodeId: NotRequired['NodeId']
+    """Identifier of the node for the root to query."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """Identifier of the backend node for the root to query."""
+    objectId: NotRequired['RemoteObjectId']
+    """JavaScript object id of the node wrapper for the root to query."""
+    accessibleName: NotRequired['str']
+    """Find nodes with this computed name."""
+    role: NotRequired['str']
+    """Find nodes with this computed role."""
+
+
+class getPartialAXTreeReturns(TypedDict):
+    nodes: 'List[AXNode]'
+    """The Accessibility.AXNode for this DOM node, if it exists, plus its ancestors, siblings and children, if requested."""
+class getFullAXTreeReturns(TypedDict):
+    nodes: 'List[AXNode]'
+class getRootAXNodeReturns(TypedDict):
+    node: 'AXNode'
+class getAXNodeAndAncestorsReturns(TypedDict):
+    nodes: 'List[AXNode]'
+class getChildAXNodesReturns(TypedDict):
+    nodes: 'List[AXNode]'
+class queryAXTreeReturns(TypedDict):
+    nodes: 'List[AXNode]'
+    """A list of Accessibility.AXNode matching the specified attributes, including nodes that are ignored for accessibility."""

cdp/protocol/accessibility/service.py

@@ -0,0 +1,21 @@
+"""CDP Accessibility Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import AccessibilityMethods
+from .events.service import AccessibilityEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Accessibility(AccessibilityMethods, AccessibilityEvents):
+    """
+    Access the Accessibility domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Accessibility domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        AccessibilityMethods.__init__(self, client)
+        AccessibilityEvents.__init__(self, client)

cdp/protocol/accessibility/types.py

@@ -0,0 +1,89 @@
+"""CDP Accessibility Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.dom.types import BackendNodeId
+    from cdp.protocol.page.types import FrameId
+
+AXNodeId = str
+"""Unique accessibility node identifier."""
+AXValueType = Literal['boolean','tristate','booleanOrUndefined','idref','idrefList','integer','node','nodeList','number','string','computedString','token','tokenList','domRelation','role','internalRole','valueUndefined']
+"""Enum of possible property types."""
+AXValueSourceType = Literal['attribute','implicit','style','contents','placeholder','relatedElement']
+"""Enum of possible property sources."""
+AXValueNativeSourceType = Literal['description','figcaption','label','labelfor','labelwrapped','legend','rubyannotation','tablecaption','title','other']
+"""Enum of possible native property sources (as a subtype of a particular AXValueSourceType)."""
+class AXValueSource(TypedDict, total=True):
+    """A single source for a computed AX property."""
+    type: 'AXValueSourceType'
+    """What type of source this is."""
+    value: NotRequired['AXValue']
+    """The value of this property source."""
+    attribute: NotRequired['str']
+    """The name of the relevant attribute, if any."""
+    attributeValue: NotRequired['AXValue']
+    """The value of the relevant attribute, if any."""
+    superseded: NotRequired['bool']
+    """Whether this source is superseded by a higher priority source."""
+    nativeSource: NotRequired['AXValueNativeSourceType']
+    """The native markup source for this value, e.g. a <label> element."""
+    nativeSourceValue: NotRequired['AXValue']
+    """The value, such as a node or node list, of the native source."""
+    invalid: NotRequired['bool']
+    """Whether the value for this property is invalid."""
+    invalidReason: NotRequired['str']
+    """Reason for the value being invalid, if it is."""
+class AXRelatedNode(TypedDict, total=True):
+    backendDOMNodeId: 'BackendNodeId'
+    """The BackendNodeId of the related DOM node."""
+    idref: NotRequired['str']
+    """The IDRef value provided, if any."""
+    text: NotRequired['str']
+    """The text alternative of this node in the current context."""
+class AXProperty(TypedDict, total=True):
+    name: 'AXPropertyName'
+    """The name of this property."""
+    value: 'AXValue'
+    """The value of this property."""
+class AXValue(TypedDict, total=True):
+    """A single computed AX property."""
+    type: 'AXValueType'
+    """The type of this value."""
+    value: NotRequired['Any']
+    """The computed value of this property."""
+    relatedNodes: NotRequired['List[AXRelatedNode]']
+    """One or more related nodes, if applicable."""
+    sources: NotRequired['List[AXValueSource]']
+    """The sources which contributed to the computation of this property."""
+AXPropertyName = Literal['actions','busy','disabled','editable','focusable','focused','hidden','hiddenRoot','invalid','keyshortcuts','settable','roledescription','live','atomic','relevant','root','autocomplete','hasPopup','level','multiselectable','orientation','multiline','readonly','required','valuemin','valuemax','valuetext','checked','expanded','modal','pressed','selected','activedescendant','controls','describedby','details','errormessage','flowto','labelledby','owns','url','activeFullscreenElement','activeModalDialog','activeAriaModalDialog','ariaHiddenElement','ariaHiddenSubtree','emptyAlt','emptyText','inertElement','inertSubtree','labelContainer','labelFor','notRendered','notVisible','presentationalRole','probablyPresentational','inactiveCarouselTabContent','uninteresting']
+"""Values of AXProperty name: - from 'busy' to 'roledescription': states which apply to every AX node - from 'live' to 'root': attributes which apply to nodes in live regions - from 'autocomplete' to 'valuetext': attributes which apply to widgets - from 'checked' to 'selected': states which apply to widgets - from 'activedescendant' to 'owns': relationships between elements other than parent/child/sibling - from 'activeFullscreenElement' to 'uninteresting': reasons why this noode is hidden"""
+class AXNode(TypedDict, total=True):
+    """A node in the accessibility tree."""
+    nodeId: 'AXNodeId'
+    """Unique identifier for this node."""
+    ignored: 'bool'
+    """Whether this node is ignored for accessibility"""
+    ignoredReasons: NotRequired['List[AXProperty]']
+    """Collection of reasons why this node is hidden."""
+    role: NotRequired['AXValue']
+    """This Node's role, whether explicit or implicit."""
+    chromeRole: NotRequired['AXValue']
+    """This Node's Chrome raw role."""
+    name: NotRequired['AXValue']
+    """The accessible name for this Node."""
+    description: NotRequired['AXValue']
+    """The accessible description for this Node."""
+    value: NotRequired['AXValue']
+    """The value for this Node."""
+    properties: NotRequired['List[AXProperty]']
+    """All other properties"""
+    parentId: NotRequired['AXNodeId']
+    """ID for this node's parent."""
+    childIds: NotRequired['List[AXNodeId]']
+    """IDs for each of this node's child nodes."""
+    backendDOMNodeId: NotRequired['BackendNodeId']
+    """The backend ID for the associated DOM node, if any."""
+    frameId: NotRequired['FrameId']
+    """The frame ID for the frame associated with this nodes document."""

cdp/protocol/animation/events/service.py

@@ -0,0 +1,53 @@
+"""CDP Animation Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class AnimationEvents:
+    """
+    Events for the Animation domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Animation events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_animation_canceled(self, callback: Callable[[animationCanceledEvent,Optional[str]], None]=None) -> None:
+        """
+    Event for when an animation has been cancelled.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: animationCanceledEvent, session_id: Optional[str]).
+        """
+        self.client.on('Animation.animationCanceled', callback)
+    def on_animation_created(self, callback: Callable[[animationCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Event for each animation that has been created.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: animationCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Animation.animationCreated', callback)
+    def on_animation_started(self, callback: Callable[[animationStartedEvent,Optional[str]], None]=None) -> None:
+        """
+    Event for animation that has been started.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: animationStartedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Animation.animationStarted', callback)
+    def on_animation_updated(self, callback: Callable[[animationUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Event for animation that has been updated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: animationUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Animation.animationUpdated', callback)

cdp/protocol/animation/events/types.py

@@ -0,0 +1,20 @@
+"""CDP Animation Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.animation.types import Animation
+
+class animationCanceledEvent(TypedDict, total=True):
+    id: 'str'
+    """Id of the animation that was cancelled."""
+class animationCreatedEvent(TypedDict, total=True):
+    id: 'str'
+    """Id of the animation that was created."""
+class animationStartedEvent(TypedDict, total=True):
+    animation: 'Animation'
+    """Animation that was started."""
+class animationUpdatedEvent(TypedDict, total=True):
+    animation: 'Animation'
+    """Animation that was updated."""

cdp/protocol/animation/methods/service.py

@@ -0,0 +1,131 @@
+"""CDP Animation Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class AnimationMethods:
+    """
+    Methods for the Animation domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Animation methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables animation domain notifications.    
+        Args:
+            params (None, optional): Parameters for the disable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disable call.
+        """
+        return await self.client.send(method="Animation.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables animation domain notifications.    
+        Args:
+            params (None, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="Animation.enable", params=params,session_id=session_id)
+    async def get_current_time(self, params: Optional[getCurrentTimeParameters]=None,session_id: Optional[str] = None) -> getCurrentTimeReturns:
+        """
+    Returns the current time of the an animation.    
+        Args:
+            params (getCurrentTimeParameters, optional): Parameters for the getCurrentTime method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getCurrentTimeReturns: The result of the getCurrentTime call.
+        """
+        return await self.client.send(method="Animation.getCurrentTime", params=params,session_id=session_id)
+    async def get_playback_rate(self, params: None=None,session_id: Optional[str] = None) -> getPlaybackRateReturns:
+        """
+    Gets the playback rate of the document timeline.    
+        Args:
+            params (None, optional): Parameters for the getPlaybackRate method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getPlaybackRateReturns: The result of the getPlaybackRate call.
+        """
+        return await self.client.send(method="Animation.getPlaybackRate", params=params,session_id=session_id)
+    async def release_animations(self, params: Optional[releaseAnimationsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Releases a set of animations to no longer be manipulated.    
+        Args:
+            params (releaseAnimationsParameters, optional): Parameters for the releaseAnimations method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the releaseAnimations call.
+        """
+        return await self.client.send(method="Animation.releaseAnimations", params=params,session_id=session_id)
+    async def resolve_animation(self, params: Optional[resolveAnimationParameters]=None,session_id: Optional[str] = None) -> resolveAnimationReturns:
+        """
+    Gets the remote object of the Animation.    
+        Args:
+            params (resolveAnimationParameters, optional): Parameters for the resolveAnimation method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    resolveAnimationReturns: The result of the resolveAnimation call.
+        """
+        return await self.client.send(method="Animation.resolveAnimation", params=params,session_id=session_id)
+    async def seek_animations(self, params: Optional[seekAnimationsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Seek a set of animations to a particular time within each animation.    
+        Args:
+            params (seekAnimationsParameters, optional): Parameters for the seekAnimations method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the seekAnimations call.
+        """
+        return await self.client.send(method="Animation.seekAnimations", params=params,session_id=session_id)
+    async def set_paused(self, params: Optional[setPausedParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets the paused state of a set of animations.    
+        Args:
+            params (setPausedParameters, optional): Parameters for the setPaused method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setPaused call.
+        """
+        return await self.client.send(method="Animation.setPaused", params=params,session_id=session_id)
+    async def set_playback_rate(self, params: Optional[setPlaybackRateParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets the playback rate of the document timeline.    
+        Args:
+            params (setPlaybackRateParameters, optional): Parameters for the setPlaybackRate method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setPlaybackRate call.
+        """
+        return await self.client.send(method="Animation.setPlaybackRate", params=params,session_id=session_id)
+    async def set_timing(self, params: Optional[setTimingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets the timing of an animation node.    
+        Args:
+            params (setTimingParameters, optional): Parameters for the setTiming method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setTiming call.
+        """
+        return await self.client.send(method="Animation.setTiming", params=params,session_id=session_id)

cdp/protocol/animation/methods/types.py

@@ -0,0 +1,52 @@
+"""CDP Animation Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.runtime.types import RemoteObject
+
+
+
+class getCurrentTimeParameters(TypedDict, total=True):
+    id: 'str'
+    """Id of animation."""
+
+class releaseAnimationsParameters(TypedDict, total=True):
+    animations: 'List[str]'
+    """List of animation ids to seek."""
+class resolveAnimationParameters(TypedDict, total=True):
+    animationId: 'str'
+    """Animation id."""
+class seekAnimationsParameters(TypedDict, total=True):
+    animations: 'List[str]'
+    """List of animation ids to seek."""
+    currentTime: 'float'
+    """Set the current time of each animation."""
+class setPausedParameters(TypedDict, total=True):
+    animations: 'List[str]'
+    """Animations to set the pause state of."""
+    paused: 'bool'
+    """Paused state to set to."""
+class setPlaybackRateParameters(TypedDict, total=True):
+    playbackRate: 'float'
+    """Playback rate for animations on page"""
+class setTimingParameters(TypedDict, total=True):
+    animationId: 'str'
+    """Animation id."""
+    duration: 'float'
+    """Duration of the animation."""
+    delay: 'float'
+    """Delay of the animation."""
+
+
+class getCurrentTimeReturns(TypedDict):
+    currentTime: 'float'
+    """Current time of the page."""
+class getPlaybackRateReturns(TypedDict):
+    playbackRate: 'float'
+    """Playback rate for animations on page."""
+
+class resolveAnimationReturns(TypedDict):
+    remoteObject: 'RemoteObject'
+    """Corresponding remote object."""

cdp/protocol/animation/service.py

@@ -0,0 +1,21 @@
+"""CDP Animation Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import AnimationMethods
+from .events.service import AnimationEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Animation(AnimationMethods, AnimationEvents):
+    """
+    Access the Animation domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Animation domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        AnimationMethods.__init__(self, client)
+        AnimationEvents.__init__(self, client)