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

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

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

Inputs

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

Outputs

• Client return type: { status: string; paused_until: string }
• OpenAPI response codes: 200

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

Inputs

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

Outputs

• Client return type: { status: string; paused_until: string }
• OpenAPI response codes: 200

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

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

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

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

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

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

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

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

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": , }

• OpenAPI operationId: signals_reports_state_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; 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

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

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

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

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

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

Inputs

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

Outputs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Inputs

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

Outputs

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

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

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

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

Inputs

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

Outputs

• Client return type: unknown
• OpenAPI response codes: 202, 403, 404, 409, 429

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Inputs

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

Outputs

• Client return type: { deleted: boolean }
• OpenAPI response codes: 200

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

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

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

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

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

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

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

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

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

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

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

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