@utdk/posthog 1.0.0-20260712.5-dev.e2949a6

package/docs/reverse_proxy.md

@@ -0,0 +1,200 @@
+# Reverse Proxy
+
+## Operations
+
+### `posthog.proxyRecordsList`
+
+- **HTTP**: `GET /api/organizations/{organization_id}/proxy_records/`
+- **What it does**: List all reverse proxies configured for the organization. Returns proxy records along with the maximum number allowed by the current plan.
+- **OpenAPI operationId**: `proxy_records_list`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ results: ({ id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: strin...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type ProxyRecordsListInput = Parameters<typeof posthog.proxyRecordsList> extends [infer T, ...unknown[]] ? T : undefined;
+type ProxyRecordsListOutput = Awaited<ReturnType<typeof posthog.proxyRecordsList>>;
+
+const result: ProxyRecordsListOutput = await posthog.proxyRecordsList();
+
+// Result shape (from schema): ({ results: ({ id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: strin...
+```
+
+### `posthog.proxyRecordsCreate`
+
+- **HTTP**: `POST /api/organizations/{organization_id}/proxy_records/`
+- **What it does**: Create a new managed reverse proxy. Provide the domain you want to proxy through. The response includes the CNAME target you need to add as a DNS record. Once the CNAME is configured, the proxy will be automatically verified and provisioned.
+- **OpenAPI operationId**: `proxy_records_create`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `201`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: string; created_by...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type ProxyRecordsCreateInput = Parameters<typeof posthog.proxyRecordsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type ProxyRecordsCreateOutput = Awaited<ReturnType<typeof posthog.proxyRecordsCreate>>;
+
+const result: ProxyRecordsCreateOutput = await posthog.proxyRecordsCreate();
+
+// Result shape (from schema): { id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: string; created_by...
+```
+
+### `posthog.proxyRecordsDestroy`
+
+- **HTTP**: `DELETE /api/organizations/{organization_id}/proxy_records/{id}/`
+- **What it does**: Delete a reverse proxy. For proxies in 'waiting', 'erroring', or 'timed_out' status, the record is deleted immediately. For active proxies, a deletion workflow is started to clean up the provisioned infrastructure.
+- **OpenAPI operationId**: `proxy_records_destroy`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type ProxyRecordsDestroyInput = Parameters<typeof posthog.proxyRecordsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type ProxyRecordsDestroyOutput = Awaited<ReturnType<typeof posthog.proxyRecordsDestroy>>;
+
+const result: ProxyRecordsDestroyOutput = await posthog.proxyRecordsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.proxyRecordsRetrieve`
+
+- **HTTP**: `GET /api/organizations/{organization_id}/proxy_records/{id}/`
+- **What it does**: Get details of a specific reverse proxy by ID. Returns the full configuration including domain, CNAME target, and current provisioning status.
+- **OpenAPI operationId**: `proxy_records_retrieve`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: string; created_by...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type ProxyRecordsRetrieveInput = Parameters<typeof posthog.proxyRecordsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type ProxyRecordsRetrieveOutput = Awaited<ReturnType<typeof posthog.proxyRecordsRetrieve>>;
+
+const result: ProxyRecordsRetrieveOutput = await posthog.proxyRecordsRetrieve();
+
+// Result shape (from schema): { id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: string; created_by...
+```
+
+### `posthog.proxyRecordsDiagnoseCreate`
+
+- **HTTP**: `POST /api/organizations/{organization_id}/proxy_records/{id}/diagnose/`
+- **What it does**: Run a deep diagnostic on a reverse proxy. Inspects DNS CNAME alignment, the certificate provider's hostname state, CAA records walked up the customer's DNS tree, HTTP-01 challenge reachability, a live event probe, and certificate expiry. Returns a structured report with each check's status and concrete remediation steps (e.g. exact DNS records to add). Use this to debug why a proxy is stuck or erroring.
+- **OpenAPI operationId**: `proxy_records_diagnose_create`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ ran_at: string; summary: { status: "healthy" | "warn" | "fail"; primary_issue: string | null; next_action: string | null }; checks: ({ id: string; name: string; status: "passed" | "warned" | "failed" | "skipped"; deta...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type ProxyRecordsDiagnoseCreateInput = Parameters<typeof posthog.proxyRecordsDiagnoseCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type ProxyRecordsDiagnoseCreateOutput = Awaited<ReturnType<typeof posthog.proxyRecordsDiagnoseCreate>>;
+
+const result: ProxyRecordsDiagnoseCreateOutput = await posthog.proxyRecordsDiagnoseCreate();
+
+// Result shape (from schema): { ran_at: string; summary: { status: "healthy" | "warn" | "fail"; primary_issue: string | null; next_action: string | null }; checks: ({ id: string; name: string; status: "passed" | "warned" | "failed" | "skipped"; deta...
+```
+
+### `posthog.proxyRecordsRetryCreate`
+
+- **HTTP**: `POST /api/organizations/{organization_id}/proxy_records/{id}/retry/`
+- **What it does**: Retry provisioning a failed reverse proxy. Only available for proxies in 'erroring' or 'timed_out' status. Resets the proxy to 'waiting' status and restarts the provisioning workflow.
+- **OpenAPI operationId**: `proxy_records_retry_create`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: string; created_by...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type ProxyRecordsRetryCreateInput = Parameters<typeof posthog.proxyRecordsRetryCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type ProxyRecordsRetryCreateOutput = Awaited<ReturnType<typeof posthog.proxyRecordsRetryCreate>>;
+
+const result: ProxyRecordsRetryCreateOutput = await posthog.proxyRecordsRetryCreate();
+
+// Result shape (from schema): { id: string; domain: string; target_cname: string; status: "waiting" | "issuing" | "valid" | "warning" | "erroring" | "deleting" | "timed_out"; message: string | null; created_at: string; updated_at: string; created_by...
+```
+
+
+<!-- prompt-hash:
+8c3694991a4c289225f05a4e8f1e098cc74d085a088d7dffd82f00d93797b7f8
+-->

package/docs/sandbox-custom-images.md

@@ -0,0 +1,209 @@
+# Sandbox Custom Images
+
+## Operations
+
+### `posthog.sandboxCustomImagesList`
+
+- **HTTP**: `GET /api/projects/{project_id}/sandbox_custom_images/`
+- **What it does**: API for custom sandbox base images, built on top of the VM sandbox base via an image-builder agent.
+
+Custom images only run on the Modal VM runtime, so every action is gated on the
+`tasks-modal-vm-sandbox` flag (org-enabled with `user_created` in its origin_products payload).
+- **OpenAPI operationId**: `sandbox_custom_images_list`
+- **Path params**: None
+- **Query params**: `limit`, `offset`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: stri...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxCustomImagesListInput = Parameters<typeof posthog.sandboxCustomImagesList> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxCustomImagesListOutput = Awaited<ReturnType<typeof posthog.sandboxCustomImagesList>>;
+
+const result: SandboxCustomImagesListOutput = await posthog.sandboxCustomImagesList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: stri...
+```
+
+### `posthog.sandboxCustomImagesCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/sandbox_custom_images/`
+- **What it does**: Create a draft custom image and start its interactive image-builder agent task. The returned builder_task_id points at the conversation.
+- **OpenAPI operationId**: `sandbox_custom_images_create`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `201`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxCustomImagesCreateInput = Parameters<typeof posthog.sandboxCustomImagesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxCustomImagesCreateOutput = Awaited<ReturnType<typeof posthog.sandboxCustomImagesCreate>>;
+
+const result: SandboxCustomImagesCreateOutput = await posthog.sandboxCustomImagesCreate();
+
+// Result shape (from schema): { id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...
+```
+
+### `posthog.sandboxCustomImagesDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/sandbox_custom_images/{id}/`
+- **What it does**: API for custom sandbox base images, built on top of the VM sandbox base via an image-builder agent.
+
+Custom images only run on the Modal VM runtime, so every action is gated on the
+`tasks-modal-vm-sandbox` flag (org-enabled with `user_created` in its origin_products payload).
+- **OpenAPI operationId**: `sandbox_custom_images_destroy`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxCustomImagesDestroyInput = Parameters<typeof posthog.sandboxCustomImagesDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxCustomImagesDestroyOutput = Awaited<ReturnType<typeof posthog.sandboxCustomImagesDestroy>>;
+
+const result: SandboxCustomImagesDestroyOutput = await posthog.sandboxCustomImagesDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.sandboxCustomImagesRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/sandbox_custom_images/{id}/`
+- **What it does**: API for custom sandbox base images, built on top of the VM sandbox base via an image-builder agent.
+
+Custom images only run on the Modal VM runtime, so every action is gated on the
+`tasks-modal-vm-sandbox` flag (org-enabled with `user_created` in its origin_products payload).
+- **OpenAPI operationId**: `sandbox_custom_images_retrieve`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxCustomImagesRetrieveInput = Parameters<typeof posthog.sandboxCustomImagesRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxCustomImagesRetrieveOutput = Awaited<ReturnType<typeof posthog.sandboxCustomImagesRetrieve>>;
+
+const result: SandboxCustomImagesRetrieveOutput = await posthog.sandboxCustomImagesRetrieve();
+
+// Result shape (from schema): { id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...
+```
+
+### `posthog.sandboxCustomImagesBuildCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/sandbox_custom_images/{id}/build/`
+- **What it does**: Persist the image spec (from the request body or the builder agent's sandbox), run the security scan, and on pass build and publish the image.
+- **OpenAPI operationId**: `sandbox_custom_images_build_create`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxCustomImagesBuildCreateInput = Parameters<typeof posthog.sandboxCustomImagesBuildCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxCustomImagesBuildCreateOutput = Awaited<ReturnType<typeof posthog.sandboxCustomImagesBuildCreate>>;
+
+const result: SandboxCustomImagesBuildCreateOutput = await posthog.sandboxCustomImagesBuildCreate();
+
+// Result shape (from schema): { id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...
+```
+
+### `posthog.sandboxCustomImagesBuilderTaskCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/sandbox_custom_images/{id}/builder_task/`
+- **What it does**: Revive (or reuse) the image's builder agent session. When the previous session has ended, a fresh one is started seeded with the stored spec — use this to update an existing image.
+- **OpenAPI operationId**: `sandbox_custom_images_builder_task_create`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxCustomImagesBuilderTaskCreateInput = Parameters<typeof posthog.sandboxCustomImagesBuilderTaskCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxCustomImagesBuilderTaskCreateOutput = Awaited<ReturnType<typeof posthog.sandboxCustomImagesBuilderTaskCreate>>;
+
+const result: SandboxCustomImagesBuilderTaskCreateOutput = await posthog.sandboxCustomImagesBuilderTaskCreate();
+
+// Result shape (from schema): { id: string; name: string; description: string; repository?: string; private?: boolean; status: string; version: number; modal_image_name: string; spec?: { [key: string]: unknown }; spec_yaml?: string; scan_result?: { ...
+```
+
+
+<!-- prompt-hash:
+8c3694991a4c289225f05a4e8f1e098cc74d085a088d7dffd82f00d93797b7f8
+-->

package/docs/sandbox-environments.md

@@ -0,0 +1,168 @@
+# Sandbox Environments
+
+## Operations
+
+### `posthog.sandboxList`
+
+- **HTTP**: `GET /api/projects/{project_id}/sandbox_environments/`
+- **What it does**: API for managing sandbox environments that control network access for task runs.
+- **OpenAPI operationId**: `sandbox_list`
+- **Path params**: None
+- **Query params**: `limit`, `offset`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: b...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxListInput = Parameters<typeof posthog.sandboxList> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxListOutput = Awaited<ReturnType<typeof posthog.sandboxList>>;
+
+const result: SandboxListOutput = await posthog.sandboxList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: b...
+```
+
+### `posthog.sandboxCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/sandbox_environments/`
+- **What it does**: API for managing sandbox environments that control network access for task runs.
+- **OpenAPI operationId**: `sandbox_create`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `201`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: boolean; created_by?: { id: number; uuid: string; distinct_id: string; first...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxCreateInput = Parameters<typeof posthog.sandboxCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxCreateOutput = Awaited<ReturnType<typeof posthog.sandboxCreate>>;
+
+const result: SandboxCreateOutput = await posthog.sandboxCreate();
+
+// Result shape (from schema): { id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: boolean; created_by?: { id: number; uuid: string; distinct_id: string; first...
+```
+
+### `posthog.sandboxDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/sandbox_environments/{id}/`
+- **What it does**: API for managing sandbox environments that control network access for task runs.
+- **OpenAPI operationId**: `sandbox_destroy`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxDestroyInput = Parameters<typeof posthog.sandboxDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxDestroyOutput = Awaited<ReturnType<typeof posthog.sandboxDestroy>>;
+
+const result: SandboxDestroyOutput = await posthog.sandboxDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.sandboxRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/sandbox_environments/{id}/`
+- **What it does**: API for managing sandbox environments that control network access for task runs.
+- **OpenAPI operationId**: `sandbox_retrieve`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: boolean; created_by?: { id: number; uuid: string; distinct_id: string; first...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxRetrieveInput = Parameters<typeof posthog.sandboxRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxRetrieveOutput = Awaited<ReturnType<typeof posthog.sandboxRetrieve>>;
+
+const result: SandboxRetrieveOutput = await posthog.sandboxRetrieve();
+
+// Result shape (from schema): { id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: boolean; created_by?: { id: number; uuid: string; distinct_id: string; first...
+```
+
+### `posthog.sandboxPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/sandbox_environments/{id}/`
+- **What it does**: API for managing sandbox environments that control network access for task runs.
+- **OpenAPI operationId**: `sandbox_partial_update`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: boolean; created_by?: { id: number; uuid: string; distinct_id: string; first...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SandboxPartialUpdateInput = Parameters<typeof posthog.sandboxPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type SandboxPartialUpdateOutput = Awaited<ReturnType<typeof posthog.sandboxPartialUpdate>>;
+
+const result: SandboxPartialUpdateOutput = await posthog.sandboxPartialUpdate();
+
+// Result shape (from schema): { id: string; name: string; network_access_level: string; allowed_domains?: (string)[]; repositories?: (string)[]; private: boolean; internal: boolean; created_by?: { id: number; uuid: string; distinct_id: string; first...
+```
+
+
+<!-- prompt-hash:
+8c3694991a4c289225f05a4e8f1e098cc74d085a088d7dffd82f00d93797b7f8
+-->