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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { hog_function_ids: (string)[] }
• OpenAPI response codes: 201

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { count: number }
• OpenAPI response codes: 200

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { [key: string]: unknown }
• OpenAPI response codes: 201

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { results: ({ value: string; count: number })[] }
• OpenAPI response codes: 200

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { [key: string]: unknown }
• OpenAPI response codes: 200

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

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

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

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

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { hog_function_ids: (string)[] }
• OpenAPI response codes: 201

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { count: number }
• OpenAPI response codes: 200

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { [key: string]: unknown }
• OpenAPI response codes: 201

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { results: ({ value: string; count: number })[] }
• OpenAPI response codes: 200

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: { [key: string]: unknown }
• OpenAPI response codes: 200

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

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

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

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

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Inputs

• Client input type: { [key: string]: unknown }
• Client transport options: None

Outputs

• Client return type: unknown
• OpenAPI response codes: 204

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

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

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

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

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

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

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...