parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/preload/types.py

@@ -0,0 +1,267 @@
+"""Custom types and enums for the Preload domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+if TYPE_CHECKING:
+    from ..dom.types import BackendNodeId as DOM_BackendNodeId
+    from ..network.types import LoaderId as Network_LoaderId
+    from ..network.types import RequestId as Network_RequestId
+
+type RuleSetId = str  # Unique id
+
+
+@register("Preload.RuleSet")
+@dataclass
+class RuleSet(DataType):
+    """Corresponds to SpeculationRuleSet"""
+    id: RuleSetId
+    loader_id: Network_LoaderId
+    source_text: str
+    backend_node_id: Optional[DOM_BackendNodeId] = None
+    url: Optional[str] = None
+    request_id: Optional[Network_RequestId] = None
+    error_type: Optional[RuleSetErrorType] = None
+    error_message: Optional[str] = None
+    tag: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('loader_id', 'loaderId', False, 'primitive'),
+        FieldMeta('source_text', 'sourceText', False, 'primitive'),
+        FieldMeta('backend_node_id', 'backendNodeId', True, 'primitive'),
+        FieldMeta('url', 'url', True, 'primitive'),
+        FieldMeta('request_id', 'requestId', True, 'primitive'),
+        FieldMeta('error_type', 'errorType', True, 'enum', ref='Preload.RuleSetErrorType'),
+        FieldMeta('error_message', 'errorMessage', True, 'primitive'),
+        FieldMeta('tag', 'tag', True, 'primitive'),
+    )
+
+
+@register("Preload.RuleSetErrorType")
+class RuleSetErrorType(str, Enum):
+    SOURCEISNOTJSONOBJECT = 'SourceIsNotJsonObject'
+    INVALIDRULESSKIPPED = 'InvalidRulesSkipped'
+    INVALIDRULESETLEVELTAG = 'InvalidRulesetLevelTag'
+
+
+@register("Preload.SpeculationAction")
+class SpeculationAction(str, Enum):
+    """
+    The type of preloading attempted. It corresponds to
+    mojom::SpeculationAction (although PrefetchWithSubresources is omitted as it
+    isn't being used by clients).
+    """
+    PREFETCH = 'Prefetch'
+    PRERENDER = 'Prerender'
+    PRERENDERUNTILSCRIPT = 'PrerenderUntilScript'
+
+
+@register("Preload.SpeculationTargetHint")
+class SpeculationTargetHint(str, Enum):
+    """
+    Corresponds to mojom::SpeculationTargetHint.
+    See https://github.com/WICG/nav-speculation/blob/main/triggers.md#window-name-targeting-hints
+    """
+    BLANK = 'Blank'
+    SELF = 'Self'
+
+
+@register("Preload.PreloadingAttemptKey")
+@dataclass
+class PreloadingAttemptKey(DataType):
+    """
+    A key that identifies a preloading attempt.
+    
+    The url used is the url specified by the trigger (i.e. the initial URL), and
+    not the final url that is navigated to. For example, prerendering allows
+    same-origin main frame navigations during the attempt, but the attempt is
+    still keyed with the initial URL.
+    """
+    loader_id: Network_LoaderId
+    action: SpeculationAction
+    url: str
+    target_hint: Optional[SpeculationTargetHint] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('loader_id', 'loaderId', False, 'primitive'),
+        FieldMeta('action', 'action', False, 'enum', ref='Preload.SpeculationAction'),
+        FieldMeta('url', 'url', False, 'primitive'),
+        FieldMeta('target_hint', 'targetHint', True, 'enum', ref='Preload.SpeculationTargetHint'),
+    )
+
+
+@register("Preload.PreloadingAttemptSource")
+@dataclass
+class PreloadingAttemptSource(DataType):
+    """
+    Lists sources for a preloading attempt, specifically the ids of rule sets
+    that had a speculation rule that triggered the attempt, and the
+    BackendNodeIds of <a href> or <area href> elements that triggered the
+    attempt (in the case of attempts triggered by a document rule). It is
+    possible for multiple rule sets and links to trigger a single attempt.
+    """
+    key: PreloadingAttemptKey
+    rule_set_ids: List[RuleSetId]
+    node_ids: List[DOM_BackendNodeId]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('key', 'key', False, 'object', ref='Preload.PreloadingAttemptKey'),
+        FieldMeta('rule_set_ids', 'ruleSetIds', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('node_ids', 'nodeIds', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+type PreloadPipelineId = str  # Chrome manages different types of preloads together using a
+
+
+@register("Preload.PrerenderFinalStatus")
+class PrerenderFinalStatus(str, Enum):
+    """List of FinalStatus reasons for Prerender2."""
+    ACTIVATED = 'Activated'
+    DESTROYED = 'Destroyed'
+    LOWENDDEVICE = 'LowEndDevice'
+    INVALIDSCHEMEREDIRECT = 'InvalidSchemeRedirect'
+    INVALIDSCHEMENAVIGATION = 'InvalidSchemeNavigation'
+    NAVIGATIONREQUESTBLOCKEDBYCSP = 'NavigationRequestBlockedByCsp'
+    MOJOBINDERPOLICY = 'MojoBinderPolicy'
+    RENDERERPROCESSCRASHED = 'RendererProcessCrashed'
+    RENDERERPROCESSKILLED = 'RendererProcessKilled'
+    DOWNLOAD = 'Download'
+    TRIGGERDESTROYED = 'TriggerDestroyed'
+    NAVIGATIONNOTCOMMITTED = 'NavigationNotCommitted'
+    NAVIGATIONBADHTTPSTATUS = 'NavigationBadHttpStatus'
+    CLIENTCERTREQUESTED = 'ClientCertRequested'
+    NAVIGATIONREQUESTNETWORKERROR = 'NavigationRequestNetworkError'
+    CANCELALLHOSTSFORTESTING = 'CancelAllHostsForTesting'
+    DIDFAILLOAD = 'DidFailLoad'
+    STOP = 'Stop'
+    SSLCERTIFICATEERROR = 'SslCertificateError'
+    LOGINAUTHREQUESTED = 'LoginAuthRequested'
+    UACHANGEREQUIRESRELOAD = 'UaChangeRequiresReload'
+    BLOCKEDBYCLIENT = 'BlockedByClient'
+    AUDIOOUTPUTDEVICEREQUESTED = 'AudioOutputDeviceRequested'
+    MIXEDCONTENT = 'MixedContent'
+    TRIGGERBACKGROUNDED = 'TriggerBackgrounded'
+    MEMORYLIMITEXCEEDED = 'MemoryLimitExceeded'
+    DATASAVERENABLED = 'DataSaverEnabled'
+    TRIGGERURLHASEFFECTIVEURL = 'TriggerUrlHasEffectiveUrl'
+    ACTIVATEDBEFORESTARTED = 'ActivatedBeforeStarted'
+    INACTIVEPAGERESTRICTION = 'InactivePageRestriction'
+    STARTFAILED = 'StartFailed'
+    TIMEOUTBACKGROUNDED = 'TimeoutBackgrounded'
+    CROSSSITEREDIRECTININITIALNAVIGATION = 'CrossSiteRedirectInInitialNavigation'
+    CROSSSITENAVIGATIONININITIALNAVIGATION = 'CrossSiteNavigationInInitialNavigation'
+    SAMESITECROSSORIGINREDIRECTNOTOPTINININITIALNAVIGATION = 'SameSiteCrossOriginRedirectNotOptInInInitialNavigation'
+    SAMESITECROSSORIGINNAVIGATIONNOTOPTINININITIALNAVIGATION = 'SameSiteCrossOriginNavigationNotOptInInInitialNavigation'
+    ACTIVATIONNAVIGATIONPARAMETERMISMATCH = 'ActivationNavigationParameterMismatch'
+    ACTIVATEDINBACKGROUND = 'ActivatedInBackground'
+    EMBEDDERHOSTDISALLOWED = 'EmbedderHostDisallowed'
+    ACTIVATIONNAVIGATIONDESTROYEDBEFORESUCCESS = 'ActivationNavigationDestroyedBeforeSuccess'
+    TABCLOSEDBYUSERGESTURE = 'TabClosedByUserGesture'
+    TABCLOSEDWITHOUTUSERGESTURE = 'TabClosedWithoutUserGesture'
+    PRIMARYMAINFRAMERENDERERPROCESSCRASHED = 'PrimaryMainFrameRendererProcessCrashed'
+    PRIMARYMAINFRAMERENDERERPROCESSKILLED = 'PrimaryMainFrameRendererProcessKilled'
+    ACTIVATIONFRAMEPOLICYNOTCOMPATIBLE = 'ActivationFramePolicyNotCompatible'
+    PRELOADINGDISABLED = 'PreloadingDisabled'
+    BATTERYSAVERENABLED = 'BatterySaverEnabled'
+    ACTIVATEDDURINGMAINFRAMENAVIGATION = 'ActivatedDuringMainFrameNavigation'
+    PRELOADINGUNSUPPORTEDBYWEBCONTENTS = 'PreloadingUnsupportedByWebContents'
+    CROSSSITEREDIRECTINMAINFRAMENAVIGATION = 'CrossSiteRedirectInMainFrameNavigation'
+    CROSSSITENAVIGATIONINMAINFRAMENAVIGATION = 'CrossSiteNavigationInMainFrameNavigation'
+    SAMESITECROSSORIGINREDIRECTNOTOPTININMAINFRAMENAVIGATION = 'SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation'
+    SAMESITECROSSORIGINNAVIGATIONNOTOPTININMAINFRAMENAVIGATION = 'SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation'
+    MEMORYPRESSUREONTRIGGER = 'MemoryPressureOnTrigger'
+    MEMORYPRESSUREAFTERTRIGGERED = 'MemoryPressureAfterTriggered'
+    PRERENDERINGDISABLEDBYDEVTOOLS = 'PrerenderingDisabledByDevTools'
+    SPECULATIONRULEREMOVED = 'SpeculationRuleRemoved'
+    ACTIVATEDWITHAUXILIARYBROWSINGCONTEXTS = 'ActivatedWithAuxiliaryBrowsingContexts'
+    MAXNUMOFRUNNINGEAGERPRERENDERSEXCEEDED = 'MaxNumOfRunningEagerPrerendersExceeded'
+    MAXNUMOFRUNNINGNONEAGERPRERENDERSEXCEEDED = 'MaxNumOfRunningNonEagerPrerendersExceeded'
+    MAXNUMOFRUNNINGEMBEDDERPRERENDERSEXCEEDED = 'MaxNumOfRunningEmbedderPrerendersExceeded'
+    PRERENDERINGURLHASEFFECTIVEURL = 'PrerenderingUrlHasEffectiveUrl'
+    REDIRECTEDPRERENDERINGURLHASEFFECTIVEURL = 'RedirectedPrerenderingUrlHasEffectiveUrl'
+    ACTIVATIONURLHASEFFECTIVEURL = 'ActivationUrlHasEffectiveUrl'
+    JAVASCRIPTINTERFACEADDED = 'JavaScriptInterfaceAdded'
+    JAVASCRIPTINTERFACEREMOVED = 'JavaScriptInterfaceRemoved'
+    ALLPRERENDERINGCANCELED = 'AllPrerenderingCanceled'
+    WINDOWCLOSED = 'WindowClosed'
+    SLOWNETWORK = 'SlowNetwork'
+    OTHERPRERENDEREDPAGEACTIVATED = 'OtherPrerenderedPageActivated'
+    V8OPTIMIZERDISABLED = 'V8OptimizerDisabled'
+    PRERENDERFAILEDDURINGPREFETCH = 'PrerenderFailedDuringPrefetch'
+    BROWSINGDATAREMOVED = 'BrowsingDataRemoved'
+    PRERENDERHOSTREUSED = 'PrerenderHostReused'
+
+
+@register("Preload.PreloadingStatus")
+class PreloadingStatus(str, Enum):
+    """
+    Preloading status values, see also PreloadingTriggeringOutcome. This
+    status is shared by prefetchStatusUpdated and prerenderStatusUpdated.
+    """
+    PENDING = 'Pending'
+    RUNNING = 'Running'
+    READY = 'Ready'
+    SUCCESS = 'Success'
+    FAILURE = 'Failure'
+    NOTSUPPORTED = 'NotSupported'
+
+
+@register("Preload.PrefetchStatus")
+class PrefetchStatus(str, Enum):
+    """
+    TODO(https://crbug.com/1384419): revisit the list of PrefetchStatus and
+    filter out the ones that aren't necessary to the developers.
+    """
+    PREFETCHALLOWED = 'PrefetchAllowed'
+    PREFETCHFAILEDINELIGIBLEREDIRECT = 'PrefetchFailedIneligibleRedirect'
+    PREFETCHFAILEDINVALIDREDIRECT = 'PrefetchFailedInvalidRedirect'
+    PREFETCHFAILEDMIMENOTSUPPORTED = 'PrefetchFailedMIMENotSupported'
+    PREFETCHFAILEDNETERROR = 'PrefetchFailedNetError'
+    PREFETCHFAILEDNON2XX = 'PrefetchFailedNon2XX'
+    PREFETCHEVICTEDAFTERBROWSINGDATAREMOVED = 'PrefetchEvictedAfterBrowsingDataRemoved'
+    PREFETCHEVICTEDAFTERCANDIDATEREMOVED = 'PrefetchEvictedAfterCandidateRemoved'
+    PREFETCHEVICTEDFORNEWERPREFETCH = 'PrefetchEvictedForNewerPrefetch'
+    PREFETCHHELDBACK = 'PrefetchHeldback'
+    PREFETCHINELIGIBLERETRYAFTER = 'PrefetchIneligibleRetryAfter'
+    PREFETCHISPRIVACYDECOY = 'PrefetchIsPrivacyDecoy'
+    PREFETCHISSTALE = 'PrefetchIsStale'
+    PREFETCHNOTELIGIBLEBROWSERCONTEXTOFFTHERECORD = 'PrefetchNotEligibleBrowserContextOffTheRecord'
+    PREFETCHNOTELIGIBLEDATASAVERENABLED = 'PrefetchNotEligibleDataSaverEnabled'
+    PREFETCHNOTELIGIBLEEXISTINGPROXY = 'PrefetchNotEligibleExistingProxy'
+    PREFETCHNOTELIGIBLEHOSTISNONUNIQUE = 'PrefetchNotEligibleHostIsNonUnique'
+    PREFETCHNOTELIGIBLENONDEFAULTSTORAGEPARTITION = 'PrefetchNotEligibleNonDefaultStoragePartition'
+    PREFETCHNOTELIGIBLESAMESITECROSSORIGINPREFETCHREQUIREDPROXY = 'PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy'
+    PREFETCHNOTELIGIBLESCHEMEISNOTHTTPS = 'PrefetchNotEligibleSchemeIsNotHttps'
+    PREFETCHNOTELIGIBLEUSERHASCOOKIES = 'PrefetchNotEligibleUserHasCookies'
+    PREFETCHNOTELIGIBLEUSERHASSERVICEWORKER = 'PrefetchNotEligibleUserHasServiceWorker'
+    PREFETCHNOTELIGIBLEUSERHASSERVICEWORKERNOFETCHHANDLER = 'PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler'
+    PREFETCHNOTELIGIBLEREDIRECTFROMSERVICEWORKER = 'PrefetchNotEligibleRedirectFromServiceWorker'
+    PREFETCHNOTELIGIBLEREDIRECTTOSERVICEWORKER = 'PrefetchNotEligibleRedirectToServiceWorker'
+    PREFETCHNOTELIGIBLEBATTERYSAVERENABLED = 'PrefetchNotEligibleBatterySaverEnabled'
+    PREFETCHNOTELIGIBLEPRELOADINGDISABLED = 'PrefetchNotEligiblePreloadingDisabled'
+    PREFETCHNOTFINISHEDINTIME = 'PrefetchNotFinishedInTime'
+    PREFETCHNOTSTARTED = 'PrefetchNotStarted'
+    PREFETCHNOTUSEDCOOKIESCHANGED = 'PrefetchNotUsedCookiesChanged'
+    PREFETCHPROXYNOTAVAILABLE = 'PrefetchProxyNotAvailable'
+    PREFETCHRESPONSEUSED = 'PrefetchResponseUsed'
+    PREFETCHSUCCESSFULBUTNOTUSED = 'PrefetchSuccessfulButNotUsed'
+    PREFETCHNOTUSEDPROBEFAILED = 'PrefetchNotUsedProbeFailed'
+
+
+@register("Preload.PrerenderMismatchedHeaders")
+@dataclass
+class PrerenderMismatchedHeaders(DataType):
+    """Information of headers to be displayed when the header mismatch occurred."""
+    header_name: str
+    initial_value: Optional[str] = None
+    activation_value: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('header_name', 'headerName', False, 'primitive'),
+        FieldMeta('initial_value', 'initialValue', True, 'primitive'),
+        FieldMeta('activation_value', 'activationValue', True, 'primitive'),
+    )
+
+__all__ = ["PrefetchStatus", "PreloadPipelineId", "PreloadingAttemptKey", "PreloadingAttemptSource", "PreloadingStatus", "PrerenderFinalStatus", "PrerenderMismatchedHeaders", "RuleSet", "RuleSetErrorType", "RuleSetId", "SpeculationAction", "SpeculationTargetHint"]

parsek_cdp/cdp/profiler/__init__.py

@@ -0,0 +1,15 @@
+"""The Profiler CDP domain (generated).
+
+Importing ``Profiler`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Profiler.SomeEvent`` /
+``Profiler.SomeType``); commands run on a target via ``page.cdp.Profiler``.
+"""
+from . import events, functions, types
+from .functions import Profiler
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(Profiler,)``).
+DOMAIN = "Profiler"
+
+__all__ = ["events", "functions", "types", "Profiler", "DOMAIN"]

parsek_cdp/cdp/profiler/events.py

@@ -0,0 +1,64 @@
+"""Events for the Profiler domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import (
+        Profile,
+        ScriptCoverage,
+    )
+    from ..debugger.types import Location as Debugger_Location
+
+@register_event("Profiler.consoleProfileFinished")
+@dataclass
+class ConsoleProfileFinished(Event):
+    id: str
+    location: Debugger_Location
+    profile: Profile
+    title: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('location', 'location', False, 'object', ref='Debugger.Location'),
+        FieldMeta('profile', 'profile', False, 'object', ref='Profiler.Profile'),
+        FieldMeta('title', 'title', True, 'primitive'),
+    )
+
+
+@register_event("Profiler.consoleProfileStarted")
+@dataclass
+class ConsoleProfileStarted(Event):
+    """Sent when new profile recording is started using console.profile() call."""
+    id: str
+    location: Debugger_Location
+    title: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('location', 'location', False, 'object', ref='Debugger.Location'),
+        FieldMeta('title', 'title', True, 'primitive'),
+    )
+
+
+@register_event("Profiler.preciseCoverageDeltaUpdate")
+@dataclass
+class PreciseCoverageDeltaUpdate(Event):
+    """
+    Reports coverage delta since the last poll (either from an event like this, or from
+    `takePreciseCoverage` for the current isolate. May only be sent if precise code
+    coverage has been started. This event can be trigged by the embedder to, for example,
+    trigger collection of coverage data immediately at a certain point in time.
+    """
+    timestamp: float
+    occasion: str
+    result: List[ScriptCoverage]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+        FieldMeta('occasion', 'occasion', False, 'primitive'),
+        FieldMeta('result', 'result', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Profiler.ScriptCoverage')),
+    )
+
+__all__ = ["ConsoleProfileFinished", "ConsoleProfileStarted", "PreciseCoverageDeltaUpdate"]

parsek_cdp/cdp/profiler/functions.py

@@ -0,0 +1,134 @@
+"""Commands for the Profiler domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        Profile,
+        ScriptCoverage,
+    )
+
+@dataclass
+class GetBestEffortCoverageReturn(DataType):
+    """Return value of :meth:`Profiler.get_best_effort_coverage`."""
+    result: List[ScriptCoverage]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('result', 'result', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Profiler.ScriptCoverage')),
+    )
+
+
+@dataclass
+class StartPreciseCoverageReturn(DataType):
+    """Return value of :meth:`Profiler.start_precise_coverage`."""
+    timestamp: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+    )
+
+
+@dataclass
+class StopReturn(DataType):
+    """Return value of :meth:`Profiler.stop`."""
+    profile: Profile
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('profile', 'profile', False, 'object', ref='Profiler.Profile'),
+    )
+
+
+@dataclass
+class TakePreciseCoverageReturn(DataType):
+    """Return value of :meth:`Profiler.take_precise_coverage`."""
+    result: List[ScriptCoverage]
+    timestamp: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('result', 'result', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Profiler.ScriptCoverage')),
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+    )
+
+
+class Profiler:
+    """Commands of the Profiler domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def disable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Profiler.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Profiler.enable', _params)
+        return None
+
+    async def get_best_effort_coverage(self) -> GetBestEffortCoverageReturn:
+        """
+        Collect coverage data for the current isolate. The coverage data may be incomplete due to
+        garbage collection.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Profiler.getBestEffortCoverage', _params)
+        return GetBestEffortCoverageReturn.from_json(_result)
+
+    async def set_sampling_interval(self, *, interval: int) -> None:
+        """
+        Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.
+        :param interval: New sampling interval in microseconds.
+        """
+        _params: Dict[str, Any] = {}
+        _params['interval'] = encode(FieldMeta('', '', False, 'primitive'), interval)
+        _result = await self._target.send('Profiler.setSamplingInterval', _params)
+        return None
+
+    async def start(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Profiler.start', _params)
+        return None
+
+    async def start_precise_coverage(self, *, call_count: Optional[bool] = None, detailed: Optional[bool] = None, allow_triggered_updates: Optional[bool] = None) -> StartPreciseCoverageReturn:
+        """
+        Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code
+        coverage may be incomplete. Enabling prevents running optimized code and resets execution
+        counters.
+        :param call_count: Collect accurate call counts beyond simple 'covered' or 'not covered'.
+        :param detailed: Collect block-based coverage.
+        :param allow_triggered_updates: Allow the backend to send updates on its own initiative
+        """
+        _params: Dict[str, Any] = {}
+        if call_count is not None:
+            _params['callCount'] = encode(FieldMeta('', '', False, 'primitive'), call_count)
+        if detailed is not None:
+            _params['detailed'] = encode(FieldMeta('', '', False, 'primitive'), detailed)
+        if allow_triggered_updates is not None:
+            _params['allowTriggeredUpdates'] = encode(FieldMeta('', '', False, 'primitive'), allow_triggered_updates)
+        _result = await self._target.send('Profiler.startPreciseCoverage', _params)
+        return StartPreciseCoverageReturn.from_json(_result)
+
+    async def stop(self) -> StopReturn:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Profiler.stop', _params)
+        return StopReturn.from_json(_result)
+
+    async def stop_precise_coverage(self) -> None:
+        """
+        Disable precise code coverage. Disabling releases unnecessary execution count records and allows
+        executing optimized code.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Profiler.stopPreciseCoverage', _params)
+        return None
+
+    async def take_precise_coverage(self) -> TakePreciseCoverageReturn:
+        """
+        Collect coverage data for the current isolate, and resets execution counters. Precise code
+        coverage needs to have started.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Profiler.takePreciseCoverage', _params)
+        return TakePreciseCoverageReturn.from_json(_result)

parsek_cdp/cdp/profiler/types.py

@@ -0,0 +1,105 @@
+"""Custom types and enums for the Profiler domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+if TYPE_CHECKING:
+    from ..runtime.types import CallFrame as Runtime_CallFrame
+    from ..runtime.types import ScriptId as Runtime_ScriptId
+
+@register("Profiler.ProfileNode")
+@dataclass
+class ProfileNode(DataType):
+    """Profile node. Holds callsite information, execution statistics and child nodes."""
+    id: int
+    call_frame: Runtime_CallFrame
+    hit_count: Optional[int] = None
+    children: Optional[List[int]] = None
+    deopt_reason: Optional[str] = None
+    position_ticks: Optional[List[PositionTickInfo]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('call_frame', 'callFrame', False, 'object', ref='Runtime.CallFrame'),
+        FieldMeta('hit_count', 'hitCount', True, 'primitive'),
+        FieldMeta('children', 'children', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('deopt_reason', 'deoptReason', True, 'primitive'),
+        FieldMeta('position_ticks', 'positionTicks', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Profiler.PositionTickInfo')),
+    )
+
+
+@register("Profiler.Profile")
+@dataclass
+class Profile(DataType):
+    """Profile."""
+    nodes: List[ProfileNode]
+    start_time: float
+    end_time: float
+    samples: Optional[List[int]] = None
+    time_deltas: Optional[List[int]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Profiler.ProfileNode')),
+        FieldMeta('start_time', 'startTime', False, 'primitive'),
+        FieldMeta('end_time', 'endTime', False, 'primitive'),
+        FieldMeta('samples', 'samples', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('time_deltas', 'timeDeltas', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("Profiler.PositionTickInfo")
+@dataclass
+class PositionTickInfo(DataType):
+    """Specifies a number of samples attributed to a certain source position."""
+    line: int
+    ticks: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('line', 'line', False, 'primitive'),
+        FieldMeta('ticks', 'ticks', False, 'primitive'),
+    )
+
+
+@register("Profiler.CoverageRange")
+@dataclass
+class CoverageRange(DataType):
+    """Coverage data for a source range."""
+    start_offset: int
+    end_offset: int
+    count: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('start_offset', 'startOffset', False, 'primitive'),
+        FieldMeta('end_offset', 'endOffset', False, 'primitive'),
+        FieldMeta('count', 'count', False, 'primitive'),
+    )
+
+
+@register("Profiler.FunctionCoverage")
+@dataclass
+class FunctionCoverage(DataType):
+    """Coverage data for a JavaScript function."""
+    function_name: str
+    ranges: List[CoverageRange]
+    is_block_coverage: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('function_name', 'functionName', False, 'primitive'),
+        FieldMeta('ranges', 'ranges', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Profiler.CoverageRange')),
+        FieldMeta('is_block_coverage', 'isBlockCoverage', False, 'primitive'),
+    )
+
+
+@register("Profiler.ScriptCoverage")
+@dataclass
+class ScriptCoverage(DataType):
+    """Coverage data for a JavaScript script."""
+    script_id: Runtime_ScriptId
+    url: str
+    functions: List[FunctionCoverage]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('script_id', 'scriptId', False, 'primitive'),
+        FieldMeta('url', 'url', False, 'primitive'),
+        FieldMeta('functions', 'functions', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Profiler.FunctionCoverage')),
+    )
+
+__all__ = ["CoverageRange", "FunctionCoverage", "PositionTickInfo", "Profile", "ProfileNode", "ScriptCoverage"]

parsek_cdp/cdp/pwa/__init__.py

@@ -0,0 +1,15 @@
+"""The PWA CDP domain (generated).
+
+Importing ``PWA`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``PWA.SomeEvent`` /
+``PWA.SomeType``); commands run on a target via ``page.cdp.PWA``.
+"""
+from . import events, functions, types
+from .functions import PWA
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(PWA,)``).
+DOMAIN = "PWA"
+
+__all__ = ["events", "functions", "types", "PWA", "DOMAIN"]

parsek_cdp/cdp/pwa/events.py

@@ -0,0 +1,13 @@
+"""Events for the PWA domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+
+# This domain defines no events.
+
+__all__ = []