anchorbrowser 0.1.0__py3-none-any.whl

anchorbrowser/resources/tools.py

@@ -0,0 +1,529 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import tool_fetch_webpage_params, tool_perform_web_task_params, tool_screenshot_webpage_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    BinaryAPIResponse,
+    AsyncBinaryAPIResponse,
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    to_custom_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_custom_streamed_response_wrapper,
+    async_to_custom_raw_response_wrapper,
+    async_to_custom_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.tool_perform_web_task_response import ToolPerformWebTaskResponse
+
+__all__ = ["ToolsResource", "AsyncToolsResource"]
+
+
+class ToolsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ToolsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return ToolsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ToolsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return ToolsResourceWithStreamingResponse(self)
+
+    def fetch_webpage(
+        self,
+        *,
+        session_id: str | NotGiven = NOT_GIVEN,
+        format: Literal["html", "markdown"] | NotGiven = NOT_GIVEN,
+        url: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> str:
+        """
+        Retrieve the rendered content of a webpage, optionally formatted as Markdown or
+        HTML.
+
+        Args:
+          session_id: An optional browser session identifier to reference an existing running browser
+              session. If provided, the tool will execute within that browser session.
+
+          format: The output format of the content.
+
+          url: The URL of the webpage to fetch content from. When left empty, the current
+              webpage is used.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"Accept": "text/plain", **(extra_headers or {})}
+        return self._post(
+            "/v1/tools/fetch-webpage",
+            body=maybe_transform(
+                {
+                    "format": format,
+                    "url": url,
+                },
+                tool_fetch_webpage_params.ToolFetchWebpageParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"session_id": session_id}, tool_fetch_webpage_params.ToolFetchWebpageParams),
+            ),
+            cast_to=str,
+        )
+
+    def perform_web_task(
+        self,
+        *,
+        prompt: str,
+        session_id: str | NotGiven = NOT_GIVEN,
+        output_schema: object | NotGiven = NOT_GIVEN,
+        url: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ToolPerformWebTaskResponse:
+        """
+        Start from a URL and perform the given task.
+
+        Args:
+          prompt: The task to be autonomously completed.
+
+          session_id: An optional browser session identifier to reference an existing running browser
+              sessions. When passed, the tool will be executed on the provided browser
+              session.
+
+          output_schema: JSON Schema defining the expected structure of the output data.
+
+          url: The URL of the webpage. If not provided, the tool will use the current page in
+              the session.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v1/tools/perform-web-task",
+            body=maybe_transform(
+                {
+                    "prompt": prompt,
+                    "output_schema": output_schema,
+                    "url": url,
+                },
+                tool_perform_web_task_params.ToolPerformWebTaskParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {"session_id": session_id}, tool_perform_web_task_params.ToolPerformWebTaskParams
+                ),
+            ),
+            cast_to=ToolPerformWebTaskResponse,
+        )
+
+    def screenshot_webpage(
+        self,
+        *,
+        session_id: str | NotGiven = NOT_GIVEN,
+        capture_full_height: bool | NotGiven = NOT_GIVEN,
+        height: int | NotGiven = NOT_GIVEN,
+        image_quality: int | NotGiven = NOT_GIVEN,
+        s3_target_address: str | NotGiven = NOT_GIVEN,
+        scroll_all_content: bool | NotGiven = NOT_GIVEN,
+        url: str | NotGiven = NOT_GIVEN,
+        wait: int | NotGiven = NOT_GIVEN,
+        width: int | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> BinaryAPIResponse:
+        """
+        This endpoint captures a screenshot of the specified webpage using Chromium.
+        Users can customize the viewport dimensions and capture options.
+
+        Args:
+          session_id: An optional browser session identifier to reference an existing running browser
+              sessions. When passed, the tool will be executed on the provided browser
+              session.
+
+          capture_full_height: If true, captures the entire height of the page, ignoring the viewport height.
+
+          height: The height of the browser viewport in pixels.
+
+          image_quality: Quality of the output image, on the range 1-100. 100 will not perform any
+              compression.
+
+          s3_target_address: Presigned S3 url target to upload the image to.
+
+          scroll_all_content: If true, scrolls the page and captures all visible content.
+
+          url: The URL of the webpage to capture.
+
+          wait: Duration in milliseconds to wait after page has loaded, mainly used for sites
+              with JS animations.
+
+          width: The width of the browser viewport in pixels.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"Accept": "image/png", **(extra_headers or {})}
+        return self._post(
+            "/v1/tools/screenshot",
+            body=maybe_transform(
+                {
+                    "capture_full_height": capture_full_height,
+                    "height": height,
+                    "image_quality": image_quality,
+                    "s3_target_address": s3_target_address,
+                    "scroll_all_content": scroll_all_content,
+                    "url": url,
+                    "wait": wait,
+                    "width": width,
+                },
+                tool_screenshot_webpage_params.ToolScreenshotWebpageParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {"session_id": session_id}, tool_screenshot_webpage_params.ToolScreenshotWebpageParams
+                ),
+            ),
+            cast_to=BinaryAPIResponse,
+        )
+
+
+class AsyncToolsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncToolsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncToolsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncToolsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AsyncToolsResourceWithStreamingResponse(self)
+
+    async def fetch_webpage(
+        self,
+        *,
+        session_id: str | NotGiven = NOT_GIVEN,
+        format: Literal["html", "markdown"] | NotGiven = NOT_GIVEN,
+        url: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> str:
+        """
+        Retrieve the rendered content of a webpage, optionally formatted as Markdown or
+        HTML.
+
+        Args:
+          session_id: An optional browser session identifier to reference an existing running browser
+              session. If provided, the tool will execute within that browser session.
+
+          format: The output format of the content.
+
+          url: The URL of the webpage to fetch content from. When left empty, the current
+              webpage is used.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"Accept": "text/plain", **(extra_headers or {})}
+        return await self._post(
+            "/v1/tools/fetch-webpage",
+            body=await async_maybe_transform(
+                {
+                    "format": format,
+                    "url": url,
+                },
+                tool_fetch_webpage_params.ToolFetchWebpageParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"session_id": session_id}, tool_fetch_webpage_params.ToolFetchWebpageParams
+                ),
+            ),
+            cast_to=str,
+        )
+
+    async def perform_web_task(
+        self,
+        *,
+        prompt: str,
+        session_id: str | NotGiven = NOT_GIVEN,
+        output_schema: object | NotGiven = NOT_GIVEN,
+        url: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ToolPerformWebTaskResponse:
+        """
+        Start from a URL and perform the given task.
+
+        Args:
+          prompt: The task to be autonomously completed.
+
+          session_id: An optional browser session identifier to reference an existing running browser
+              sessions. When passed, the tool will be executed on the provided browser
+              session.
+
+          output_schema: JSON Schema defining the expected structure of the output data.
+
+          url: The URL of the webpage. If not provided, the tool will use the current page in
+              the session.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v1/tools/perform-web-task",
+            body=await async_maybe_transform(
+                {
+                    "prompt": prompt,
+                    "output_schema": output_schema,
+                    "url": url,
+                },
+                tool_perform_web_task_params.ToolPerformWebTaskParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"session_id": session_id}, tool_perform_web_task_params.ToolPerformWebTaskParams
+                ),
+            ),
+            cast_to=ToolPerformWebTaskResponse,
+        )
+
+    async def screenshot_webpage(
+        self,
+        *,
+        session_id: str | NotGiven = NOT_GIVEN,
+        capture_full_height: bool | NotGiven = NOT_GIVEN,
+        height: int | NotGiven = NOT_GIVEN,
+        image_quality: int | NotGiven = NOT_GIVEN,
+        s3_target_address: str | NotGiven = NOT_GIVEN,
+        scroll_all_content: bool | NotGiven = NOT_GIVEN,
+        url: str | NotGiven = NOT_GIVEN,
+        wait: int | NotGiven = NOT_GIVEN,
+        width: int | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncBinaryAPIResponse:
+        """
+        This endpoint captures a screenshot of the specified webpage using Chromium.
+        Users can customize the viewport dimensions and capture options.
+
+        Args:
+          session_id: An optional browser session identifier to reference an existing running browser
+              sessions. When passed, the tool will be executed on the provided browser
+              session.
+
+          capture_full_height: If true, captures the entire height of the page, ignoring the viewport height.
+
+          height: The height of the browser viewport in pixels.
+
+          image_quality: Quality of the output image, on the range 1-100. 100 will not perform any
+              compression.
+
+          s3_target_address: Presigned S3 url target to upload the image to.
+
+          scroll_all_content: If true, scrolls the page and captures all visible content.
+
+          url: The URL of the webpage to capture.
+
+          wait: Duration in milliseconds to wait after page has loaded, mainly used for sites
+              with JS animations.
+
+          width: The width of the browser viewport in pixels.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"Accept": "image/png", **(extra_headers or {})}
+        return await self._post(
+            "/v1/tools/screenshot",
+            body=await async_maybe_transform(
+                {
+                    "capture_full_height": capture_full_height,
+                    "height": height,
+                    "image_quality": image_quality,
+                    "s3_target_address": s3_target_address,
+                    "scroll_all_content": scroll_all_content,
+                    "url": url,
+                    "wait": wait,
+                    "width": width,
+                },
+                tool_screenshot_webpage_params.ToolScreenshotWebpageParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"session_id": session_id}, tool_screenshot_webpage_params.ToolScreenshotWebpageParams
+                ),
+            ),
+            cast_to=AsyncBinaryAPIResponse,
+        )
+
+
+class ToolsResourceWithRawResponse:
+    def __init__(self, tools: ToolsResource) -> None:
+        self._tools = tools
+
+        self.fetch_webpage = to_raw_response_wrapper(
+            tools.fetch_webpage,
+        )
+        self.perform_web_task = to_raw_response_wrapper(
+            tools.perform_web_task,
+        )
+        self.screenshot_webpage = to_custom_raw_response_wrapper(
+            tools.screenshot_webpage,
+            BinaryAPIResponse,
+        )
+
+
+class AsyncToolsResourceWithRawResponse:
+    def __init__(self, tools: AsyncToolsResource) -> None:
+        self._tools = tools
+
+        self.fetch_webpage = async_to_raw_response_wrapper(
+            tools.fetch_webpage,
+        )
+        self.perform_web_task = async_to_raw_response_wrapper(
+            tools.perform_web_task,
+        )
+        self.screenshot_webpage = async_to_custom_raw_response_wrapper(
+            tools.screenshot_webpage,
+            AsyncBinaryAPIResponse,
+        )
+
+
+class ToolsResourceWithStreamingResponse:
+    def __init__(self, tools: ToolsResource) -> None:
+        self._tools = tools
+
+        self.fetch_webpage = to_streamed_response_wrapper(
+            tools.fetch_webpage,
+        )
+        self.perform_web_task = to_streamed_response_wrapper(
+            tools.perform_web_task,
+        )
+        self.screenshot_webpage = to_custom_streamed_response_wrapper(
+            tools.screenshot_webpage,
+            StreamedBinaryAPIResponse,
+        )
+
+
+class AsyncToolsResourceWithStreamingResponse:
+    def __init__(self, tools: AsyncToolsResource) -> None:
+        self._tools = tools
+
+        self.fetch_webpage = async_to_streamed_response_wrapper(
+            tools.fetch_webpage,
+        )
+        self.perform_web_task = async_to_streamed_response_wrapper(
+            tools.perform_web_task,
+        )
+        self.screenshot_webpage = async_to_custom_streamed_response_wrapper(
+            tools.screenshot_webpage,
+            AsyncStreamedBinaryAPIResponse,
+        )

anchorbrowser/types/__init__.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .shared import SuccessResponse as SuccessResponse
+from .extension_manifest import ExtensionManifest as ExtensionManifest
+from .session_goto_params import SessionGotoParams as SessionGotoParams
+from .session_paste_params import SessionPasteParams as SessionPasteParams
+from .profile_create_params import ProfileCreateParams as ProfileCreateParams
+from .profile_list_response import ProfileListResponse as ProfileListResponse
+from .profile_update_params import ProfileUpdateParams as ProfileUpdateParams
+from .session_copy_response import SessionCopyResponse as SessionCopyResponse
+from .session_create_params import SessionCreateParams as SessionCreateParams
+from .session_goto_response import SessionGotoResponse as SessionGotoResponse
+from .session_scroll_params import SessionScrollParams as SessionScrollParams
+from .session_paste_response import SessionPasteResponse as SessionPasteResponse
+from .extension_list_response import ExtensionListResponse as ExtensionListResponse
+from .extension_upload_params import ExtensionUploadParams as ExtensionUploadParams
+from .session_create_response import SessionCreateResponse as SessionCreateResponse
+from .session_scroll_response import SessionScrollResponse as SessionScrollResponse
+from .extension_delete_response import ExtensionDeleteResponse as ExtensionDeleteResponse
+from .extension_upload_response import ExtensionUploadResponse as ExtensionUploadResponse
+from .profile_retrieve_response import ProfileRetrieveResponse as ProfileRetrieveResponse
+from .tool_fetch_webpage_params import ToolFetchWebpageParams as ToolFetchWebpageParams
+from .extension_retrieve_response import ExtensionRetrieveResponse as ExtensionRetrieveResponse
+from .tool_fetch_webpage_response import ToolFetchWebpageResponse as ToolFetchWebpageResponse
+from .session_drag_and_drop_params import SessionDragAndDropParams as SessionDragAndDropParams
+from .tool_perform_web_task_params import ToolPerformWebTaskParams as ToolPerformWebTaskParams
+from .session_drag_and_drop_response import SessionDragAndDropResponse as SessionDragAndDropResponse
+from .tool_perform_web_task_response import ToolPerformWebTaskResponse as ToolPerformWebTaskResponse
+from .tool_screenshot_webpage_params import ToolScreenshotWebpageParams as ToolScreenshotWebpageParams
+from .session_retrieve_downloads_response import SessionRetrieveDownloadsResponse as SessionRetrieveDownloadsResponse

anchorbrowser/types/extension_delete_response.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+from .shared.success_response import SuccessResponse
+
+__all__ = ["ExtensionDeleteResponse"]
+
+
+class ExtensionDeleteResponse(BaseModel):
+    data: Optional[SuccessResponse] = None

anchorbrowser/types/extension_list_response.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .extension_manifest import ExtensionManifest
+
+__all__ = ["ExtensionListResponse", "Data"]
+
+
+class Data(BaseModel):
+    id: Optional[str] = None
+    """Unique identifier for the extension"""
+
+    created_at: Optional[datetime] = FieldInfo(alias="createdAt", default=None)
+    """Timestamp when the extension was created"""
+
+    manifest: Optional[ExtensionManifest] = None
+
+    name: Optional[str] = None
+    """Extension name"""
+
+    updated_at: Optional[datetime] = FieldInfo(alias="updatedAt", default=None)
+    """Timestamp when the extension was last updated"""
+
+
+class ExtensionListResponse(BaseModel):
+    data: Optional[List[Data]] = None

anchorbrowser/types/extension_manifest.py

@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ExtensionManifest"]
+
+
+class ExtensionManifest(BaseModel):
+    description: Optional[str] = None
+
+    manifest_version: Optional[int] = None
+
+    name: Optional[str] = None
+
+    permissions: Optional[List[str]] = None
+
+    version: Optional[str] = None
+
+    __pydantic_extra__: Dict[str, object] = FieldInfo(init=False)  # pyright: ignore[reportIncompatibleVariableOverride]
+    if TYPE_CHECKING:
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...

anchorbrowser/types/extension_retrieve_response.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .extension_manifest import ExtensionManifest
+
+__all__ = ["ExtensionRetrieveResponse"]
+
+
+class ExtensionRetrieveResponse(BaseModel):
+    id: Optional[str] = None
+    """Unique identifier for the extension"""
+
+    created_at: Optional[datetime] = FieldInfo(alias="createdAt", default=None)
+    """Timestamp when the extension was created"""
+
+    manifest: Optional[ExtensionManifest] = None
+
+    name: Optional[str] = None
+    """Extension name"""
+
+    updated_at: Optional[datetime] = FieldInfo(alias="updatedAt", default=None)
+    """Timestamp when the extension was last updated"""

anchorbrowser/types/extension_upload_params.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from .._types import FileTypes
+
+__all__ = ["ExtensionUploadParams"]
+
+
+class ExtensionUploadParams(TypedDict, total=False):
+    file: Required[FileTypes]
+    """ZIP file containing the browser extension"""
+
+    name: Required[str]
+    """User-friendly name for the extension (1-255 characters)"""