@utdk/posthog 1.0.0-20260712.5-dev.e2949a6

package/docs/logs.md

@@ -0,0 +1,2446 @@
+# Logs
+
+## Operations
+
+### `posthog.environmentsLogsAlertsList`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/alerts/`
+- **OpenAPI operationId**: `environments_logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsListInput = Parameters<typeof posthog.environmentsLogsAlertsList> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsListOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsList>>;
+
+const result: EnvironmentsLogsAlertsListOutput = await posthog.environmentsLogsAlertsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: ...
+```
+
+### `posthog.environmentsLogsAlertsCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/alerts/`
+- **OpenAPI operationId**: `environments_logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsCreateInput = Parameters<typeof posthog.environmentsLogsAlertsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsCreate>>;
+
+const result: EnvironmentsLogsAlertsCreateOutput = await posthog.environmentsLogsAlertsCreate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.environmentsLogsAlertsDestroy`
+
+- **HTTP**: `DELETE /api/environments/{environment_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `environments_logs_alerts_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 EnvironmentsLogsAlertsDestroyInput = Parameters<typeof posthog.environmentsLogsAlertsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsDestroyOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsDestroy>>;
+
+const result: EnvironmentsLogsAlertsDestroyOutput = await posthog.environmentsLogsAlertsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.environmentsLogsAlertsRetrieve`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `environments_logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsRetrieveInput = Parameters<typeof posthog.environmentsLogsAlertsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsRetrieve>>;
+
+const result: EnvironmentsLogsAlertsRetrieveOutput = await posthog.environmentsLogsAlertsRetrieve();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.environmentsLogsAlertsPartialUpdate`
+
+- **HTTP**: `PATCH /api/environments/{environment_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `environments_logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsPartialUpdateInput = Parameters<typeof posthog.environmentsLogsAlertsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsPartialUpdate>>;
+
+const result: EnvironmentsLogsAlertsPartialUpdateOutput = await posthog.environmentsLogsAlertsPartialUpdate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.environmentsLogsAlertsUpdate`
+
+- **HTTP**: `PUT /api/environments/{environment_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `environments_logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsUpdateInput = Parameters<typeof posthog.environmentsLogsAlertsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsUpdate>>;
+
+const result: EnvironmentsLogsAlertsUpdateOutput = await posthog.environmentsLogsAlertsUpdate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.environmentsLogsAlertsDestinationsCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/alerts/{id}/destinations/`
+- **What it does**: Create a notification destination for this alert. One HogFunction is created per alert event kind (firing, resolved, ...) atomically.
+- **OpenAPI operationId**: `environments_logs_alerts_destinations_create`
+- **Path params**: `id`
+- **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: `{ hog_function_ids: (string)[] }`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsDestinationsCreateInput = Parameters<typeof posthog.environmentsLogsAlertsDestinationsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsDestinationsCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsDestinationsCreate>>;
+
+const result: EnvironmentsLogsAlertsDestinationsCreateOutput = await posthog.environmentsLogsAlertsDestinationsCreate();
+
+// Result shape (from schema): { hog_function_ids: (string)[] }
+```
+
+### `posthog.environmentsLogsAlertsDestinationsDeleteCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/alerts/{id}/destinations/delete/`
+- **What it does**: Delete a notification destination by deleting its HogFunction group atomically.
+- **OpenAPI operationId**: `environments_logs_alerts_destinations_delete_create`
+- **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 EnvironmentsLogsAlertsDestinationsDeleteCreateInput = Parameters<typeof posthog.environmentsLogsAlertsDestinationsDeleteCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsDestinationsDeleteCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsDestinationsDeleteCreate>>;
+
+const result: EnvironmentsLogsAlertsDestinationsDeleteCreateOutput = await posthog.environmentsLogsAlertsDestinationsDeleteCreate();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.environmentsLogsAlertsEventsList`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/alerts/{id}/events/`
+- **What it does**: Paginated event history for this alert, newest first. Returns state transitions, errored checks, and user-initiated control-plane rows (reset, enable/disable, snooze/unsnooze, threshold change) — quiet no-op check rows (where state didn't change and there was no error) are filtered out since only the last 10 are kept and they carry no forensic value. Optional `?kind=...` narrows to a single kind.
+- **OpenAPI operationId**: `environments_logs_alerts_events_list`
+- **Path params**: `id`
+- **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; created_at: string; kind: "check" | "reset" | "enable" | "disable" | "snooze" | "unsnooze" | "threshold_change" | "broken_config";...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsEventsListInput = Parameters<typeof posthog.environmentsLogsAlertsEventsList> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsEventsListOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsEventsList>>;
+
+const result: EnvironmentsLogsAlertsEventsListOutput = await posthog.environmentsLogsAlertsEventsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; created_at: string; kind: "check" | "reset" | "enable" | "disable" | "snooze" | "unsnooze" | "threshold_change" | "broken_config";...
+```
+
+### `posthog.environmentsLogsAlertsResetCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/alerts/{id}/reset/`
+- **What it does**: Reset a broken alert. Clears the consecutive-failure counter and schedules an immediate recheck.
+- **OpenAPI operationId**: `environments_logs_alerts_reset_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsResetCreateInput = Parameters<typeof posthog.environmentsLogsAlertsResetCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsResetCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsResetCreate>>;
+
+const result: EnvironmentsLogsAlertsResetCreateOutput = await posthog.environmentsLogsAlertsResetCreate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.environmentsLogsAlertsSimulateCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/alerts/simulate/`
+- **What it does**: Simulate a logs alert on historical data using the full state machine. Read-only — no alert check records are created.
+- **OpenAPI operationId**: `environments_logs_alerts_simulate_create`
+- **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: `{ buckets: ({ timestamp: string; count: number; threshold_breached: boolean; state: string; notification: string; reason: string })[]; fire_count: number; resolve_count: number; total_buckets: number; threshold_count: n...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAlertsSimulateCreateInput = Parameters<typeof posthog.environmentsLogsAlertsSimulateCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAlertsSimulateCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAlertsSimulateCreate>>;
+
+const result: EnvironmentsLogsAlertsSimulateCreateOutput = await posthog.environmentsLogsAlertsSimulateCreate();
+
+// Result shape (from schema): { buckets: ({ timestamp: string; count: number; threshold_breached: boolean; state: string; notification: string; reason: string })[]; fire_count: number; resolve_count: number; total_buckets: number; threshold_count: n...
+```
+
+### `posthog.environmentsLogsAttributesRetrieve`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/attributes/`
+- **OpenAPI operationId**: `environments_logs_attributes_retrieve`
+- **Path params**: None
+- **Query params**: `attribute_type`, `dateRange`, `filterGroup`, `limit`, `offset`, `search`, `search_values`, `serviceNames`
+- **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: ({ name: string; propertyFilterType: string; matchedOn: "key" | "value"; matchedValue?: string | null })[]; count: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsAttributesRetrieveInput = Parameters<typeof posthog.environmentsLogsAttributesRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsAttributesRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsLogsAttributesRetrieve>>;
+
+const result: EnvironmentsLogsAttributesRetrieveOutput = await posthog.environmentsLogsAttributesRetrieve();
+
+// Result shape (from schema): { results: ({ name: string; propertyFilterType: string; matchedOn: "key" | "value"; matchedValue?: string | null })[]; count: number }
+```
+
+### `posthog.environmentsLogsCountRangesCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/count-ranges/`
+- **OpenAPI operationId**: `environments_logs_count_ranges_create`
+- **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: `{ ranges: ({ date_from: string; date_to: string; count: number })[]; interval: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsCountRangesCreateInput = Parameters<typeof posthog.environmentsLogsCountRangesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsCountRangesCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsCountRangesCreate>>;
+
+const result: EnvironmentsLogsCountRangesCreateOutput = await posthog.environmentsLogsCountRangesCreate();
+
+// Result shape (from schema): { ranges: ({ date_from: string; date_to: string; count: number })[]; interval: string }
+```
+
+### `posthog.environmentsLogsCountCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/count/`
+- **OpenAPI operationId**: `environments_logs_count_create`
+- **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: `{ count: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsCountCreateInput = Parameters<typeof posthog.environmentsLogsCountCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsCountCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsCountCreate>>;
+
+const result: EnvironmentsLogsCountCreateOutput = await posthog.environmentsLogsCountCreate();
+
+// Result shape (from schema): { count: number }
+```
+
+### `posthog.environmentsLogsExplainLogWithAiCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/explainLogWithAI/`
+- **What it does**: Explain a log entry using AI.
+
+POST /api/environments/:id/logs/explainLogWithAI/
+- **OpenAPI operationId**: `environments_logs_explainLogWithAI_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: `{ uuid: string; timestamp: string; force_refresh?: boolean }`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsExplainLogWithAiCreateInput = Parameters<typeof posthog.environmentsLogsExplainLogWithAiCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsExplainLogWithAiCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsExplainLogWithAiCreate>>;
+
+const result: EnvironmentsLogsExplainLogWithAiCreateOutput = await posthog.environmentsLogsExplainLogWithAiCreate();
+
+// Result shape (from schema): { uuid: string; timestamp: string; force_refresh?: boolean }
+```
+
+### `posthog.environmentsLogsExportCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/export/`
+- **OpenAPI operationId**: `environments_logs_export_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: `{ [key: string]: unknown }`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsExportCreateInput = Parameters<typeof posthog.environmentsLogsExportCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsExportCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsExportCreate>>;
+
+const result: EnvironmentsLogsExportCreateOutput = await posthog.environmentsLogsExportCreate();
+
+// Result shape (from schema): { [key: string]: unknown }
+```
+
+### `posthog.environmentsLogsFacetValuesCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/facet_values/`
+- **OpenAPI operationId**: `environments_logs_facet_values_create`
+- **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: ({ value: string; count: number })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsFacetValuesCreateInput = Parameters<typeof posthog.environmentsLogsFacetValuesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsFacetValuesCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsFacetValuesCreate>>;
+
+const result: EnvironmentsLogsFacetValuesCreateOutput = await posthog.environmentsLogsFacetValuesCreate();
+
+// Result shape (from schema): { results: ({ value: string; count: number })[] }
+```
+
+### `posthog.environmentsLogsGroupByCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/group-by/`
+- **OpenAPI operationId**: `environments_logs_group_by_create`
+- **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: `{ groups: ({ value: string; log_count: number; error_count: number; last_seen: string })[]; total_groups: number; total_logs: number; truncated: boolean }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsGroupByCreateInput = Parameters<typeof posthog.environmentsLogsGroupByCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsGroupByCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsGroupByCreate>>;
+
+const result: EnvironmentsLogsGroupByCreateOutput = await posthog.environmentsLogsGroupByCreate();
+
+// Result shape (from schema): { groups: ({ value: string; log_count: number; error_count: number; last_seen: string })[]; total_groups: number; total_logs: number; truncated: boolean }
+```
+
+### `posthog.environmentsLogsHasLogsRetrieve`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/has_logs/`
+- **OpenAPI operationId**: `environments_logs_has_logs_retrieve`
+- **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: `{ [key: string]: unknown }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsHasLogsRetrieveInput = Parameters<typeof posthog.environmentsLogsHasLogsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsHasLogsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsLogsHasLogsRetrieve>>;
+
+const result: EnvironmentsLogsHasLogsRetrieveOutput = await posthog.environmentsLogsHasLogsRetrieve();
+
+// Result shape (from schema): { [key: string]: unknown }
+```
+
+### `posthog.environmentsLogsPatternsDiffCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/patterns_diff/`
+- **OpenAPI operationId**: `environments_logs_patterns_diff_create`
+- **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: `{ entries: ({ classification: "new" | "rate_shift" | "gone" | "unchanged"; rate_ratio: number | null; pattern: { pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; es...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsPatternsDiffCreateInput = Parameters<typeof posthog.environmentsLogsPatternsDiffCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsPatternsDiffCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsPatternsDiffCreate>>;
+
+const result: EnvironmentsLogsPatternsDiffCreateOutput = await posthog.environmentsLogsPatternsDiffCreate();
+
+// Result shape (from schema): { entries: ({ classification: "new" | "rate_shift" | "gone" | "unchanged"; rate_ratio: number | null; pattern: { pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; es...
+```
+
+### `posthog.environmentsLogsPatternsCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/patterns/`
+- **OpenAPI operationId**: `environments_logs_patterns_create`
+- **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: `{ patterns: ({ pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; estimated_error_count: number; first_seen: string; last_seen: string; examples: ({ body: string; sev...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsPatternsCreateInput = Parameters<typeof posthog.environmentsLogsPatternsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsPatternsCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsPatternsCreate>>;
+
+const result: EnvironmentsLogsPatternsCreateOutput = await posthog.environmentsLogsPatternsCreate();
+
+// Result shape (from schema): { patterns: ({ pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; estimated_error_count: number; first_seen: string; last_seen: string; examples: ({ body: string; sev...
+```
+
+### `posthog.environmentsLogsQueryCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/query/`
+- **OpenAPI operationId**: `environments_logs_query_create`
+- **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: `{ query: { [key: string]: unknown }; results: ({ uuid: string; timestamp: string; observed_timestamp: string; body: string; severity_text: string; severity_number: number; level: string; trace_id: string; span_id: strin...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsQueryCreateInput = Parameters<typeof posthog.environmentsLogsQueryCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsQueryCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsQueryCreate>>;
+
+const result: EnvironmentsLogsQueryCreateOutput = await posthog.environmentsLogsQueryCreate();
+
+// Result shape (from schema): { query: { [key: string]: unknown }; results: ({ uuid: string; timestamp: string; observed_timestamp: string; body: string; severity_text: string; severity_number: number; level: string; trace_id: string; span_id: strin...
+```
+
+### `posthog.environmentsLogsSamplingRulesList`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/sampling_rules/`
+- **OpenAPI operationId**: `environments_logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSamplingRulesListInput = Parameters<typeof posthog.environmentsLogsSamplingRulesList> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesListOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesList>>;
+
+const result: EnvironmentsLogsSamplingRulesListOutput = await posthog.environmentsLogsSamplingRulesList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...
+```
+
+### `posthog.environmentsLogsSamplingRulesCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/sampling_rules/`
+- **OpenAPI operationId**: `environments_logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSamplingRulesCreateInput = Parameters<typeof posthog.environmentsLogsSamplingRulesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesCreate>>;
+
+const result: EnvironmentsLogsSamplingRulesCreateOutput = await posthog.environmentsLogsSamplingRulesCreate();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.environmentsLogsSamplingRulesDestroy`
+
+- **HTTP**: `DELETE /api/environments/{environment_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `environments_logs_sampling_rules_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 EnvironmentsLogsSamplingRulesDestroyInput = Parameters<typeof posthog.environmentsLogsSamplingRulesDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesDestroyOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesDestroy>>;
+
+const result: EnvironmentsLogsSamplingRulesDestroyOutput = await posthog.environmentsLogsSamplingRulesDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.environmentsLogsSamplingRulesRetrieve`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `environments_logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSamplingRulesRetrieveInput = Parameters<typeof posthog.environmentsLogsSamplingRulesRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesRetrieve>>;
+
+const result: EnvironmentsLogsSamplingRulesRetrieveOutput = await posthog.environmentsLogsSamplingRulesRetrieve();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.environmentsLogsSamplingRulesPartialUpdate`
+
+- **HTTP**: `PATCH /api/environments/{environment_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `environments_logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSamplingRulesPartialUpdateInput = Parameters<typeof posthog.environmentsLogsSamplingRulesPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesPartialUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesPartialUpdate>>;
+
+const result: EnvironmentsLogsSamplingRulesPartialUpdateOutput = await posthog.environmentsLogsSamplingRulesPartialUpdate();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.environmentsLogsSamplingRulesUpdate`
+
+- **HTTP**: `PUT /api/environments/{environment_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `environments_logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSamplingRulesUpdateInput = Parameters<typeof posthog.environmentsLogsSamplingRulesUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesUpdate>>;
+
+const result: EnvironmentsLogsSamplingRulesUpdateOutput = await posthog.environmentsLogsSamplingRulesUpdate();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.environmentsLogsSamplingRulesSimulateCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/sampling_rules/{id}/simulate/`
+- **What it does**: Dry-run estimate for how much volume this rule would remove (placeholder response until CH-backed simulation is wired).
+- **OpenAPI operationId**: `environments_logs_sampling_rules_simulate_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: `{ estimated_reduction_pct: number; notes: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSamplingRulesSimulateCreateInput = Parameters<typeof posthog.environmentsLogsSamplingRulesSimulateCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesSimulateCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesSimulateCreate>>;
+
+const result: EnvironmentsLogsSamplingRulesSimulateCreateOutput = await posthog.environmentsLogsSamplingRulesSimulateCreate();
+
+// Result shape (from schema): { estimated_reduction_pct: number; notes: string }
+```
+
+### `posthog.environmentsLogsSamplingRulesReorderCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/sampling_rules/reorder/`
+- **What it does**: Atomically reassign priorities so the given ID order maps to ascending priorities (0..n-1).
+- **OpenAPI operationId**: `environments_logs_sampling_rules_reorder_create`
+- **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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSamplingRulesReorderCreateInput = Parameters<typeof posthog.environmentsLogsSamplingRulesReorderCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSamplingRulesReorderCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSamplingRulesReorderCreate>>;
+
+const result: EnvironmentsLogsSamplingRulesReorderCreateOutput = await posthog.environmentsLogsSamplingRulesReorderCreate();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...
+```
+
+### `posthog.environmentsLogsServicesCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/services/`
+- **OpenAPI operationId**: `environments_logs_services_create`
+- **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: `{ services: ({ service_name: string; log_count: number; error_count: number; error_rate: number; volume_share_pct?: number; severity_breakdown?: { debug: number; info: number; warn: number; error: number }; active_rules...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsServicesCreateInput = Parameters<typeof posthog.environmentsLogsServicesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsServicesCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsServicesCreate>>;
+
+const result: EnvironmentsLogsServicesCreateOutput = await posthog.environmentsLogsServicesCreate();
+
+// Result shape (from schema): { services: ({ service_name: string; log_count: number; error_count: number; error_rate: number; volume_share_pct?: number; severity_breakdown?: { debug: number; info: number; warn: number; error: number }; active_rules...
+```
+
+### `posthog.environmentsLogsSparklineCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/sparkline/`
+- **OpenAPI operationId**: `environments_logs_sparkline_create`
+- **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: ({ time: string; severity?: string; service?: string; count: number; bytes_uncompressed?: number })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsSparklineCreateInput = Parameters<typeof posthog.environmentsLogsSparklineCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsSparklineCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsSparklineCreate>>;
+
+const result: EnvironmentsLogsSparklineCreateOutput = await posthog.environmentsLogsSparklineCreate();
+
+// Result shape (from schema): { results: ({ time: string; severity?: string; service?: string; count: number; bytes_uncompressed?: number })[] }
+```
+
+### `posthog.environmentsLogsValuesRetrieve`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/values/`
+- **OpenAPI operationId**: `environments_logs_values_retrieve`
+- **Path params**: None
+- **Query params**: `attribute_type`, `dateRange`, `filterGroup`, `key`, `serviceNames`, `value`
+- **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; name: string; count?: number })[]; refreshing: boolean }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsValuesRetrieveInput = Parameters<typeof posthog.environmentsLogsValuesRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsValuesRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsLogsValuesRetrieve>>;
+
+const result: EnvironmentsLogsValuesRetrieveOutput = await posthog.environmentsLogsValuesRetrieve();
+
+// Result shape (from schema): { results: ({ id: string; name: string; count?: number })[]; refreshing: boolean }
+```
+
+### `posthog.environmentsLogsViewsList`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/views/`
+- **OpenAPI operationId**: `environments_logs_views_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: numb...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsViewsListInput = Parameters<typeof posthog.environmentsLogsViewsList> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsViewsListOutput = Awaited<ReturnType<typeof posthog.environmentsLogsViewsList>>;
+
+const result: EnvironmentsLogsViewsListOutput = await posthog.environmentsLogsViewsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: numb...
+```
+
+### `posthog.environmentsLogsViewsCreate`
+
+- **HTTP**: `POST /api/environments/{environment_id}/logs/views/`
+- **OpenAPI operationId**: `environments_logs_views_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsViewsCreateInput = Parameters<typeof posthog.environmentsLogsViewsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsViewsCreateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsViewsCreate>>;
+
+const result: EnvironmentsLogsViewsCreateOutput = await posthog.environmentsLogsViewsCreate();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+### `posthog.environmentsLogsViewsDestroy`
+
+- **HTTP**: `DELETE /api/environments/{environment_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `environments_logs_views_destroy`
+- **Path params**: `short_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 EnvironmentsLogsViewsDestroyInput = Parameters<typeof posthog.environmentsLogsViewsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsViewsDestroyOutput = Awaited<ReturnType<typeof posthog.environmentsLogsViewsDestroy>>;
+
+const result: EnvironmentsLogsViewsDestroyOutput = await posthog.environmentsLogsViewsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.environmentsLogsViewsRetrieve`
+
+- **HTTP**: `GET /api/environments/{environment_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `environments_logs_views_retrieve`
+- **Path params**: `short_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsViewsRetrieveInput = Parameters<typeof posthog.environmentsLogsViewsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsViewsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsLogsViewsRetrieve>>;
+
+const result: EnvironmentsLogsViewsRetrieveOutput = await posthog.environmentsLogsViewsRetrieve();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+### `posthog.environmentsLogsViewsPartialUpdate`
+
+- **HTTP**: `PATCH /api/environments/{environment_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `environments_logs_views_partial_update`
+- **Path params**: `short_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsViewsPartialUpdateInput = Parameters<typeof posthog.environmentsLogsViewsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsViewsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsViewsPartialUpdate>>;
+
+const result: EnvironmentsLogsViewsPartialUpdateOutput = await posthog.environmentsLogsViewsPartialUpdate();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+### `posthog.environmentsLogsViewsUpdate`
+
+- **HTTP**: `PUT /api/environments/{environment_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `environments_logs_views_update`
+- **Path params**: `short_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type EnvironmentsLogsViewsUpdateInput = Parameters<typeof posthog.environmentsLogsViewsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type EnvironmentsLogsViewsUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsLogsViewsUpdate>>;
+
+const result: EnvironmentsLogsViewsUpdateOutput = await posthog.environmentsLogsViewsUpdate();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+### `posthog.logsAlertsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/alerts/`
+- **OpenAPI operationId**: `logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsListInput = Parameters<typeof posthog.logsAlertsList> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsListOutput = Awaited<ReturnType<typeof posthog.logsAlertsList>>;
+
+const result: LogsAlertsListOutput = await posthog.logsAlertsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: ...
+```
+
+### `posthog.logsAlertsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/alerts/`
+- **OpenAPI operationId**: `logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsCreateInput = Parameters<typeof posthog.logsAlertsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsCreateOutput = Awaited<ReturnType<typeof posthog.logsAlertsCreate>>;
+
+const result: LogsAlertsCreateOutput = await posthog.logsAlertsCreate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.logsAlertsDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `logs_alerts_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 LogsAlertsDestroyInput = Parameters<typeof posthog.logsAlertsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsDestroyOutput = Awaited<ReturnType<typeof posthog.logsAlertsDestroy>>;
+
+const result: LogsAlertsDestroyOutput = await posthog.logsAlertsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.logsAlertsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsRetrieveInput = Parameters<typeof posthog.logsAlertsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsRetrieveOutput = Awaited<ReturnType<typeof posthog.logsAlertsRetrieve>>;
+
+const result: LogsAlertsRetrieveOutput = await posthog.logsAlertsRetrieve();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.logsAlertsPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsPartialUpdateInput = Parameters<typeof posthog.logsAlertsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.logsAlertsPartialUpdate>>;
+
+const result: LogsAlertsPartialUpdateOutput = await posthog.logsAlertsPartialUpdate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.logsAlertsUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/logs/alerts/{id}/`
+- **OpenAPI operationId**: `logs_alerts_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsUpdateInput = Parameters<typeof posthog.logsAlertsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsUpdateOutput = Awaited<ReturnType<typeof posthog.logsAlertsUpdate>>;
+
+const result: LogsAlertsUpdateOutput = await posthog.logsAlertsUpdate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.logsAlertsDestinationsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/alerts/{id}/destinations/`
+- **What it does**: Create a notification destination for this alert. One HogFunction is created per alert event kind (firing, resolved, ...) atomically.
+- **OpenAPI operationId**: `logs_alerts_destinations_create`
+- **Path params**: `id`
+- **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: `{ hog_function_ids: (string)[] }`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsDestinationsCreateInput = Parameters<typeof posthog.logsAlertsDestinationsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsDestinationsCreateOutput = Awaited<ReturnType<typeof posthog.logsAlertsDestinationsCreate>>;
+
+const result: LogsAlertsDestinationsCreateOutput = await posthog.logsAlertsDestinationsCreate();
+
+// Result shape (from schema): { hog_function_ids: (string)[] }
+```
+
+### `posthog.logsAlertsDestinationsDeleteCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/alerts/{id}/destinations/delete/`
+- **What it does**: Delete a notification destination by deleting its HogFunction group atomically.
+- **OpenAPI operationId**: `logs_alerts_destinations_delete_create`
+- **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 LogsAlertsDestinationsDeleteCreateInput = Parameters<typeof posthog.logsAlertsDestinationsDeleteCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsDestinationsDeleteCreateOutput = Awaited<ReturnType<typeof posthog.logsAlertsDestinationsDeleteCreate>>;
+
+const result: LogsAlertsDestinationsDeleteCreateOutput = await posthog.logsAlertsDestinationsDeleteCreate();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.logsAlertsEventsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/alerts/{id}/events/`
+- **What it does**: Paginated event history for this alert, newest first. Returns state transitions, errored checks, and user-initiated control-plane rows (reset, enable/disable, snooze/unsnooze, threshold change) — quiet no-op check rows (where state didn't change and there was no error) are filtered out since only the last 10 are kept and they carry no forensic value. Optional `?kind=...` narrows to a single kind.
+- **OpenAPI operationId**: `logs_alerts_events_list`
+- **Path params**: `id`
+- **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; created_at: string; kind: "check" | "reset" | "enable" | "disable" | "snooze" | "unsnooze" | "threshold_change" | "broken_config";...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsEventsListInput = Parameters<typeof posthog.logsAlertsEventsList> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsEventsListOutput = Awaited<ReturnType<typeof posthog.logsAlertsEventsList>>;
+
+const result: LogsAlertsEventsListOutput = await posthog.logsAlertsEventsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; created_at: string; kind: "check" | "reset" | "enable" | "disable" | "snooze" | "unsnooze" | "threshold_change" | "broken_config";...
+```
+
+### `posthog.logsAlertsResetCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/alerts/{id}/reset/`
+- **What it does**: Reset a broken alert. Clears the consecutive-failure counter and schedules an immediate recheck.
+- **OpenAPI operationId**: `logs_alerts_reset_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; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsResetCreateInput = Parameters<typeof posthog.logsAlertsResetCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsResetCreateOutput = Awaited<ReturnType<typeof posthog.logsAlertsResetCreate>>;
+
+const result: LogsAlertsResetCreateOutput = await posthog.logsAlertsResetCreate();
+
+// Result shape (from schema): { id: string; name?: string; enabled?: boolean; filters?: { filterGroup?: { type: "AND" | "OR"; values: ({ type: "AND" | "OR"; values: ({ type: unknown; values: (unknown | { key: string; label?: string | null; operator?...
+```
+
+### `posthog.logsAlertsSimulateCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/alerts/simulate/`
+- **What it does**: Simulate a logs alert on historical data using the full state machine. Read-only — no alert check records are created.
+- **OpenAPI operationId**: `logs_alerts_simulate_create`
+- **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: `{ buckets: ({ timestamp: string; count: number; threshold_breached: boolean; state: string; notification: string; reason: string })[]; fire_count: number; resolve_count: number; total_buckets: number; threshold_count: n...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAlertsSimulateCreateInput = Parameters<typeof posthog.logsAlertsSimulateCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAlertsSimulateCreateOutput = Awaited<ReturnType<typeof posthog.logsAlertsSimulateCreate>>;
+
+const result: LogsAlertsSimulateCreateOutput = await posthog.logsAlertsSimulateCreate();
+
+// Result shape (from schema): { buckets: ({ timestamp: string; count: number; threshold_breached: boolean; state: string; notification: string; reason: string })[]; fire_count: number; resolve_count: number; total_buckets: number; threshold_count: n...
+```
+
+### `posthog.logsAttributesRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/attributes/`
+- **OpenAPI operationId**: `logs_attributes_retrieve`
+- **Path params**: None
+- **Query params**: `attribute_type`, `dateRange`, `filterGroup`, `limit`, `offset`, `search`, `search_values`, `serviceNames`
+- **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: ({ name: string; propertyFilterType: string; matchedOn: "key" | "value"; matchedValue?: string | null })[]; count: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsAttributesRetrieveInput = Parameters<typeof posthog.logsAttributesRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsAttributesRetrieveOutput = Awaited<ReturnType<typeof posthog.logsAttributesRetrieve>>;
+
+const result: LogsAttributesRetrieveOutput = await posthog.logsAttributesRetrieve();
+
+// Result shape (from schema): { results: ({ name: string; propertyFilterType: string; matchedOn: "key" | "value"; matchedValue?: string | null })[]; count: number }
+```
+
+### `posthog.logsCountRangesCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/count-ranges/`
+- **OpenAPI operationId**: `logs_count_ranges_create`
+- **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: `{ ranges: ({ date_from: string; date_to: string; count: number })[]; interval: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsCountRangesCreateInput = Parameters<typeof posthog.logsCountRangesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsCountRangesCreateOutput = Awaited<ReturnType<typeof posthog.logsCountRangesCreate>>;
+
+const result: LogsCountRangesCreateOutput = await posthog.logsCountRangesCreate();
+
+// Result shape (from schema): { ranges: ({ date_from: string; date_to: string; count: number })[]; interval: string }
+```
+
+### `posthog.logsCountCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/count/`
+- **OpenAPI operationId**: `logs_count_create`
+- **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: `{ count: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsCountCreateInput = Parameters<typeof posthog.logsCountCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsCountCreateOutput = Awaited<ReturnType<typeof posthog.logsCountCreate>>;
+
+const result: LogsCountCreateOutput = await posthog.logsCountCreate();
+
+// Result shape (from schema): { count: number }
+```
+
+### `posthog.logsExplainLogWithAiCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/explainLogWithAI/`
+- **What it does**: Explain a log entry using AI.
+
+POST /api/environments/:id/logs/explainLogWithAI/
+- **OpenAPI operationId**: `logs_explainLogWithAI_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: `{ uuid: string; timestamp: string; force_refresh?: boolean }`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsExplainLogWithAiCreateInput = Parameters<typeof posthog.logsExplainLogWithAiCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsExplainLogWithAiCreateOutput = Awaited<ReturnType<typeof posthog.logsExplainLogWithAiCreate>>;
+
+const result: LogsExplainLogWithAiCreateOutput = await posthog.logsExplainLogWithAiCreate();
+
+// Result shape (from schema): { uuid: string; timestamp: string; force_refresh?: boolean }
+```
+
+### `posthog.logsExportCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/export/`
+- **OpenAPI operationId**: `logs_export_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: `{ [key: string]: unknown }`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsExportCreateInput = Parameters<typeof posthog.logsExportCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsExportCreateOutput = Awaited<ReturnType<typeof posthog.logsExportCreate>>;
+
+const result: LogsExportCreateOutput = await posthog.logsExportCreate();
+
+// Result shape (from schema): { [key: string]: unknown }
+```
+
+### `posthog.logsFacetValuesCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/facet_values/`
+- **OpenAPI operationId**: `logs_facet_values_create`
+- **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: ({ value: string; count: number })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsFacetValuesCreateInput = Parameters<typeof posthog.logsFacetValuesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsFacetValuesCreateOutput = Awaited<ReturnType<typeof posthog.logsFacetValuesCreate>>;
+
+const result: LogsFacetValuesCreateOutput = await posthog.logsFacetValuesCreate();
+
+// Result shape (from schema): { results: ({ value: string; count: number })[] }
+```
+
+### `posthog.logsGroupByCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/group-by/`
+- **OpenAPI operationId**: `logs_group_by_create`
+- **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: `{ groups: ({ value: string; log_count: number; error_count: number; last_seen: string })[]; total_groups: number; total_logs: number; truncated: boolean }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsGroupByCreateInput = Parameters<typeof posthog.logsGroupByCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsGroupByCreateOutput = Awaited<ReturnType<typeof posthog.logsGroupByCreate>>;
+
+const result: LogsGroupByCreateOutput = await posthog.logsGroupByCreate();
+
+// Result shape (from schema): { groups: ({ value: string; log_count: number; error_count: number; last_seen: string })[]; total_groups: number; total_logs: number; truncated: boolean }
+```
+
+### `posthog.logsHasLogsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/has_logs/`
+- **OpenAPI operationId**: `logs_has_logs_retrieve`
+- **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: `{ [key: string]: unknown }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsHasLogsRetrieveInput = Parameters<typeof posthog.logsHasLogsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsHasLogsRetrieveOutput = Awaited<ReturnType<typeof posthog.logsHasLogsRetrieve>>;
+
+const result: LogsHasLogsRetrieveOutput = await posthog.logsHasLogsRetrieve();
+
+// Result shape (from schema): { [key: string]: unknown }
+```
+
+### `posthog.logsPatternsDiffCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/patterns_diff/`
+- **OpenAPI operationId**: `logs_patterns_diff_create`
+- **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: `{ entries: ({ classification: "new" | "rate_shift" | "gone" | "unchanged"; rate_ratio: number | null; pattern: { pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; es...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsPatternsDiffCreateInput = Parameters<typeof posthog.logsPatternsDiffCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsPatternsDiffCreateOutput = Awaited<ReturnType<typeof posthog.logsPatternsDiffCreate>>;
+
+const result: LogsPatternsDiffCreateOutput = await posthog.logsPatternsDiffCreate();
+
+// Result shape (from schema): { entries: ({ classification: "new" | "rate_shift" | "gone" | "unchanged"; rate_ratio: number | null; pattern: { pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; es...
+```
+
+### `posthog.logsPatternsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/patterns/`
+- **OpenAPI operationId**: `logs_patterns_create`
+- **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: `{ patterns: ({ pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; estimated_error_count: number; first_seen: string; last_seen: string; examples: ({ body: string; sev...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsPatternsCreateInput = Parameters<typeof posthog.logsPatternsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsPatternsCreateOutput = Awaited<ReturnType<typeof posthog.logsPatternsCreate>>;
+
+const result: LogsPatternsCreateOutput = await posthog.logsPatternsCreate();
+
+// Result shape (from schema): { patterns: ({ pattern: string; count: number; estimated_count: number; volume_share_pct: number; error_count: number; estimated_error_count: number; first_seen: string; last_seen: string; examples: ({ body: string; sev...
+```
+
+### `posthog.logsQueryCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/query/`
+- **OpenAPI operationId**: `logs_query_create`
+- **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: `{ query: { [key: string]: unknown }; results: ({ uuid: string; timestamp: string; observed_timestamp: string; body: string; severity_text: string; severity_number: number; level: string; trace_id: string; span_id: strin...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsQueryCreateInput = Parameters<typeof posthog.logsQueryCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsQueryCreateOutput = Awaited<ReturnType<typeof posthog.logsQueryCreate>>;
+
+const result: LogsQueryCreateOutput = await posthog.logsQueryCreate();
+
+// Result shape (from schema): { query: { [key: string]: unknown }; results: ({ uuid: string; timestamp: string; observed_timestamp: string; body: string; severity_text: string; severity_number: number; level: string; trace_id: string; span_id: strin...
+```
+
+### `posthog.logsSamplingRulesList`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/sampling_rules/`
+- **OpenAPI operationId**: `logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSamplingRulesListInput = Parameters<typeof posthog.logsSamplingRulesList> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesListOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesList>>;
+
+const result: LogsSamplingRulesListOutput = await posthog.logsSamplingRulesList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...
+```
+
+### `posthog.logsSamplingRulesCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/sampling_rules/`
+- **OpenAPI operationId**: `logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSamplingRulesCreateInput = Parameters<typeof posthog.logsSamplingRulesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesCreateOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesCreate>>;
+
+const result: LogsSamplingRulesCreateOutput = await posthog.logsSamplingRulesCreate();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.logsSamplingRulesDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `logs_sampling_rules_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 LogsSamplingRulesDestroyInput = Parameters<typeof posthog.logsSamplingRulesDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesDestroyOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesDestroy>>;
+
+const result: LogsSamplingRulesDestroyOutput = await posthog.logsSamplingRulesDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.logsSamplingRulesRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSamplingRulesRetrieveInput = Parameters<typeof posthog.logsSamplingRulesRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesRetrieveOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesRetrieve>>;
+
+const result: LogsSamplingRulesRetrieveOutput = await posthog.logsSamplingRulesRetrieve();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.logsSamplingRulesPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSamplingRulesPartialUpdateInput = Parameters<typeof posthog.logsSamplingRulesPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesPartialUpdateOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesPartialUpdate>>;
+
+const result: LogsSamplingRulesPartialUpdateOutput = await posthog.logsSamplingRulesPartialUpdate();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.logsSamplingRulesUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/logs/sampling_rules/{id}/`
+- **OpenAPI operationId**: `logs_sampling_rules_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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSamplingRulesUpdateInput = Parameters<typeof posthog.logsSamplingRulesUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesUpdateOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesUpdate>>;
+
+const result: LogsSamplingRulesUpdateOutput = await posthog.logsSamplingRulesUpdate();
+
+// Result shape (from schema): { id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_service?: string | null; scope_path_pattern?: string | null; scope_attribute_fi...
+```
+
+### `posthog.logsSamplingRulesSimulateCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/sampling_rules/{id}/simulate/`
+- **What it does**: Dry-run estimate for how much volume this rule would remove (placeholder response until CH-backed simulation is wired).
+- **OpenAPI operationId**: `logs_sampling_rules_simulate_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: `{ estimated_reduction_pct: number; notes: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSamplingRulesSimulateCreateInput = Parameters<typeof posthog.logsSamplingRulesSimulateCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesSimulateCreateOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesSimulateCreate>>;
+
+const result: LogsSamplingRulesSimulateCreateOutput = await posthog.logsSamplingRulesSimulateCreate();
+
+// Result shape (from schema): { estimated_reduction_pct: number; notes: string }
+```
+
+### `posthog.logsSamplingRulesReorderCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/sampling_rules/reorder/`
+- **What it does**: Atomically reassign priorities so the given ID order maps to ascending priorities (0..n-1).
+- **OpenAPI operationId**: `logs_sampling_rules_reorder_create`
+- **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; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSamplingRulesReorderCreateInput = Parameters<typeof posthog.logsSamplingRulesReorderCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSamplingRulesReorderCreateOutput = Awaited<ReturnType<typeof posthog.logsSamplingRulesReorderCreate>>;
+
+const result: LogsSamplingRulesReorderCreateOutput = await posthog.logsSamplingRulesReorderCreate();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string; enabled?: boolean; priority?: number | null; rule_type: "severity_sampling" | "path_drop" | "rate_limit"; scope_serv...
+```
+
+### `posthog.logsServicesCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/services/`
+- **OpenAPI operationId**: `logs_services_create`
+- **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: `{ services: ({ service_name: string; log_count: number; error_count: number; error_rate: number; volume_share_pct?: number; severity_breakdown?: { debug: number; info: number; warn: number; error: number }; active_rules...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsServicesCreateInput = Parameters<typeof posthog.logsServicesCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsServicesCreateOutput = Awaited<ReturnType<typeof posthog.logsServicesCreate>>;
+
+const result: LogsServicesCreateOutput = await posthog.logsServicesCreate();
+
+// Result shape (from schema): { services: ({ service_name: string; log_count: number; error_count: number; error_rate: number; volume_share_pct?: number; severity_breakdown?: { debug: number; info: number; warn: number; error: number }; active_rules...
+```
+
+### `posthog.logsSparklineCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/sparkline/`
+- **OpenAPI operationId**: `logs_sparkline_create`
+- **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: ({ time: string; severity?: string; service?: string; count: number; bytes_uncompressed?: number })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsSparklineCreateInput = Parameters<typeof posthog.logsSparklineCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsSparklineCreateOutput = Awaited<ReturnType<typeof posthog.logsSparklineCreate>>;
+
+const result: LogsSparklineCreateOutput = await posthog.logsSparklineCreate();
+
+// Result shape (from schema): { results: ({ time: string; severity?: string; service?: string; count: number; bytes_uncompressed?: number })[] }
+```
+
+### `posthog.logsValuesRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/values/`
+- **OpenAPI operationId**: `logs_values_retrieve`
+- **Path params**: None
+- **Query params**: `attribute_type`, `dateRange`, `filterGroup`, `key`, `serviceNames`, `value`
+- **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; name: string; count?: number })[]; refreshing: boolean }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsValuesRetrieveInput = Parameters<typeof posthog.logsValuesRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsValuesRetrieveOutput = Awaited<ReturnType<typeof posthog.logsValuesRetrieve>>;
+
+const result: LogsValuesRetrieveOutput = await posthog.logsValuesRetrieve();
+
+// Result shape (from schema): { results: ({ id: string; name: string; count?: number })[]; refreshing: boolean }
+```
+
+### `posthog.logsViewsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/views/`
+- **OpenAPI operationId**: `logs_views_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: numb...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsViewsListInput = Parameters<typeof posthog.logsViewsList> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsViewsListOutput = Awaited<ReturnType<typeof posthog.logsViewsList>>;
+
+const result: LogsViewsListOutput = await posthog.logsViewsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: numb...
+```
+
+### `posthog.logsViewsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/logs/views/`
+- **OpenAPI operationId**: `logs_views_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsViewsCreateInput = Parameters<typeof posthog.logsViewsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsViewsCreateOutput = Awaited<ReturnType<typeof posthog.logsViewsCreate>>;
+
+const result: LogsViewsCreateOutput = await posthog.logsViewsCreate();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+### `posthog.logsViewsDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `logs_views_destroy`
+- **Path params**: `short_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 LogsViewsDestroyInput = Parameters<typeof posthog.logsViewsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsViewsDestroyOutput = Awaited<ReturnType<typeof posthog.logsViewsDestroy>>;
+
+const result: LogsViewsDestroyOutput = await posthog.logsViewsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.logsViewsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `logs_views_retrieve`
+- **Path params**: `short_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsViewsRetrieveInput = Parameters<typeof posthog.logsViewsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsViewsRetrieveOutput = Awaited<ReturnType<typeof posthog.logsViewsRetrieve>>;
+
+const result: LogsViewsRetrieveOutput = await posthog.logsViewsRetrieve();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+### `posthog.logsViewsPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `logs_views_partial_update`
+- **Path params**: `short_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsViewsPartialUpdateInput = Parameters<typeof posthog.logsViewsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsViewsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.logsViewsPartialUpdate>>;
+
+const result: LogsViewsPartialUpdateOutput = await posthog.logsViewsPartialUpdate();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+### `posthog.logsViewsUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/logs/views/{short_id}/`
+- **OpenAPI operationId**: `logs_views_update`
+- **Path params**: `short_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; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type LogsViewsUpdateInput = Parameters<typeof posthog.logsViewsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type LogsViewsUpdateOutput = Awaited<ReturnType<typeof posthog.logsViewsUpdate>>;
+
+const result: LogsViewsUpdateOutput = await posthog.logsViewsUpdate();
+
+// Result shape (from schema): { id: string; short_id: string; name: string; filters?: { [key: string]: unknown }; pinned?: boolean; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: string; last_na...
+```
+
+
+<!-- prompt-hash:
+8c3694991a4c289225f05a4e8f1e098cc74d085a088d7dffd82f00d93797b7f8
+-->