chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/performance_timeline/service.py

@@ -0,0 +1,21 @@
+"""CDP PerformanceTimeline Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import PerformanceTimelineMethods
+from .events.service import PerformanceTimelineEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class PerformanceTimeline(PerformanceTimelineMethods, PerformanceTimelineEvents):
+    """
+    Reporting of performance timeline events, as specified in https://w3c.github.io/performance-timeline/#dom-performanceobserver.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the PerformanceTimeline domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        PerformanceTimelineMethods.__init__(self, client)
+        PerformanceTimelineEvents.__init__(self, client)

cdp/protocol/performance_timeline/types.py

@@ -0,0 +1,46 @@
+"""CDP PerformanceTimeline 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.dom.types import Rect
+    from cdp.protocol.network.types import TimeSinceEpoch
+    from cdp.protocol.page.types import FrameId
+
+class LargestContentfulPaint(TypedDict, total=True):
+    """See https://github.com/WICG/LargestContentfulPaint and largest_contentful_paint.idl"""
+    renderTime: 'TimeSinceEpoch'
+    loadTime: 'TimeSinceEpoch'
+    size: 'float'
+    """The number of pixels being painted."""
+    elementId: NotRequired['str']
+    """The id attribute of the element, if available."""
+    url: NotRequired['str']
+    """The URL of the image (may be trimmed)."""
+    nodeId: NotRequired['BackendNodeId']
+class LayoutShiftAttribution(TypedDict, total=True):
+    previousRect: 'Rect'
+    currentRect: 'Rect'
+    nodeId: NotRequired['BackendNodeId']
+class LayoutShift(TypedDict, total=True):
+    """See https://wicg.github.io/layout-instability/#sec-layout-shift and layout_shift.idl"""
+    value: 'float'
+    """Score increment produced by this event."""
+    hadRecentInput: 'bool'
+    lastInputTime: 'TimeSinceEpoch'
+    sources: 'List[LayoutShiftAttribution]'
+class TimelineEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Identifies the frame that this event is related to. Empty for non-frame targets."""
+    type: 'str'
+    """The event type, as specified in https://w3c.github.io/performance-timeline/#dom-performanceentry-entrytype This determines which of the optional details fields is present."""
+    name: 'str'
+    """Name may be empty depending on the type."""
+    time: 'TimeSinceEpoch'
+    """Time in seconds since Epoch, monotonically increasing within document lifetime."""
+    duration: NotRequired['float']
+    """Event duration, if applicable."""
+    lcpDetails: NotRequired['LargestContentfulPaint']
+    layoutShiftDetails: NotRequired['LayoutShift']

cdp/protocol/preload/events/service.py

@@ -0,0 +1,69 @@
+"""CDP Preload 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 PreloadEvents:
+    """
+    Events for the Preload domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Preload events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_rule_set_updated(self, callback: Callable[[ruleSetUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Upsert. Currently, it is only emitted when a rule set added.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: ruleSetUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Preload.ruleSetUpdated', callback)
+    def on_rule_set_removed(self, callback: Callable[[ruleSetRemovedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for ruleSetRemoved.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: ruleSetRemovedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Preload.ruleSetRemoved', callback)
+    def on_preload_enabled_state_updated(self, callback: Callable[[preloadEnabledStateUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a preload enabled state is updated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: preloadEnabledStateUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Preload.preloadEnabledStateUpdated', callback)
+    def on_prefetch_status_updated(self, callback: Callable[[prefetchStatusUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a prefetch attempt is updated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: prefetchStatusUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Preload.prefetchStatusUpdated', callback)
+    def on_prerender_status_updated(self, callback: Callable[[prerenderStatusUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a prerender attempt is updated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: prerenderStatusUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Preload.prerenderStatusUpdated', callback)
+    def on_preloading_attempt_sources_updated(self, callback: Callable[[preloadingAttemptSourcesUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Send a list of sources for all preloading attempts in a document.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: preloadingAttemptSourcesUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Preload.preloadingAttemptSourcesUpdated', callback)

cdp/protocol/preload/events/types.py

@@ -0,0 +1,49 @@
+"""CDP Preload 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.network.types import LoaderId
+    from cdp.protocol.network.types import RequestId
+    from cdp.protocol.page.types import FrameId
+    from cdp.protocol.preload.types import PrefetchStatus
+    from cdp.protocol.preload.types import PreloadPipelineId
+    from cdp.protocol.preload.types import PreloadingAttemptKey
+    from cdp.protocol.preload.types import PreloadingAttemptSource
+    from cdp.protocol.preload.types import PreloadingStatus
+    from cdp.protocol.preload.types import PrerenderFinalStatus
+    from cdp.protocol.preload.types import PrerenderMismatchedHeaders
+    from cdp.protocol.preload.types import RuleSet
+    from cdp.protocol.preload.types import RuleSetId
+
+class ruleSetUpdatedEvent(TypedDict, total=True):
+    ruleSet: 'RuleSet'
+class ruleSetRemovedEvent(TypedDict, total=True):
+    id: 'RuleSetId'
+class preloadEnabledStateUpdatedEvent(TypedDict, total=True):
+    disabledByPreference: 'bool'
+    disabledByDataSaver: 'bool'
+    disabledByBatterySaver: 'bool'
+    disabledByHoldbackPrefetchSpeculationRules: 'bool'
+    disabledByHoldbackPrerenderSpeculationRules: 'bool'
+class prefetchStatusUpdatedEvent(TypedDict, total=True):
+    key: 'PreloadingAttemptKey'
+    pipelineId: 'PreloadPipelineId'
+    initiatingFrameId: 'FrameId'
+    """The frame id of the frame initiating prefetch."""
+    prefetchUrl: 'str'
+    status: 'PreloadingStatus'
+    prefetchStatus: 'PrefetchStatus'
+    requestId: 'RequestId'
+class prerenderStatusUpdatedEvent(TypedDict, total=True):
+    key: 'PreloadingAttemptKey'
+    pipelineId: 'PreloadPipelineId'
+    status: 'PreloadingStatus'
+    prerenderStatus: NotRequired['PrerenderFinalStatus']
+    disallowedMojoInterface: NotRequired['str']
+    """This is used to give users more information about the name of Mojo interface that is incompatible with prerender and has caused the cancellation of the attempt."""
+    mismatchedHeaders: NotRequired['List[PrerenderMismatchedHeaders]']
+class preloadingAttemptSourcesUpdatedEvent(TypedDict, total=True):
+    loaderId: 'LoaderId'
+    preloadingAttemptSources: 'List[PreloadingAttemptSource]'

cdp/protocol/preload/methods/service.py

@@ -0,0 +1,43 @@
+"""CDP Preload 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 PreloadMethods:
+    """
+    Methods for the Preload domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Preload methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for enable.    
+        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="Preload.enable", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for disable.    
+        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="Preload.disable", params=params,session_id=session_id)

cdp/protocol/preload/methods/types.py

@@ -0,0 +1,3 @@
+"""CDP Preload Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple

cdp/protocol/preload/service.py

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

cdp/protocol/preload/types.py

@@ -0,0 +1,56 @@
+"""CDP Preload 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.network.types import LoaderId
+    from cdp.protocol.network.types import RequestId
+
+RuleSetId = str
+"""Unique id"""
+class RuleSet(TypedDict, total=True):
+    """Corresponds to SpeculationRuleSet"""
+    id: 'RuleSetId'
+    loaderId: 'LoaderId'
+    """Identifies a document which the rule set is associated with."""
+    sourceText: 'str'
+    """Source text of JSON representing the rule set. If it comes from <script> tag, it is the textContent of the node. Note that it is a JSON for valid case.  See also: - https://wicg.github.io/nav-speculation/speculation-rules.html - https://github.com/WICG/nav-speculation/blob/main/triggers.md"""
+    backendNodeId: NotRequired['BackendNodeId']
+    """A speculation rule set is either added through an inline <script> tag or through an external resource via the 'Speculation-Rules' HTTP header. For the first case, we include the BackendNodeId of the relevant <script> tag. For the second case, we include the external URL where the rule set was loaded from, and also RequestId if Network domain is enabled.  See also: - https://wicg.github.io/nav-speculation/speculation-rules.html#speculation-rules-script - https://wicg.github.io/nav-speculation/speculation-rules.html#speculation-rules-header"""
+    url: NotRequired['str']
+    requestId: NotRequired['RequestId']
+    errorType: NotRequired['RuleSetErrorType']
+    """Error information errorMessage is null iff errorType is null."""
+    tag: NotRequired['str']
+    """For more details, see: https://github.com/WICG/nav-speculation/blob/main/speculation-rules-tags.md"""
+RuleSetErrorType = Literal['SourceIsNotJsonObject','InvalidRulesSkipped','InvalidRulesetLevelTag']
+SpeculationAction = Literal['Prefetch','Prerender','PrerenderUntilScript']
+"""The type of preloading attempted. It corresponds to mojom::SpeculationAction (although PrefetchWithSubresources is omitted as it isn't being used by clients)."""
+SpeculationTargetHint = Literal['Blank','Self']
+"""Corresponds to mojom::SpeculationTargetHint. See https://github.com/WICG/nav-speculation/blob/main/triggers.md#window-name-targeting-hints"""
+class PreloadingAttemptKey(TypedDict, total=True):
+    """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."""
+    loaderId: 'LoaderId'
+    action: 'SpeculationAction'
+    url: 'str'
+    targetHint: NotRequired['SpeculationTargetHint']
+class PreloadingAttemptSource(TypedDict, total=True):
+    """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'
+    ruleSetIds: 'List[RuleSetId]'
+    nodeIds: 'List[BackendNodeId]'
+PreloadPipelineId = str
+"""Chrome manages different types of preloads together using a concept of preloading pipeline. For example, if a site uses a SpeculationRules for prerender, Chrome first starts a prefetch and then upgrades it to prerender.  CDP events for them are emitted separately but they share PreloadPipelineId."""
+PrerenderFinalStatus = Literal['Activated','Destroyed','LowEndDevice','InvalidSchemeRedirect','InvalidSchemeNavigation','NavigationRequestBlockedByCsp','MojoBinderPolicy','RendererProcessCrashed','RendererProcessKilled','Download','TriggerDestroyed','NavigationNotCommitted','NavigationBadHttpStatus','ClientCertRequested','NavigationRequestNetworkError','CancelAllHostsForTesting','DidFailLoad','Stop','SslCertificateError','LoginAuthRequested','UaChangeRequiresReload','BlockedByClient','AudioOutputDeviceRequested','MixedContent','TriggerBackgrounded','MemoryLimitExceeded','DataSaverEnabled','TriggerUrlHasEffectiveUrl','ActivatedBeforeStarted','InactivePageRestriction','StartFailed','TimeoutBackgrounded','CrossSiteRedirectInInitialNavigation','CrossSiteNavigationInInitialNavigation','SameSiteCrossOriginRedirectNotOptInInInitialNavigation','SameSiteCrossOriginNavigationNotOptInInInitialNavigation','ActivationNavigationParameterMismatch','ActivatedInBackground','EmbedderHostDisallowed','ActivationNavigationDestroyedBeforeSuccess','TabClosedByUserGesture','TabClosedWithoutUserGesture','PrimaryMainFrameRendererProcessCrashed','PrimaryMainFrameRendererProcessKilled','ActivationFramePolicyNotCompatible','PreloadingDisabled','BatterySaverEnabled','ActivatedDuringMainFrameNavigation','PreloadingUnsupportedByWebContents','CrossSiteRedirectInMainFrameNavigation','CrossSiteNavigationInMainFrameNavigation','SameSiteCrossOriginRedirectNotOptInInMainFrameNavigation','SameSiteCrossOriginNavigationNotOptInInMainFrameNavigation','MemoryPressureOnTrigger','MemoryPressureAfterTriggered','PrerenderingDisabledByDevTools','SpeculationRuleRemoved','ActivatedWithAuxiliaryBrowsingContexts','MaxNumOfRunningEagerPrerendersExceeded','MaxNumOfRunningNonEagerPrerendersExceeded','MaxNumOfRunningEmbedderPrerendersExceeded','PrerenderingUrlHasEffectiveUrl','RedirectedPrerenderingUrlHasEffectiveUrl','ActivationUrlHasEffectiveUrl','JavaScriptInterfaceAdded','JavaScriptInterfaceRemoved','AllPrerenderingCanceled','WindowClosed','SlowNetwork','OtherPrerenderedPageActivated','V8OptimizerDisabled','PrerenderFailedDuringPrefetch','BrowsingDataRemoved','PrerenderHostReused']
+"""List of FinalStatus reasons for Prerender2."""
+PreloadingStatus = Literal['Pending','Running','Ready','Success','Failure','NotSupported']
+"""Preloading status values, see also PreloadingTriggeringOutcome. This status is shared by prefetchStatusUpdated and prerenderStatusUpdated."""
+PrefetchStatus = Literal['PrefetchAllowed','PrefetchFailedIneligibleRedirect','PrefetchFailedInvalidRedirect','PrefetchFailedMIMENotSupported','PrefetchFailedNetError','PrefetchFailedNon2XX','PrefetchEvictedAfterBrowsingDataRemoved','PrefetchEvictedAfterCandidateRemoved','PrefetchEvictedForNewerPrefetch','PrefetchHeldback','PrefetchIneligibleRetryAfter','PrefetchIsPrivacyDecoy','PrefetchIsStale','PrefetchNotEligibleBrowserContextOffTheRecord','PrefetchNotEligibleDataSaverEnabled','PrefetchNotEligibleExistingProxy','PrefetchNotEligibleHostIsNonUnique','PrefetchNotEligibleNonDefaultStoragePartition','PrefetchNotEligibleSameSiteCrossOriginPrefetchRequiredProxy','PrefetchNotEligibleSchemeIsNotHttps','PrefetchNotEligibleUserHasCookies','PrefetchNotEligibleUserHasServiceWorker','PrefetchNotEligibleUserHasServiceWorkerNoFetchHandler','PrefetchNotEligibleRedirectFromServiceWorker','PrefetchNotEligibleRedirectToServiceWorker','PrefetchNotEligibleBatterySaverEnabled','PrefetchNotEligiblePreloadingDisabled','PrefetchNotFinishedInTime','PrefetchNotStarted','PrefetchNotUsedCookiesChanged','PrefetchProxyNotAvailable','PrefetchResponseUsed','PrefetchSuccessfulButNotUsed','PrefetchNotUsedProbeFailed']
+"""TODO(https://crbug.com/1384419): revisit the list of PrefetchStatus and filter out the ones that aren't necessary to the developers."""
+class PrerenderMismatchedHeaders(TypedDict, total=True):
+    """Information of headers to be displayed when the header mismatch occurred."""
+    headerName: 'str'
+    initialValue: NotRequired['str']
+    activationValue: NotRequired['str']

cdp/protocol/profiler/events/service.py

@@ -0,0 +1,45 @@
+"""CDP Profiler 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 ProfilerEvents:
+    """
+    Events for the Profiler domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Profiler events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_console_profile_finished(self, callback: Callable[[consoleProfileFinishedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for consoleProfileFinished.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: consoleProfileFinishedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Profiler.consoleProfileFinished', callback)
+    def on_console_profile_started(self, callback: Callable[[consoleProfileStartedEvent,Optional[str]], None]=None) -> None:
+        """
+    Sent when new profile recording is started using console.profile() call.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: consoleProfileStartedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Profiler.consoleProfileStarted', callback)
+    def on_precise_coverage_delta_update(self, callback: Callable[[preciseCoverageDeltaUpdateEvent,Optional[str]], None]=None) -> None:
+        """
+    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.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: preciseCoverageDeltaUpdateEvent, session_id: Optional[str]).
+        """
+        self.client.on('Profiler.preciseCoverageDeltaUpdate', callback)

cdp/protocol/profiler/events/types.py

@@ -0,0 +1,30 @@
+"""CDP Profiler 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.debugger.types import Location
+    from cdp.protocol.profiler.types import Profile
+    from cdp.protocol.profiler.types import ScriptCoverage
+
+class consoleProfileFinishedEvent(TypedDict, total=True):
+    id: 'str'
+    location: 'Location'
+    """Location of console.profileEnd()."""
+    profile: 'Profile'
+    title: NotRequired['str']
+    """Profile title passed as an argument to console.profile()."""
+class consoleProfileStartedEvent(TypedDict, total=True):
+    id: 'str'
+    location: 'Location'
+    """Location of console.profile()."""
+    title: NotRequired['str']
+    """Profile title passed as an argument to console.profile()."""
+class preciseCoverageDeltaUpdateEvent(TypedDict, total=True):
+    timestamp: 'float'
+    """Monotonically increasing time (in seconds) when the coverage update was taken in the backend."""
+    occasion: 'str'
+    """Identifier for distinguishing coverage events."""
+    result: 'List[ScriptCoverage]'
+    """Coverage data for the current isolate."""

cdp/protocol/profiler/methods/service.py

@@ -0,0 +1,120 @@
+"""CDP Profiler 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 ProfilerMethods:
+    """
+    Methods for the Profiler domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Profiler 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]:
+        """
+    No description available for disable.    
+        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="Profiler.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for enable.    
+        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="Profiler.enable", params=params,session_id=session_id)
+    async def get_best_effort_coverage(self, params: None=None,session_id: Optional[str] = None) -> getBestEffortCoverageReturns:
+        """
+    Collect coverage data for the current isolate. The coverage data may be incomplete due to garbage collection.    
+        Args:
+            params (None, optional): Parameters for the getBestEffortCoverage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getBestEffortCoverageReturns: The result of the getBestEffortCoverage call.
+        """
+        return await self.client.send(method="Profiler.getBestEffortCoverage", params=params,session_id=session_id)
+    async def set_sampling_interval(self, params: Optional[setSamplingIntervalParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.    
+        Args:
+            params (setSamplingIntervalParameters, optional): Parameters for the setSamplingInterval method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setSamplingInterval call.
+        """
+        return await self.client.send(method="Profiler.setSamplingInterval", params=params,session_id=session_id)
+    async def start(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for start.    
+        Args:
+            params (None, optional): Parameters for the start method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the start call.
+        """
+        return await self.client.send(method="Profiler.start", params=params,session_id=session_id)
+    async def start_precise_coverage(self, params: Optional[startPreciseCoverageParameters]=None,session_id: Optional[str] = None) -> startPreciseCoverageReturns:
+        """
+    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.    
+        Args:
+            params (startPreciseCoverageParameters, optional): Parameters for the startPreciseCoverage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    startPreciseCoverageReturns: The result of the startPreciseCoverage call.
+        """
+        return await self.client.send(method="Profiler.startPreciseCoverage", params=params,session_id=session_id)
+    async def stop(self, params: None=None,session_id: Optional[str] = None) -> stopReturns:
+        """
+    No description available for stop.    
+        Args:
+            params (None, optional): Parameters for the stop method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    stopReturns: The result of the stop call.
+        """
+        return await self.client.send(method="Profiler.stop", params=params,session_id=session_id)
+    async def stop_precise_coverage(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disable precise code coverage. Disabling releases unnecessary execution count records and allows executing optimized code.    
+        Args:
+            params (None, optional): Parameters for the stopPreciseCoverage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopPreciseCoverage call.
+        """
+        return await self.client.send(method="Profiler.stopPreciseCoverage", params=params,session_id=session_id)
+    async def take_precise_coverage(self, params: None=None,session_id: Optional[str] = None) -> takePreciseCoverageReturns:
+        """
+    Collect coverage data for the current isolate, and resets execution counters. Precise code coverage needs to have started.    
+        Args:
+            params (None, optional): Parameters for the takePreciseCoverage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    takePreciseCoverageReturns: The result of the takePreciseCoverage call.
+        """
+        return await self.client.send(method="Profiler.takePreciseCoverage", params=params,session_id=session_id)

cdp/protocol/profiler/methods/types.py

@@ -0,0 +1,45 @@
+"""CDP Profiler 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.profiler.types import Profile
+    from cdp.protocol.profiler.types import ScriptCoverage
+
+
+
+
+class setSamplingIntervalParameters(TypedDict, total=True):
+    interval: 'int'
+    """New sampling interval in microseconds."""
+
+class startPreciseCoverageParameters(TypedDict, total=False):
+    callCount: NotRequired['bool']
+    """Collect accurate call counts beyond simple 'covered' or 'not covered'."""
+    detailed: NotRequired['bool']
+    """Collect block-based coverage."""
+    allowTriggeredUpdates: NotRequired['bool']
+    """Allow the backend to send updates on its own initiative"""
+
+
+
+
+
+class getBestEffortCoverageReturns(TypedDict):
+    result: 'List[ScriptCoverage]'
+    """Coverage data for the current isolate."""
+
+
+class startPreciseCoverageReturns(TypedDict):
+    timestamp: 'float'
+    """Monotonically increasing time (in seconds) when the coverage update was taken in the backend."""
+class stopReturns(TypedDict):
+    profile: 'Profile'
+    """Recorded profile."""
+
+class takePreciseCoverageReturns(TypedDict):
+    result: 'List[ScriptCoverage]'
+    """Coverage data for the current isolate."""
+    timestamp: 'float'
+    """Monotonically increasing time (in seconds) when the coverage update was taken in the backend."""

cdp/protocol/profiler/service.py

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