kernel 0.72.0__tar.gz → 0.73.0__tar.gz

kernel-0.73.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.73.0"
+}

{kernel-0.72.0 → kernel-0.73.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.73.0 (2026-07-01)
+
+Full Changelog: [v0.72.0...v0.73.0](https://github.com/kernel/kernel-python-sdk/compare/v0.72.0...v0.73.0)
+
+### Features
+
+* Add hidden audit-logs export endpoint ([619c672](https://github.com/kernel/kernel-python-sdk/commit/619c6720f986b835393793896bb5ad4b64f8673f))
+
 ## 0.72.0 (2026-06-26)
 
 Full Changelog: [v0.71.0...v0.72.0](https://github.com/kernel/kernel-python-sdk/compare/v0.71.0...v0.72.0)

{kernel-0.72.0 → kernel-0.73.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kernel
-Version: 0.72.0
+Version: 0.73.0
 Summary: The official Python library for the kernel API
 Project-URL: Homepage, https://github.com/kernel/kernel-python-sdk
 Project-URL: Repository, https://github.com/kernel/kernel-python-sdk

{kernel-0.72.0 → kernel-0.73.0}/api.md

@@ -454,6 +454,7 @@ from kernel.types import AuditLogEntry
 Methods:
 
 - <code title="get /audit-logs">client.audit_logs.<a href="./src/kernel/resources/audit_logs.py">list</a>(\*\*<a href="src/kernel/types/audit_log_list_params.py">params</a>) -> <a href="./src/kernel/types/audit_log_entry.py">SyncPageTokenPagination[AuditLogEntry]</a></code>
+- <code title="get /audit-logs/export/chunk">client.audit_logs.<a href="./src/kernel/resources/audit_logs.py">export_chunk</a>(\*\*<a href="src/kernel/types/audit_log_export_chunk_params.py">params</a>) -> BinaryAPIResponse</code>
 
 # APIKeys
 

{kernel-0.72.0 → kernel-0.73.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kernel"
-version = "0.72.0"
+version = "0.73.0"
 description = "The official Python library for the kernel API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{kernel-0.72.0 → kernel-0.73.0}/src/kernel/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "kernel"
-__version__ = "0.72.0"  # x-release-please-version
+__version__ = "0.73.0"  # x-release-please-version

{kernel-0.72.0 → kernel-0.73.0}/src/kernel/resources/audit_logs.py

@@ -4,19 +4,28 @@ from __future__ import annotations
 
 from typing import Union
 from datetime import datetime
+from typing_extensions import Literal
 
 import httpx
 
-from ..types import audit_log_list_params
+from ..types import audit_log_list_params, audit_log_export_chunk_params
 from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
-from .._utils import maybe_transform
+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 ..pagination import SyncPageTokenPagination, AsyncPageTokenPagination
 from .._base_client import AsyncPaginator, make_request_options
@@ -128,6 +137,91 @@ class AuditLogsResource(SyncAPIResource):
             model=AuditLogEntry,
         )
 
+    def export_chunk(
+        self,
+        *,
+        end: Union[str, datetime],
+        start: Union[str, datetime],
+        auth_strategy: str | Omit = omit,
+        cursor: str | Omit = omit,
+        exclude_method: str | Omit = omit,
+        format: Literal["jsonl", "jsonl.gz"] | Omit = omit,
+        limit: int | Omit = omit,
+        method: str | Omit = omit,
+        search: str | Omit = omit,
+        search_user_id: SequenceNotStr[str] | Omit = omit,
+        service: str | Omit = omit,
+        # 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:
+        """
+        Download an organization's audit log records for a time range as a file, for
+        archival, compliance, or offline analysis. For interactive browsing, use GET
+        /audit-logs.
+
+        Args:
+          end: Upper bound (exclusive) for the audit record timestamp.
+
+          start: Lower bound (inclusive) for the audit record timestamp.
+
+          auth_strategy: Filter by authentication strategy.
+
+          cursor: Opaque cursor from X-Next-Cursor for the next chunk of older records.
+
+          exclude_method: Filter out results by HTTP method.
+
+          format: Encoding for the returned chunk.
+
+          limit: Maximum number of records to return in this chunk.
+
+          method: Filter by HTTP method.
+
+          search: Free-text search over path, user ID, email, client IP, and status.
+
+          search_user_id: Additional user IDs to OR into free-text search.
+
+          service: Filter by service name.
+
+          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": "application/octet-stream", **(extra_headers or {})}
+        return self._get(
+            "/audit-logs/export/chunk",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "end": end,
+                        "start": start,
+                        "auth_strategy": auth_strategy,
+                        "cursor": cursor,
+                        "exclude_method": exclude_method,
+                        "format": format,
+                        "limit": limit,
+                        "method": method,
+                        "search": search,
+                        "search_user_id": search_user_id,
+                        "service": service,
+                    },
+                    audit_log_export_chunk_params.AuditLogExportChunkParams,
+                ),
+            ),
+            cast_to=BinaryAPIResponse,
+        )
+
 
 class AsyncAuditLogsResource(AsyncAPIResource):
     """Read audit log records for the authenticated organization."""
@@ -232,6 +326,91 @@ class AsyncAuditLogsResource(AsyncAPIResource):
             model=AuditLogEntry,
         )
 
+    async def export_chunk(
+        self,
+        *,
+        end: Union[str, datetime],
+        start: Union[str, datetime],
+        auth_strategy: str | Omit = omit,
+        cursor: str | Omit = omit,
+        exclude_method: str | Omit = omit,
+        format: Literal["jsonl", "jsonl.gz"] | Omit = omit,
+        limit: int | Omit = omit,
+        method: str | Omit = omit,
+        search: str | Omit = omit,
+        search_user_id: SequenceNotStr[str] | Omit = omit,
+        service: str | Omit = omit,
+        # 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:
+        """
+        Download an organization's audit log records for a time range as a file, for
+        archival, compliance, or offline analysis. For interactive browsing, use GET
+        /audit-logs.
+
+        Args:
+          end: Upper bound (exclusive) for the audit record timestamp.
+
+          start: Lower bound (inclusive) for the audit record timestamp.
+
+          auth_strategy: Filter by authentication strategy.
+
+          cursor: Opaque cursor from X-Next-Cursor for the next chunk of older records.
+
+          exclude_method: Filter out results by HTTP method.
+
+          format: Encoding for the returned chunk.
+
+          limit: Maximum number of records to return in this chunk.
+
+          method: Filter by HTTP method.
+
+          search: Free-text search over path, user ID, email, client IP, and status.
+
+          search_user_id: Additional user IDs to OR into free-text search.
+
+          service: Filter by service name.
+
+          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": "application/octet-stream", **(extra_headers or {})}
+        return await self._get(
+            "/audit-logs/export/chunk",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "end": end,
+                        "start": start,
+                        "auth_strategy": auth_strategy,
+                        "cursor": cursor,
+                        "exclude_method": exclude_method,
+                        "format": format,
+                        "limit": limit,
+                        "method": method,
+                        "search": search,
+                        "search_user_id": search_user_id,
+                        "service": service,
+                    },
+                    audit_log_export_chunk_params.AuditLogExportChunkParams,
+                ),
+            ),
+            cast_to=AsyncBinaryAPIResponse,
+        )
+
 
 class AuditLogsResourceWithRawResponse:
     def __init__(self, audit_logs: AuditLogsResource) -> None:
@@ -240,6 +419,10 @@ class AuditLogsResourceWithRawResponse:
         self.list = to_raw_response_wrapper(
             audit_logs.list,
         )
+        self.export_chunk = to_custom_raw_response_wrapper(
+            audit_logs.export_chunk,
+            BinaryAPIResponse,
+        )
 
 
 class AsyncAuditLogsResourceWithRawResponse:
@@ -249,6 +432,10 @@ class AsyncAuditLogsResourceWithRawResponse:
         self.list = async_to_raw_response_wrapper(
             audit_logs.list,
         )
+        self.export_chunk = async_to_custom_raw_response_wrapper(
+            audit_logs.export_chunk,
+            AsyncBinaryAPIResponse,
+        )
 
 
 class AuditLogsResourceWithStreamingResponse:
@@ -258,6 +445,10 @@ class AuditLogsResourceWithStreamingResponse:
         self.list = to_streamed_response_wrapper(
             audit_logs.list,
         )
+        self.export_chunk = to_custom_streamed_response_wrapper(
+            audit_logs.export_chunk,
+            StreamedBinaryAPIResponse,
+        )
 
 
 class AsyncAuditLogsResourceWithStreamingResponse:
@@ -267,3 +458,7 @@ class AsyncAuditLogsResourceWithStreamingResponse:
         self.list = async_to_streamed_response_wrapper(
             audit_logs.list,
         )
+        self.export_chunk = async_to_custom_streamed_response_wrapper(
+            audit_logs.export_chunk,
+            AsyncStreamedBinaryAPIResponse,
+        )

{kernel-0.72.0 → kernel-0.73.0}/src/kernel/types/__init__.py

@@ -90,6 +90,7 @@ from .browser_pool_acquire_params import BrowserPoolAcquireParams as BrowserPool
 from .browser_pool_release_params import BrowserPoolReleaseParams as BrowserPoolReleaseParams
 from .deployment_retrieve_response import DeploymentRetrieveResponse as DeploymentRetrieveResponse
 from .invocation_retrieve_response import InvocationRetrieveResponse as InvocationRetrieveResponse
+from .audit_log_export_chunk_params import AuditLogExportChunkParams as AuditLogExportChunkParams
 from .browser_pool_acquire_response import BrowserPoolAcquireResponse as BrowserPoolAcquireResponse
 from .credential_totp_code_response import CredentialTotpCodeResponse as CredentialTotpCodeResponse
 from .browser_load_extensions_params import BrowserLoadExtensionsParams as BrowserLoadExtensionsParams

kernel-0.73.0/src/kernel/types/audit_log_export_chunk_params.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from .._types import SequenceNotStr
+from .._utils import PropertyInfo
+
+__all__ = ["AuditLogExportChunkParams"]
+
+
+class AuditLogExportChunkParams(TypedDict, total=False):
+    end: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """Upper bound (exclusive) for the audit record timestamp."""
+
+    start: Required[Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]]
+    """Lower bound (inclusive) for the audit record timestamp."""
+
+    auth_strategy: str
+    """Filter by authentication strategy."""
+
+    cursor: str
+    """Opaque cursor from X-Next-Cursor for the next chunk of older records."""
+
+    exclude_method: str
+    """Filter out results by HTTP method."""
+
+    format: Literal["jsonl", "jsonl.gz"]
+    """Encoding for the returned chunk."""
+
+    limit: int
+    """Maximum number of records to return in this chunk."""
+
+    method: str
+    """Filter by HTTP method."""
+
+    search: str
+    """Free-text search over path, user ID, email, client IP, and status."""
+
+    search_user_id: SequenceNotStr[str]
+    """Additional user IDs to OR into free-text search."""
+
+    service: str
+    """Filter by service name."""

kernel-0.73.0/tests/api_resources/test_audit_logs.py

@@ -0,0 +1,276 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import httpx
+import pytest
+from respx import MockRouter
+
+from kernel import Kernel, AsyncKernel
+from tests.utils import assert_matches_type
+from kernel.types import AuditLogEntry
+from kernel._utils import parse_datetime
+from kernel._response import (
+    BinaryAPIResponse,
+    AsyncBinaryAPIResponse,
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+)
+from kernel.pagination import SyncPageTokenPagination, AsyncPageTokenPagination
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestAuditLogs:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_method_list(self, client: Kernel) -> None:
+        audit_log = client.audit_logs.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+        assert_matches_type(SyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_method_list_with_all_params(self, client: Kernel) -> None:
+        audit_log = client.audit_logs.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+            auth_strategy="auth_strategy",
+            exclude_method="exclude_method",
+            limit=1,
+            method="method",
+            page_token="page_token",
+            search="search",
+            search_user_id=["string"],
+            service="service",
+        )
+        assert_matches_type(SyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_raw_response_list(self, client: Kernel) -> None:
+        response = client.audit_logs.with_raw_response.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        audit_log = response.parse()
+        assert_matches_type(SyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    def test_streaming_response_list(self, client: Kernel) -> None:
+        with client.audit_logs.with_streaming_response.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            audit_log = response.parse()
+            assert_matches_type(SyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_method_export_chunk(self, client: Kernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        audit_log = client.audit_logs.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+        assert audit_log.is_closed
+        assert audit_log.json() == {"foo": "bar"}
+        assert cast(Any, audit_log.is_closed) is True
+        assert isinstance(audit_log, BinaryAPIResponse)
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_method_export_chunk_with_all_params(self, client: Kernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        audit_log = client.audit_logs.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+            auth_strategy="auth_strategy",
+            cursor="cursor",
+            exclude_method="exclude_method",
+            format="jsonl",
+            limit=1,
+            method="method",
+            search="search",
+            search_user_id=["string"],
+            service="service",
+        )
+        assert audit_log.is_closed
+        assert audit_log.json() == {"foo": "bar"}
+        assert cast(Any, audit_log.is_closed) is True
+        assert isinstance(audit_log, BinaryAPIResponse)
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_raw_response_export_chunk(self, client: Kernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+
+        audit_log = client.audit_logs.with_raw_response.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+
+        assert audit_log.is_closed is True
+        assert audit_log.http_request.headers.get("X-Stainless-Lang") == "python"
+        assert audit_log.json() == {"foo": "bar"}
+        assert isinstance(audit_log, BinaryAPIResponse)
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_streaming_response_export_chunk(self, client: Kernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        with client.audit_logs.with_streaming_response.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        ) as audit_log:
+            assert not audit_log.is_closed
+            assert audit_log.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            assert audit_log.json() == {"foo": "bar"}
+            assert cast(Any, audit_log.is_closed) is True
+            assert isinstance(audit_log, StreamedBinaryAPIResponse)
+
+        assert cast(Any, audit_log.is_closed) is True
+
+
+class TestAsyncAuditLogs:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_method_list(self, async_client: AsyncKernel) -> None:
+        audit_log = await async_client.audit_logs.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+        assert_matches_type(AsyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncKernel) -> None:
+        audit_log = await async_client.audit_logs.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+            auth_strategy="auth_strategy",
+            exclude_method="exclude_method",
+            limit=1,
+            method="method",
+            page_token="page_token",
+            search="search",
+            search_user_id=["string"],
+            service="service",
+        )
+        assert_matches_type(AsyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncKernel) -> None:
+        response = await async_client.audit_logs.with_raw_response.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        audit_log = await response.parse()
+        assert_matches_type(AsyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+    @pytest.mark.skip(reason="Mock server tests are disabled")
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncKernel) -> None:
+        async with async_client.audit_logs.with_streaming_response.list(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            audit_log = await response.parse()
+            assert_matches_type(AsyncPageTokenPagination[AuditLogEntry], audit_log, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_method_export_chunk(self, async_client: AsyncKernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        audit_log = await async_client.audit_logs.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+        assert audit_log.is_closed
+        assert await audit_log.json() == {"foo": "bar"}
+        assert cast(Any, audit_log.is_closed) is True
+        assert isinstance(audit_log, AsyncBinaryAPIResponse)
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_method_export_chunk_with_all_params(self, async_client: AsyncKernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        audit_log = await async_client.audit_logs.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+            auth_strategy="auth_strategy",
+            cursor="cursor",
+            exclude_method="exclude_method",
+            format="jsonl",
+            limit=1,
+            method="method",
+            search="search",
+            search_user_id=["string"],
+            service="service",
+        )
+        assert audit_log.is_closed
+        assert await audit_log.json() == {"foo": "bar"}
+        assert cast(Any, audit_log.is_closed) is True
+        assert isinstance(audit_log, AsyncBinaryAPIResponse)
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_raw_response_export_chunk(self, async_client: AsyncKernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+
+        audit_log = await async_client.audit_logs.with_raw_response.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        )
+
+        assert audit_log.is_closed is True
+        assert audit_log.http_request.headers.get("X-Stainless-Lang") == "python"
+        assert await audit_log.json() == {"foo": "bar"}
+        assert isinstance(audit_log, AsyncBinaryAPIResponse)
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_streaming_response_export_chunk(self, async_client: AsyncKernel, respx_mock: MockRouter) -> None:
+        respx_mock.get("/audit-logs/export/chunk").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        async with async_client.audit_logs.with_streaming_response.export_chunk(
+            end=parse_datetime("2026-01-02T00:00:00Z"),
+            start=parse_datetime("2026-01-01T00:00:00Z"),
+        ) as audit_log:
+            assert not audit_log.is_closed
+            assert audit_log.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            assert await audit_log.json() == {"foo": "bar"}
+            assert cast(Any, audit_log.is_closed) is True
+            assert isinstance(audit_log, AsyncStreamedBinaryAPIResponse)
+
+        assert cast(Any, audit_log.is_closed) is True

kernel-0.72.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.72.0"
-}