@utdk/posthog 1.0.0-20260712.5-dev.e2949a6

package/docs/signals.md

@@ -0,0 +1,1428 @@
+# Signals
+
+## Operations
+
+### `posthog.signalsProcessingList`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/processing/`
+- **What it does**: Return current processing state including pause status.
+- **OpenAPI operationId**: `signals_processing_list`
+- **Path params**: None
+- **Query params**: `limit`, `offset`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ paused_until: string | null })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsProcessingListInput = Parameters<typeof posthog.signalsProcessingList> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsProcessingListOutput = Awaited<ReturnType<typeof posthog.signalsProcessingList>>;
+
+const result: SignalsProcessingListOutput = await posthog.signalsProcessingList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ paused_until: string | null })[] }
+```
+
+### `posthog.signalsProcessingPauseDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/signals/processing/pause/`
+- **What it does**: View and control signal processing pipeline state for a team.
+- **OpenAPI operationId**: `signals_processing_pause_destroy`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ status: string; paused_until: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsProcessingPauseDestroyInput = Parameters<typeof posthog.signalsProcessingPauseDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsProcessingPauseDestroyOutput = Awaited<ReturnType<typeof posthog.signalsProcessingPauseDestroy>>;
+
+const result: SignalsProcessingPauseDestroyOutput = await posthog.signalsProcessingPauseDestroy();
+
+// Result shape (from schema): { status: string; paused_until: string }
+```
+
+### `posthog.signalsProcessingPauseUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/signals/processing/pause/`
+- **What it does**: View and control signal processing pipeline state for a team.
+- **OpenAPI operationId**: `signals_processing_pause_update`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ status: string; paused_until: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsProcessingPauseUpdateInput = Parameters<typeof posthog.signalsProcessingPauseUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsProcessingPauseUpdateOutput = Awaited<ReturnType<typeof posthog.signalsProcessingPauseUpdate>>;
+
+const result: SignalsProcessingPauseUpdateOutput = await posthog.signalsProcessingPauseUpdate();
+
+// Result shape (from schema): { status: string; paused_until: string }
+```
+
+### `posthog.signalsReportsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/reports/`
+- **OpenAPI operationId**: `signals_reports_list`
+- **Path params**: None
+- **Query params**: `has_implementation_pr`, `limit`, `offset`, `ordering`, `priority`, `search`, `source_product`, `status`, `suggested_reviewers`, `task_id`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "res...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportsListInput = Parameters<typeof posthog.signalsReportsList> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportsListOutput = Awaited<ReturnType<typeof posthog.signalsReportsList>>;
+
+const result: SignalsReportsListOutput = await posthog.signalsReportsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "res...
+```
+
+### `posthog.signalsReportsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/reports/{id}/`
+- **OpenAPI operationId**: `signals_reports_retrieve`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: number; signal_...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportsRetrieveInput = Parameters<typeof posthog.signalsReportsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportsRetrieveOutput = Awaited<ReturnType<typeof posthog.signalsReportsRetrieve>>;
+
+const result: SignalsReportsRetrieveOutput = await posthog.signalsReportsRetrieve();
+
+// Result shape (from schema): { id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: number; signal_...
+```
+
+### `posthog.signalsReportsPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/signals/reports/{id}/`
+- **What it does**: Edit a report's title or summary
+- **OpenAPI operationId**: `signals_reports_partial_update`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`, `400`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: number; signal_...`
+- OpenAPI response codes: `200`, `400`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportsPartialUpdateInput = Parameters<typeof posthog.signalsReportsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.signalsReportsPartialUpdate>>;
+
+const result: SignalsReportsPartialUpdateOutput = await posthog.signalsReportsPartialUpdate();
+
+// Result shape (from schema): { id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: number; signal_...
+```
+
+### `posthog.signalsReportsSignalsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/reports/{id}/signals/`
+- **What it does**: List a report's signals
+- **OpenAPI operationId**: `signals_reports_signals_retrieve`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ report: { id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: numbe...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportsSignalsRetrieveInput = Parameters<typeof posthog.signalsReportsSignalsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportsSignalsRetrieveOutput = Awaited<ReturnType<typeof posthog.signalsReportsSignalsRetrieve>>;
+
+const result: SignalsReportsSignalsRetrieveOutput = await posthog.signalsReportsSignalsRetrieve();
+
+// Result shape (from schema): { report: { id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: numbe...
+```
+
+### `posthog.signalsReportsStateCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/reports/{id}/state/`
+- **What it does**: Transition a report to a new state. The model validates allowed transitions.
+
+The request body is validated by SignalReportStateRequestSerializer — only the
+fields it declares (state, dismissal_reason, dismissal_note, snooze_for) are read,
+and only snooze_for is ever forwarded to transition_to. Any other key is ignored,
+so internal transition_to kwargs (reset_weight, error, ...) can't be injected.
+
+Body: {
+    "state": "suppressed" | "potential",
+    # Optional dismissal feedback (honored when state == "suppressed" or "potential"):
+    "dismissal_reason": "<canonical reason code, see SIGNAL_REPORT_DISMISSAL_REASON_CHOICES>",
+    "dismissal_note": "free-form text",
+    # Optional, only honored for state == "potential":
+    "snooze_for": <number of additional signals before re-promotion>,
+}
+- **OpenAPI operationId**: `signals_reports_state_create`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: number; signal_...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportsStateCreateInput = Parameters<typeof posthog.signalsReportsStateCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportsStateCreateOutput = Awaited<ReturnType<typeof posthog.signalsReportsStateCreate>>;
+
+const result: SignalsReportsStateCreateOutput = await posthog.signalsReportsStateCreate();
+
+// Result shape (from schema): { id: string; title: string | null; summary: string | null; status: "potential" | "candidate" | "in_progress" | "pending_input" | "ready" | "resolved" | "failed" | "deleted" | "suppressed"; total_weight: number; signal_...
+```
+
+### `posthog.signalsReportArtefactsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/reports/{report_id}/artefacts/`
+- **What it does**: List a report's artefacts
+- **OpenAPI operationId**: `signals_report_artefacts_list`
+- **Path params**: `report_id`
+- **Query params**: `limit`, `offset`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: string; type: "video_segment" | "safety_judgment" | "actionability_judgment" | "priority_judgment" | "signal_finding" | "repo_selection" |...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportArtefactsListInput = Parameters<typeof posthog.signalsReportArtefactsList> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportArtefactsListOutput = Awaited<ReturnType<typeof posthog.signalsReportArtefactsList>>;
+
+const result: SignalsReportArtefactsListOutput = await posthog.signalsReportArtefactsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; type: "video_segment" | "safety_judgment" | "actionability_judgment" | "priority_judgment" | "signal_finding" | "repo_selection" |...
+```
+
+### `posthog.signalsReportArtefactsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/reports/{report_id}/artefacts/`
+- **What it does**: Append an artefact to a report
+- **OpenAPI operationId**: `signals_report_artefacts_create`
+- **Path params**: `report_id`
+- **Query params**: None
+- **Response codes**: `201`, `400`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; report_id: string; type: string; content: unknown; created_at: string; updated_at: string | null; task_id: string | null }`
+- OpenAPI response codes: `201`, `400`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportArtefactsCreateInput = Parameters<typeof posthog.signalsReportArtefactsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportArtefactsCreateOutput = Awaited<ReturnType<typeof posthog.signalsReportArtefactsCreate>>;
+
+const result: SignalsReportArtefactsCreateOutput = await posthog.signalsReportArtefactsCreate();
+
+// Result shape (from schema): { id: string; report_id: string; type: string; content: unknown; created_at: string; updated_at: string | null; task_id: string | null }
+```
+
+### `posthog.signalsReportArtefactsDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/signals/reports/{report_id}/artefacts/{id}/`
+- **What it does**: Delete an artefact
+- **OpenAPI operationId**: `signals_report_artefacts_destroy`
+- **Path params**: `id`, `report_id`
+- **Query params**: None
+- **Response codes**: `204`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportArtefactsDestroyInput = Parameters<typeof posthog.signalsReportArtefactsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportArtefactsDestroyOutput = Awaited<ReturnType<typeof posthog.signalsReportArtefactsDestroy>>;
+
+const result: SignalsReportArtefactsDestroyOutput = await posthog.signalsReportArtefactsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.signalsReportArtefactsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/reports/{report_id}/artefacts/{id}/`
+- **What it does**: Get a single artefact
+- **OpenAPI operationId**: `signals_report_artefacts_retrieve`
+- **Path params**: `id`, `report_id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; type: "video_segment" | "safety_judgment" | "actionability_judgment" | "priority_judgment" | "signal_finding" | "repo_selection" | "suggested_reviewers" | "dismissal" | "code_reference" | "commit" | "task_...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportArtefactsRetrieveInput = Parameters<typeof posthog.signalsReportArtefactsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportArtefactsRetrieveOutput = Awaited<ReturnType<typeof posthog.signalsReportArtefactsRetrieve>>;
+
+const result: SignalsReportArtefactsRetrieveOutput = await posthog.signalsReportArtefactsRetrieve();
+
+// Result shape (from schema): { id: string; type: "video_segment" | "safety_judgment" | "actionability_judgment" | "priority_judgment" | "signal_finding" | "repo_selection" | "suggested_reviewers" | "dismissal" | "code_reference" | "commit" | "task_...
+```
+
+### `posthog.signalsReportArtefactsPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/signals/reports/{report_id}/artefacts/{id}/`
+- **What it does**: Replace an artefact's content
+- **OpenAPI operationId**: `signals_report_artefacts_partial_update`
+- **Path params**: `id`, `report_id`
+- **Query params**: None
+- **Response codes**: `200`, `400`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; report_id: string; type: string; content: unknown; created_at: string; updated_at: string | null; task_id: string | null }`
+- OpenAPI response codes: `200`, `400`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportArtefactsPartialUpdateInput = Parameters<typeof posthog.signalsReportArtefactsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportArtefactsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.signalsReportArtefactsPartialUpdate>>;
+
+const result: SignalsReportArtefactsPartialUpdateOutput = await posthog.signalsReportArtefactsPartialUpdate();
+
+// Result shape (from schema): { id: string; report_id: string; type: string; content: unknown; created_at: string; updated_at: string | null; task_id: string | null }
+```
+
+### `posthog.signalsReportArtefactsDiff`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/reports/{report_id}/artefacts/{id}/diff/`
+- **What it does**: Fetch the diff for a commit artefact
+- **OpenAPI operationId**: `signals_report_artefacts_diff`
+- **Path params**: `id`, `report_id`
+- **Query params**: None
+- **Response codes**: `200`, `400`, `404`, `502`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ diff: string; truncated: boolean }`
+- OpenAPI response codes: `200`, `400`, `404`, `502`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportArtefactsDiffInput = Parameters<typeof posthog.signalsReportArtefactsDiff> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportArtefactsDiffOutput = Awaited<ReturnType<typeof posthog.signalsReportArtefactsDiff>>;
+
+const result: SignalsReportArtefactsDiffOutput = await posthog.signalsReportArtefactsDiff();
+
+// Result shape (from schema): { diff: string; truncated: boolean }
+```
+
+### `posthog.signalsReportsBulkStateCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/reports/bulk-state/`
+- **What it does**: Transition many reports to a new state in one call.
+
+Each id is processed independently: a report whose transition isn't allowed from its
+current status is reported as `skipped` (a 409 on the single-report endpoint) and the
+rest still go through. Returns one result per requested id (in request order, after
+de-duplication) plus per-outcome counts. The whole call is 200 even on partial failure —
+inspect `results` / the counts to see what happened.
+- **OpenAPI operationId**: `signals_reports_bulk_state_create`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ results: ({ id: string; outcome: string; status?: string | null; detail?: string | null })[]; transitioned_count: number; skipped_count: number; failed_count: number; not_found_count: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsReportsBulkStateCreateInput = Parameters<typeof posthog.signalsReportsBulkStateCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsReportsBulkStateCreateOutput = Awaited<ReturnType<typeof posthog.signalsReportsBulkStateCreate>>;
+
+const result: SignalsReportsBulkStateCreateOutput = await posthog.signalsReportsBulkStateCreate();
+
+// Result shape (from schema): { results: ({ id: string; outcome: string; status?: string | null; detail?: string | null })[]; transitioned_count: number; skipped_count: number; failed_count: number; not_found_count: number }
+```
+
+### `posthog.signalsScoutConfigList`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/configs/`
+- **What it does**: List scout configs
+- **OpenAPI operationId**: `signals_scout_config_list`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutConfigListInput = Parameters<typeof posthog.signalsScoutConfigList> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutConfigListOutput = Awaited<ReturnType<typeof posthog.signalsScoutConfigList>>;
+
+const result: SignalsScoutConfigListOutput = await posthog.signalsScoutConfigList();
+
+// Result shape (from schema): ({ id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string })[]
+```
+
+### `posthog.signalsScoutConfigCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/configs/`
+- **What it does**: Create a scout config
+- **OpenAPI operationId**: `signals_scout_config_create`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`, `201`, `400`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string }`
+- OpenAPI response codes: `200`, `201`, `400`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutConfigCreateInput = Parameters<typeof posthog.signalsScoutConfigCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutConfigCreateOutput = Awaited<ReturnType<typeof posthog.signalsScoutConfigCreate>>;
+
+const result: SignalsScoutConfigCreateOutput = await posthog.signalsScoutConfigCreate();
+
+// Result shape (from schema): { id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string }
+```
+
+### `posthog.signalsScoutConfigDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/signals/scout/configs/{id}/`
+- **What it does**: Delete a scout config
+- **OpenAPI operationId**: `signals_scout_config_destroy`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `204`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutConfigDestroyInput = Parameters<typeof posthog.signalsScoutConfigDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutConfigDestroyOutput = Awaited<ReturnType<typeof posthog.signalsScoutConfigDestroy>>;
+
+const result: SignalsScoutConfigDestroyOutput = await posthog.signalsScoutConfigDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.signalsScoutConfigUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/signals/scout/configs/{id}/`
+- **What it does**: Update a scout config
+- **OpenAPI operationId**: `signals_scout_config_update`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`, `400`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string }`
+- OpenAPI response codes: `200`, `400`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutConfigUpdateInput = Parameters<typeof posthog.signalsScoutConfigUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutConfigUpdateOutput = Awaited<ReturnType<typeof posthog.signalsScoutConfigUpdate>>;
+
+const result: SignalsScoutConfigUpdateOutput = await posthog.signalsScoutConfigUpdate();
+
+// Result shape (from schema): { id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string }
+```
+
+### `posthog.signalsScoutConfigRun`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/configs/{id}/run/`
+- **What it does**: Run a scout now
+- **OpenAPI operationId**: `signals_scout_config_run`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `202`, `403`, `404`, `409`, `429`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `202`, `403`, `404`, `409`, `429`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutConfigRunInput = Parameters<typeof posthog.signalsScoutConfigRun> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutConfigRunOutput = Awaited<ReturnType<typeof posthog.signalsScoutConfigRun>>;
+
+const result: SignalsScoutConfigRunOutput = await posthog.signalsScoutConfigRun();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.signalsScoutConfigSync`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/configs/sync/`
+- **What it does**: Sync scout configs
+- **OpenAPI operationId**: `signals_scout_config_sync`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutConfigSyncInput = Parameters<typeof posthog.signalsScoutConfigSync> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutConfigSyncOutput = Awaited<ReturnType<typeof posthog.signalsScoutConfigSync>>;
+
+const result: SignalsScoutConfigSyncOutput = await posthog.signalsScoutConfigSync();
+
+// Result shape (from schema): ({ id: string; skill_name: string; description: string; scout_origin: "canonical" | "custom"; enabled?: boolean; emit?: boolean; run_interval_minutes?: number; last_run_at: string | null; created_at: string })[]
+```
+
+### `posthog.signalsScoutMembersList`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/members/`
+- **What it does**: List project members for reviewer routing
+- **OpenAPI operationId**: `signals_scout_members_list`
+- **Path params**: None
+- **Query params**: `search`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ user_uuid: string; email: string; first_name: string; last_name: string; github_login: string | null })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutMembersListInput = Parameters<typeof posthog.signalsScoutMembersList> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutMembersListOutput = Awaited<ReturnType<typeof posthog.signalsScoutMembersList>>;
+
+const result: SignalsScoutMembersListOutput = await posthog.signalsScoutMembersList();
+
+// Result shape (from schema): ({ user_uuid: string; email: string; first_name: string; last_name: string; github_login: string | null })[]
+```
+
+### `posthog.signalsScoutMetadataGet`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/metadata/current/`
+- **What it does**: Get scout metadata
+- **OpenAPI operationId**: `signals_scout_metadata_get`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ enrolled: boolean; banner_message: string | null; limits: { max_runs_per_tick: number; max_runs_per_day: number | null; runs_today: number; runs_remaining_today: number | null } }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutMetadataGetInput = Parameters<typeof posthog.signalsScoutMetadataGet> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutMetadataGetOutput = Awaited<ReturnType<typeof posthog.signalsScoutMetadataGet>>;
+
+const result: SignalsScoutMetadataGetOutput = await posthog.signalsScoutMetadataGet();
+
+// Result shape (from schema): { enrolled: boolean; banner_message: string | null; limits: { max_runs_per_tick: number; max_runs_per_day: number | null; runs_today: number; runs_remaining_today: number | null } }
+```
+
+### `posthog.signalsScoutProjectProfileGet`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/project_profile/current/`
+- **What it does**: Get the current project profile
+- **OpenAPI operationId**: `signals_scout_project_profile_get`
+- **Path params**: None
+- **Query params**: `force_refresh`
+- **Response codes**: `200`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ profile_id: string; computed_at: string; expires_at: string; source_version: string; payload: { inventory: { project_context: { product_description: string | null; app_urls: (string)[] }; products_in_use: (string)[]; ...`
+- OpenAPI response codes: `200`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutProjectProfileGetInput = Parameters<typeof posthog.signalsScoutProjectProfileGet> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutProjectProfileGetOutput = Awaited<ReturnType<typeof posthog.signalsScoutProjectProfileGet>>;
+
+const result: SignalsScoutProjectProfileGetOutput = await posthog.signalsScoutProjectProfileGet();
+
+// Result shape (from schema): { profile_id: string; computed_at: string; expires_at: string; source_version: string; payload: { inventory: { project_context: { product_description: string | null; app_urls: (string)[] }; products_in_use: (string)[]; ...
+```
+
+### `posthog.signalsScoutRunsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/runs/`
+- **What it does**: Search recent agent runs
+- **OpenAPI operationId**: `signals_scout_runs_list`
+- **Path params**: None
+- **Query params**: `date_from`, `date_to`, `emitted`, `limit`, `skill_name`, `skill_version`, `text`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ run_id: string; skill_name: string; skill_version: number; status: string; created_at: string; started_at: string; completed_at: string | null; task_id?: string | null; task_run_id?: string | null; task_url?: string ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsListInput = Parameters<typeof posthog.signalsScoutRunsList> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsListOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsList>>;
+
+const result: SignalsScoutRunsListOutput = await posthog.signalsScoutRunsList();
+
+// Result shape (from schema): ({ run_id: string; skill_name: string; skill_version: number; status: string; created_at: string; started_at: string; completed_at: string | null; task_id?: string | null; task_run_id?: string | null; task_url?: string ...
+```
+
+### `posthog.signalsScoutRunsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/runs/{run_id}/`
+- **What it does**: Get a run by ID
+- **OpenAPI operationId**: `signals_scout_runs_retrieve`
+- **Path params**: `run_id`
+- **Query params**: None
+- **Response codes**: `200`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ run_id: string; skill_name: string; skill_version: number; status: string; created_at: string; started_at: string; completed_at: string | null; task_id?: string | null; task_run_id?: string | null; task_url?: string |...`
+- OpenAPI response codes: `200`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsRetrieveInput = Parameters<typeof posthog.signalsScoutRunsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsRetrieveOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsRetrieve>>;
+
+const result: SignalsScoutRunsRetrieveOutput = await posthog.signalsScoutRunsRetrieve();
+
+// Result shape (from schema): { run_id: string; skill_name: string; skill_version: number; status: string; created_at: string; started_at: string; completed_at: string | null; task_id?: string | null; task_run_id?: string | null; task_url?: string |...
+```
+
+### `posthog.signalsScoutEditReport`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/runs/{run_id}/edit-report/`
+- **What it does**: Edit an existing report for a run
+- **OpenAPI operationId**: `signals_scout_edit_report`
+- **Path params**: `run_id`
+- **Query params**: None
+- **Response codes**: `200`, `400`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ report_id: string; updated_fields: (string)[]; note_appended: boolean; reviewers_set: boolean }`
+- OpenAPI response codes: `200`, `400`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutEditReportInput = Parameters<typeof posthog.signalsScoutEditReport> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutEditReportOutput = Awaited<ReturnType<typeof posthog.signalsScoutEditReport>>;
+
+const result: SignalsScoutEditReportOutput = await posthog.signalsScoutEditReport();
+
+// Result shape (from schema): { report_id: string; updated_fields: (string)[]; note_appended: boolean; reviewers_set: boolean }
+```
+
+### `posthog.signalsScoutRunsEmissions`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/runs/{run_id}/emissions/`
+- **What it does**: List a run's emitted findings
+- **OpenAPI operationId**: `signals_scout_runs_emissions`
+- **Path params**: `run_id`
+- **Query params**: None
+- **Response codes**: `200`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ id: string; run_id: string; finding_id: string; description: string; weight: number; confidence: number; severity: "P0" | "P1" | "P2" | "P3" | "P4" | null; tags: (string)[]; source_id: string; emitted_at: string })[]`
+- OpenAPI response codes: `200`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsEmissionsInput = Parameters<typeof posthog.signalsScoutRunsEmissions> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsEmissionsOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsEmissions>>;
+
+const result: SignalsScoutRunsEmissionsOutput = await posthog.signalsScoutRunsEmissions();
+
+// Result shape (from schema): ({ id: string; run_id: string; finding_id: string; description: string; weight: number; confidence: number; severity: "P0" | "P1" | "P2" | "P3" | "P4" | null; tags: (string)[]; source_id: string; emitted_at: string })[]
+```
+
+### `posthog.signalsScoutRunsEmissionReports`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/runs/{run_id}/emissions/reports/`
+- **What it does**: List the inbox reports a run's findings linked to
+- **OpenAPI operationId**: `signals_scout_runs_emission_reports`
+- **Path params**: `run_id`
+- **Query params**: None
+- **Response codes**: `200`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ finding_id: string; source_id: string; report: { id: string; title: string | null; status: string } | null })[]`
+- OpenAPI response codes: `200`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsEmissionReportsInput = Parameters<typeof posthog.signalsScoutRunsEmissionReports> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsEmissionReportsOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsEmissionReports>>;
+
+const result: SignalsScoutRunsEmissionReportsOutput = await posthog.signalsScoutRunsEmissionReports();
+
+// Result shape (from schema): ({ finding_id: string; source_id: string; report: { id: string; title: string | null; status: string } | null })[]
+```
+
+### `posthog.signalsScoutEmitReport`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/runs/{run_id}/emit-report/`
+- **What it does**: Author a full report for a run
+- **OpenAPI operationId**: `signals_scout_emit_report`
+- **Path params**: `run_id`
+- **Query params**: None
+- **Response codes**: `200`, `400`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ report_id: string | null; report_status: string | null; emitted: boolean; skipped_reason: string | null; safety_explanation: string | null; remediation: string | null }`
+- OpenAPI response codes: `200`, `400`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutEmitReportInput = Parameters<typeof posthog.signalsScoutEmitReport> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutEmitReportOutput = Awaited<ReturnType<typeof posthog.signalsScoutEmitReport>>;
+
+const result: SignalsScoutEmitReportOutput = await posthog.signalsScoutEmitReport();
+
+// Result shape (from schema): { report_id: string | null; report_status: string | null; emitted: boolean; skipped_reason: string | null; safety_explanation: string | null; remediation: string | null }
+```
+
+### `posthog.signalsScoutEmitSignal`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/runs/{run_id}/emit-signal/`
+- **What it does**: Emit a finding for a run
+- **OpenAPI operationId**: `signals_scout_emit_signal`
+- **Path params**: `run_id`
+- **Query params**: None
+- **Response codes**: `200`, `400`, `404`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ finding_id: string; emitted: boolean; skipped_reason: string | null; remediation: string | null }`
+- OpenAPI response codes: `200`, `400`, `404`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutEmitSignalInput = Parameters<typeof posthog.signalsScoutEmitSignal> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutEmitSignalOutput = Awaited<ReturnType<typeof posthog.signalsScoutEmitSignal>>;
+
+const result: SignalsScoutEmitSignalOutput = await posthog.signalsScoutEmitSignal();
+
+// Result shape (from schema): { finding_id: string; emitted: boolean; skipped_reason: string | null; remediation: string | null }
+```
+
+### `posthog.signalsScoutRunsEmissionsBatch`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/runs/emissions/batch/`
+- **What it does**: List emitted findings for many runs at once
+- **OpenAPI operationId**: `signals_scout_runs_emissions_batch`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ id: string; run_id: string; finding_id: string; description: string; weight: number; confidence: number; severity: "P0" | "P1" | "P2" | "P3" | "P4" | null; tags: (string)[]; source_id: string; emitted_at: string })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsEmissionsBatchInput = Parameters<typeof posthog.signalsScoutRunsEmissionsBatch> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsEmissionsBatchOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsEmissionsBatch>>;
+
+const result: SignalsScoutRunsEmissionsBatchOutput = await posthog.signalsScoutRunsEmissionsBatch();
+
+// Result shape (from schema): ({ id: string; run_id: string; finding_id: string; description: string; weight: number; confidence: number; severity: "P0" | "P1" | "P2" | "P3" | "P4" | null; tags: (string)[]; source_id: string; emitted_at: string })[]
+```
+
+### `posthog.signalsScoutRunsRecentEmissions`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/runs/emissions/recent/`
+- **What it does**: List recent emitted findings across all runs
+- **OpenAPI operationId**: `signals_scout_runs_recent_emissions`
+- **Path params**: None
+- **Query params**: `date_from`, `date_to`, `limit`, `skill_name`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ id: string; run_id: string; finding_id: string; description: string; weight: number; confidence: number; severity: "P0" | "P1" | "P2" | "P3" | "P4" | null; tags: (string)[]; source_id: string; emitted_at: string })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsRecentEmissionsInput = Parameters<typeof posthog.signalsScoutRunsRecentEmissions> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsRecentEmissionsOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsRecentEmissions>>;
+
+const result: SignalsScoutRunsRecentEmissionsOutput = await posthog.signalsScoutRunsRecentEmissions();
+
+// Result shape (from schema): ({ id: string; run_id: string; finding_id: string; description: string; weight: number; confidence: number; severity: "P0" | "P1" | "P2" | "P3" | "P4" | null; tags: (string)[]; source_id: string; emitted_at: string })[]
+```
+
+### `posthog.signalsScoutRunsEmissionReportsBatch`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/runs/emissions/reports/batch/`
+- **What it does**: List the inbox reports many runs' findings linked to
+- **OpenAPI operationId**: `signals_scout_runs_emission_reports_batch`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ finding_id: string; source_id: string; report: { id: string; title: string | null; status: string } | null })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsEmissionReportsBatchInput = Parameters<typeof posthog.signalsScoutRunsEmissionReportsBatch> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsEmissionReportsBatchOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsEmissionReportsBatch>>;
+
+const result: SignalsScoutRunsEmissionReportsBatchOutput = await posthog.signalsScoutRunsEmissionReportsBatch();
+
+// Result shape (from schema): ({ finding_id: string; source_id: string; report: { id: string; title: string | null; status: string } | null })[]
+```
+
+### `posthog.signalsScoutRunsFindingsSummary`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/runs/findings/summary/`
+- **What it does**: Summarise recently emitted findings across the fleet
+- **OpenAPI operationId**: `signals_scout_runs_findings_summary`
+- **Path params**: None
+- **Query params**: `window_hours`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; scout_count: number; latest_at: string | null }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutRunsFindingsSummaryInput = Parameters<typeof posthog.signalsScoutRunsFindingsSummary> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutRunsFindingsSummaryOutput = Awaited<ReturnType<typeof posthog.signalsScoutRunsFindingsSummary>>;
+
+const result: SignalsScoutRunsFindingsSummaryOutput = await posthog.signalsScoutRunsFindingsSummary();
+
+// Result shape (from schema): { count: number; scout_count: number; latest_at: string | null }
+```
+
+### `posthog.signalsScoutScratchpadSearch`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/scout/scratchpad/`
+- **What it does**: Search the scout scratchpad
+- **OpenAPI operationId**: `signals_scout_scratchpad_search`
+- **Path params**: None
+- **Query params**: `content_max_chars`, `date_from`, `date_to`, `keys_only`, `limit`, `text`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ key: string; content: string; created_at: string | null; updated_at: string | null; created_by_run_id: string | null; created_by_skill?: string | null; created_by_run_url?: string | null })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutScratchpadSearchInput = Parameters<typeof posthog.signalsScoutScratchpadSearch> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutScratchpadSearchOutput = Awaited<ReturnType<typeof posthog.signalsScoutScratchpadSearch>>;
+
+const result: SignalsScoutScratchpadSearchOutput = await posthog.signalsScoutScratchpadSearch();
+
+// Result shape (from schema): ({ key: string; content: string; created_at: string | null; updated_at: string | null; created_by_run_id: string | null; created_by_skill?: string | null; created_by_run_url?: string | null })[]
+```
+
+### `posthog.signalsScoutScratchpadRemember`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/scratchpad/`
+- **What it does**: Remember a scratchpad entry
+- **OpenAPI operationId**: `signals_scout_scratchpad_remember`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`, `400`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ key: string; content: string; created_at: string | null; updated_at: string | null; created_by_run_id: string | null; created_by_skill?: string | null; created_by_run_url?: string | null }`
+- OpenAPI response codes: `200`, `400`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutScratchpadRememberInput = Parameters<typeof posthog.signalsScoutScratchpadRemember> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutScratchpadRememberOutput = Awaited<ReturnType<typeof posthog.signalsScoutScratchpadRemember>>;
+
+const result: SignalsScoutScratchpadRememberOutput = await posthog.signalsScoutScratchpadRemember();
+
+// Result shape (from schema): { key: string; content: string; created_at: string | null; updated_at: string | null; created_by_run_id: string | null; created_by_skill?: string | null; created_by_run_url?: string | null }
+```
+
+### `posthog.signalsScoutScratchpadForget`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/scout/scratchpad/forget/`
+- **What it does**: Forget a scratchpad entry by key
+- **OpenAPI operationId**: `signals_scout_scratchpad_forget`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ deleted: boolean }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsScoutScratchpadForgetInput = Parameters<typeof posthog.signalsScoutScratchpadForget> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsScoutScratchpadForgetOutput = Awaited<ReturnType<typeof posthog.signalsScoutScratchpadForget>>;
+
+const result: SignalsScoutScratchpadForgetOutput = await posthog.signalsScoutScratchpadForget();
+
+// Result shape (from schema): { deleted: boolean }
+```
+
+### `posthog.signalsSourceConfigsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/source_configs/`
+- **OpenAPI operationId**: `signals_source_configs_list`
+- **Path params**: None
+- **Query params**: `limit`, `offset`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pgana...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsSourceConfigsListInput = Parameters<typeof posthog.signalsSourceConfigsList> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsSourceConfigsListOutput = Awaited<ReturnType<typeof posthog.signalsSourceConfigsList>>;
+
+const result: SignalsSourceConfigsListOutput = await posthog.signalsSourceConfigsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pgana...
+```
+
+### `posthog.signalsSourceConfigsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/signals/source_configs/`
+- **OpenAPI operationId**: `signals_source_configs_create`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `201`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsSourceConfigsCreateInput = Parameters<typeof posthog.signalsSourceConfigsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsSourceConfigsCreateOutput = Awaited<ReturnType<typeof posthog.signalsSourceConfigsCreate>>;
+
+const result: SignalsSourceConfigsCreateOutput = await posthog.signalsSourceConfigsCreate();
+
+// Result shape (from schema): { id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...
+```
+
+### `posthog.signalsSourceConfigsDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/signals/source_configs/{id}/`
+- **OpenAPI operationId**: `signals_source_configs_destroy`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsSourceConfigsDestroyInput = Parameters<typeof posthog.signalsSourceConfigsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsSourceConfigsDestroyOutput = Awaited<ReturnType<typeof posthog.signalsSourceConfigsDestroy>>;
+
+const result: SignalsSourceConfigsDestroyOutput = await posthog.signalsSourceConfigsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.signalsSourceConfigsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/signals/source_configs/{id}/`
+- **OpenAPI operationId**: `signals_source_configs_retrieve`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsSourceConfigsRetrieveInput = Parameters<typeof posthog.signalsSourceConfigsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsSourceConfigsRetrieveOutput = Awaited<ReturnType<typeof posthog.signalsSourceConfigsRetrieve>>;
+
+const result: SignalsSourceConfigsRetrieveOutput = await posthog.signalsSourceConfigsRetrieve();
+
+// Result shape (from schema): { id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...
+```
+
+### `posthog.signalsSourceConfigsPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/signals/source_configs/{id}/`
+- **OpenAPI operationId**: `signals_source_configs_partial_update`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsSourceConfigsPartialUpdateInput = Parameters<typeof posthog.signalsSourceConfigsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsSourceConfigsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.signalsSourceConfigsPartialUpdate>>;
+
+const result: SignalsSourceConfigsPartialUpdateOutput = await posthog.signalsSourceConfigsPartialUpdate();
+
+// Result shape (from schema): { id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...
+```
+
+### `posthog.signalsSourceConfigsUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/signals/source_configs/{id}/`
+- **OpenAPI operationId**: `signals_source_configs_update`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type SignalsSourceConfigsUpdateInput = Parameters<typeof posthog.signalsSourceConfigsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type SignalsSourceConfigsUpdateOutput = Awaited<ReturnType<typeof posthog.signalsSourceConfigsUpdate>>;
+
+const result: SignalsSourceConfigsUpdateOutput = await posthog.signalsSourceConfigsUpdate();
+
+// Result shape (from schema): { id: string; source_product: "session_replay" | "llm_analytics" | "github" | "linear" | "zendesk" | "conversations" | "error_tracking" | "pganalyze" | "signals_scout" | "logs" | "health_checks" | "endpoints" | "replay_...
+```
+
+
+<!-- prompt-hash:
+8c3694991a4c289225f05a4e8f1e098cc74d085a088d7dffd82f00d93797b7f8
+-->