provider 2506 operations 141 docs pages

@utdk/posthog

PostHog API

Generated UTDK provider client for PostHog API. Generated UTDK provider types and OpenAPI-backed client for https://us.posthog.com/api/schema/.

Import sample

import posthog from "@utdk/posthog"

Factory sample

import { createPosthogClient } from "@utdk/posthog"

Provider path: posthog
Source API title: PostHog API
Version: 1.0.0
Generated: Jul 12, 2026, 9:26 PM
Homepage: Open site
API spec: View spec

Hog Flows

Optional generated docs page for @utdk/posthog.

Hog Flows

Operations

`posthog.environmentsHogFlowsList`

HTTP: GET /api/environments/{environment_id}/hog_flows/
OpenAPI operationId: environments_hog_flows_list
Path params: None
Query params: created_at, created_by, id, limit, offset, status, updated_at
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string | null; description: string; version: number; status: "draft" | "active" | "archived"; created_at: string; created_by...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsListInput = Parameters<typeof posthog.environmentsHogFlowsList> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsListOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsList>>;

const result: EnvironmentsHogFlowsListOutput = await posthog.environmentsHogFlowsList();

// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string | null; description: string; version: number; status: "draft" | "active" | "archived"; created_at: string; created_by...

`posthog.environmentsHogFlowsCreate`

HTTP: POST /api/environments/{environment_id}/hog_flows/
OpenAPI operationId: environments_hog_flows_create
Path params: None
Query params: None
Response codes: 201
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 201

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsCreateInput = Parameters<typeof posthog.environmentsHogFlowsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsCreateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsCreate>>;

const result: EnvironmentsHogFlowsCreateOutput = await posthog.environmentsHogFlowsCreate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.environmentsHogFlowsDestroy`

HTTP: DELETE /api/environments/{environment_id}/hog_flows/{id}/
OpenAPI operationId: environments_hog_flows_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 EnvironmentsHogFlowsDestroyInput = Parameters<typeof posthog.environmentsHogFlowsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsDestroyOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsDestroy>>;

const result: EnvironmentsHogFlowsDestroyOutput = await posthog.environmentsHogFlowsDestroy();

// Result shape (from schema): unknown

`posthog.environmentsHogFlowsRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/
OpenAPI operationId: environments_hog_flows_retrieve
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsRetrieve>>;

const result: EnvironmentsHogFlowsRetrieveOutput = await posthog.environmentsHogFlowsRetrieve();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.environmentsHogFlowsPartialUpdate`

HTTP: PATCH /api/environments/{environment_id}/hog_flows/{id}/
OpenAPI operationId: environments_hog_flows_partial_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsPartialUpdateInput = Parameters<typeof posthog.environmentsHogFlowsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsPartialUpdate>>;

const result: EnvironmentsHogFlowsPartialUpdateOutput = await posthog.environmentsHogFlowsPartialUpdate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.environmentsHogFlowsUpdate`

HTTP: PUT /api/environments/{environment_id}/hog_flows/{id}/
OpenAPI operationId: environments_hog_flows_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsUpdateInput = Parameters<typeof posthog.environmentsHogFlowsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsUpdate>>;

const result: EnvironmentsHogFlowsUpdateOutput = await posthog.environmentsHogFlowsUpdate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.environmentsHogFlowsAssetsRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/assets/
OpenAPI operationId: environments_hog_flows_assets_retrieve
Path params: id
Query params: action_id, after, before, distinct_id, invocation_id, limit, offset, parent_run_id, 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: ({ invocation_id: string; action_id: string; function_id: string; function_name: string; parent_run_id: string; kind: string; distinct_id: string; person_id: string; recipient: string; subject: string; status: string; s...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsAssetsRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsAssetsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsAssetsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsAssetsRetrieve>>;

const result: EnvironmentsHogFlowsAssetsRetrieveOutput = await posthog.environmentsHogFlowsAssetsRetrieve();

// Result shape (from schema): ({ invocation_id: string; action_id: string; function_id: string; function_name: string; parent_run_id: string; kind: string; distinct_id: string; person_id: string; recipient: string; subject: string; status: string; s...

`posthog.environmentsHogFlowsAssetContentRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/assets/content/
OpenAPI operationId: environments_hog_flows_asset_content_retrieve
Path params: id
Query params: action_id, invocation_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: string
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsAssetContentRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsAssetContentRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsAssetContentRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsAssetContentRetrieve>>;

const result: EnvironmentsHogFlowsAssetContentRetrieveOutput = await posthog.environmentsHogFlowsAssetContentRetrieve();

// Result shape (from schema): string

`posthog.environmentsHogFlowsBatchJobsList`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/batch_jobs/
OpenAPI operationId: environments_hog_flows_batch_jobs_list
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; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; disti...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsBatchJobsListInput = Parameters<typeof posthog.environmentsHogFlowsBatchJobsList> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsBatchJobsListOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsBatchJobsList>>;

const result: EnvironmentsHogFlowsBatchJobsListOutput = await posthog.environmentsHogFlowsBatchJobsList();

// Result shape (from schema): ({ id: string; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; disti...

`posthog.environmentsHogFlowsBatchJobsCreate`

HTTP: POST /api/environments/{environment_id}/hog_flows/{id}/batch_jobs/
OpenAPI operationId: environments_hog_flows_batch_jobs_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; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; distin...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsBatchJobsCreateInput = Parameters<typeof posthog.environmentsHogFlowsBatchJobsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsBatchJobsCreateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsBatchJobsCreate>>;

const result: EnvironmentsHogFlowsBatchJobsCreateOutput = await posthog.environmentsHogFlowsBatchJobsCreate();

// Result shape (from schema): { id: string; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; distin...

`posthog.environmentsHogFlowsGraphPartialUpdate`

HTTP: PATCH /api/environments/{environment_id}/hog_flows/{id}/graph/
OpenAPI operationId: environments_hog_flows_graph_partial_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsGraphPartialUpdateInput = Parameters<typeof posthog.environmentsHogFlowsGraphPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsGraphPartialUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsGraphPartialUpdate>>;

const result: EnvironmentsHogFlowsGraphPartialUpdateOutput = await posthog.environmentsHogFlowsGraphPartialUpdate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.environmentsHogFlowsInvocationResultsRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/invocation_results/
OpenAPI operationId: environments_hog_flows_invocation_results_retrieve
Path params: id
Query params: after, before, distinct_id, limit, status
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: ({ invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null; finished_at: string | null; duration_ms: numb...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsInvocationResultsRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsInvocationResultsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsInvocationResultsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsInvocationResultsRetrieve>>;

const result: EnvironmentsHogFlowsInvocationResultsRetrieveOutput = await posthog.environmentsHogFlowsInvocationResultsRetrieve();

// Result shape (from schema): ({ invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null; finished_at: string | null; duration_ms: numb...

`posthog.environmentsHogFlowsInvocationResultRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/invocation_results/{invocation_id}/
OpenAPI operationId: environments_hog_flows_invocation_result_retrieve
Path params: id, invocation_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: { invocation_globals: { [key: string]: unknown }; invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsInvocationResultRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsInvocationResultRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsInvocationResultRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsInvocationResultRetrieve>>;

const result: EnvironmentsHogFlowsInvocationResultRetrieveOutput = await posthog.environmentsHogFlowsInvocationResultRetrieve();

// Result shape (from schema): { invocation_globals: { [key: string]: unknown }; invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null...

`posthog.environmentsHogFlowsInvocationsCreate`

HTTP: POST /api/environments/{environment_id}/hog_flows/{id}/invocations/
OpenAPI operationId: environments_hog_flows_invocations_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: unknown
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsInvocationsCreateInput = Parameters<typeof posthog.environmentsHogFlowsInvocationsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsInvocationsCreateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsInvocationsCreate>>;

const result: EnvironmentsHogFlowsInvocationsCreateOutput = await posthog.environmentsHogFlowsInvocationsCreate();

// Result shape (from schema): unknown

`posthog.environmentsHogFlowsLogsRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/logs/
OpenAPI operationId: environments_hog_flows_logs_retrieve
Path params: id
Query params: after, before, instance_id, level, limit, 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: unknown
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsLogsRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsLogsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsLogsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsLogsRetrieve>>;

const result: EnvironmentsHogFlowsLogsRetrieveOutput = await posthog.environmentsHogFlowsLogsRetrieve();

// Result shape (from schema): unknown

`posthog.environmentsHogFlowsMetricsRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/metrics/
OpenAPI operationId: environments_hog_flows_metrics_retrieve
Path params: id
Query params: after, before, breakdown_by, instance_id, interval, kind, 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: { labels: (string)[]; series: ({ name: string; values: (number)[] })[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsMetricsRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsMetricsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsMetricsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsMetricsRetrieve>>;

const result: EnvironmentsHogFlowsMetricsRetrieveOutput = await posthog.environmentsHogFlowsMetricsRetrieve();

// Result shape (from schema): { labels: (string)[]; series: ({ name: string; values: (number)[] })[] }

`posthog.environmentsHogFlowsMetricsTotalsRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/metrics/totals/
OpenAPI operationId: environments_hog_flows_metrics_totals_retrieve
Path params: id
Query params: after, before, breakdown_by, instance_id, interval, kind, 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: { totals: { [key: string]: number | undefined } }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsMetricsTotalsRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsMetricsTotalsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsMetricsTotalsRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsMetricsTotalsRetrieve>>;

const result: EnvironmentsHogFlowsMetricsTotalsRetrieveOutput = await posthog.environmentsHogFlowsMetricsTotalsRetrieve();

// Result shape (from schema): { totals: { [key: string]: number | undefined } }

`posthog.environmentsHogFlowsRerunCreate`

HTTP: POST /api/environments/{environment_id}/hog_flows/{id}/rerun/
What it does: Rerun past invocations of this hog flow from their stored payloads.

Same shape and semantics as the hog function rerun endpoint — proxies through to the CDP worker, which reads matching rows from ClickHouse, rehydrates from invocation_globals, and re-enqueues onto cyclotron with is_retry=1.

Because rerun replays historical event/person/group data, it requires person:read and group:read on top of hog_flow:write.

OpenAPI operationId: environments_hog_flows_rerun_create
Path params: id
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: { rerun_job_id: string; queued_count: number; skipped_count: number }
OpenAPI response codes: 200, 400

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsRerunCreateInput = Parameters<typeof posthog.environmentsHogFlowsRerunCreate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsRerunCreateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsRerunCreate>>;

const result: EnvironmentsHogFlowsRerunCreateOutput = await posthog.environmentsHogFlowsRerunCreate();

// Result shape (from schema): { rerun_job_id: string; queued_count: number; skipped_count: number }

`posthog.environmentsHogFlowsSchedulesList`

HTTP: GET /api/environments/{environment_id}/hog_flows/{id}/schedules/
OpenAPI operationId: environments_hog_flows_schedules_list
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; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string })[]
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsSchedulesListInput = Parameters<typeof posthog.environmentsHogFlowsSchedulesList> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsSchedulesListOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsSchedulesList>>;

const result: EnvironmentsHogFlowsSchedulesListOutput = await posthog.environmentsHogFlowsSchedulesList();

// Result shape (from schema): ({ id: string; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string })[]

`posthog.environmentsHogFlowsSchedulesCreate`

HTTP: POST /api/environments/{environment_id}/hog_flows/{id}/schedules/
OpenAPI operationId: environments_hog_flows_schedules_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; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsSchedulesCreateInput = Parameters<typeof posthog.environmentsHogFlowsSchedulesCreate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsSchedulesCreateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsSchedulesCreate>>;

const result: EnvironmentsHogFlowsSchedulesCreateOutput = await posthog.environmentsHogFlowsSchedulesCreate();

// Result shape (from schema): { id: string; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }

`posthog.environmentsHogFlowsSchedulesDestroy`

HTTP: DELETE /api/environments/{environment_id}/hog_flows/{id}/schedules/{schedule_id}/
OpenAPI operationId: environments_hog_flows_schedules_destroy
Path params: id, schedule_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 EnvironmentsHogFlowsSchedulesDestroyInput = Parameters<typeof posthog.environmentsHogFlowsSchedulesDestroy> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsSchedulesDestroyOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsSchedulesDestroy>>;

const result: EnvironmentsHogFlowsSchedulesDestroyOutput = await posthog.environmentsHogFlowsSchedulesDestroy();

// Result shape (from schema): unknown

`posthog.environmentsHogFlowsSchedulesPartialUpdate`

HTTP: PATCH /api/environments/{environment_id}/hog_flows/{id}/schedules/{schedule_id}/
OpenAPI operationId: environments_hog_flows_schedules_partial_update
Path params: id, schedule_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; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsSchedulesPartialUpdateInput = Parameters<typeof posthog.environmentsHogFlowsSchedulesPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsSchedulesPartialUpdateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsSchedulesPartialUpdate>>;

const result: EnvironmentsHogFlowsSchedulesPartialUpdateOutput = await posthog.environmentsHogFlowsSchedulesPartialUpdate();

// Result shape (from schema): { id: string; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }

`posthog.environmentsHogFlowsBulkDeleteCreate`

HTTP: POST /api/environments/{environment_id}/hog_flows/bulk_delete/
OpenAPI operationId: environments_hog_flows_bulk_delete_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: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsBulkDeleteCreateInput = Parameters<typeof posthog.environmentsHogFlowsBulkDeleteCreate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsBulkDeleteCreateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsBulkDeleteCreate>>;

const result: EnvironmentsHogFlowsBulkDeleteCreateOutput = await posthog.environmentsHogFlowsBulkDeleteCreate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.environmentsHogFlowsMetricsGlobalRetrieve`

HTTP: GET /api/environments/{environment_id}/hog_flows/metrics/global/
OpenAPI operationId: environments_hog_flows_metrics_global_retrieve
Path params: None
Query params: after, before
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: ({ workflow_id: string; succeeded: number; failed: number })[]
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsMetricsGlobalRetrieveInput = Parameters<typeof posthog.environmentsHogFlowsMetricsGlobalRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsMetricsGlobalRetrieveOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsMetricsGlobalRetrieve>>;

const result: EnvironmentsHogFlowsMetricsGlobalRetrieveOutput = await posthog.environmentsHogFlowsMetricsGlobalRetrieve();

// Result shape (from schema): ({ workflow_id: string; succeeded: number; failed: number })[]

`posthog.environmentsHogFlowsUserBlastRadiusCreate`

HTTP: POST /api/environments/{environment_id}/hog_flows/user_blast_radius/
OpenAPI operationId: environments_hog_flows_user_blast_radius_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: { affected: number; total: number; limit: number; dedupe_key: "email" | null }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type EnvironmentsHogFlowsUserBlastRadiusCreateInput = Parameters<typeof posthog.environmentsHogFlowsUserBlastRadiusCreate> extends [infer T, ...unknown[]] ? T : undefined;
type EnvironmentsHogFlowsUserBlastRadiusCreateOutput = Awaited<ReturnType<typeof posthog.environmentsHogFlowsUserBlastRadiusCreate>>;

const result: EnvironmentsHogFlowsUserBlastRadiusCreateOutput = await posthog.environmentsHogFlowsUserBlastRadiusCreate();

// Result shape (from schema): { affected: number; total: number; limit: number; dedupe_key: "email" | null }

`posthog.hogFlowsList`

HTTP: GET /api/projects/{project_id}/hog_flows/
OpenAPI operationId: hog_flows_list
Path params: None
Query params: created_at, created_by, id, limit, offset, status, updated_at
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string | null; description: string; version: number; status: "draft" | "active" | "archived"; created_at: string; created_by...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsListInput = Parameters<typeof posthog.hogFlowsList> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsListOutput = Awaited<ReturnType<typeof posthog.hogFlowsList>>;

const result: HogFlowsListOutput = await posthog.hogFlowsList();

// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; name: string | null; description: string; version: number; status: "draft" | "active" | "archived"; created_at: string; created_by...

`posthog.hogFlowsCreate`

HTTP: POST /api/projects/{project_id}/hog_flows/
OpenAPI operationId: hog_flows_create
Path params: None
Query params: None
Response codes: 201
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 201

import posthog from "@utdk/posthog";

type HogFlowsCreateInput = Parameters<typeof posthog.hogFlowsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsCreateOutput = Awaited<ReturnType<typeof posthog.hogFlowsCreate>>;

const result: HogFlowsCreateOutput = await posthog.hogFlowsCreate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.hogFlowsDestroy`

HTTP: DELETE /api/projects/{project_id}/hog_flows/{id}/
OpenAPI operationId: hog_flows_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 HogFlowsDestroyInput = Parameters<typeof posthog.hogFlowsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsDestroyOutput = Awaited<ReturnType<typeof posthog.hogFlowsDestroy>>;

const result: HogFlowsDestroyOutput = await posthog.hogFlowsDestroy();

// Result shape (from schema): unknown

`posthog.hogFlowsRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/
OpenAPI operationId: hog_flows_retrieve
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsRetrieveInput = Parameters<typeof posthog.hogFlowsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsRetrieve>>;

const result: HogFlowsRetrieveOutput = await posthog.hogFlowsRetrieve();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.hogFlowsPartialUpdate`

HTTP: PATCH /api/projects/{project_id}/hog_flows/{id}/
OpenAPI operationId: hog_flows_partial_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsPartialUpdateInput = Parameters<typeof posthog.hogFlowsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.hogFlowsPartialUpdate>>;

const result: HogFlowsPartialUpdateOutput = await posthog.hogFlowsPartialUpdate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.hogFlowsUpdate`

HTTP: PUT /api/projects/{project_id}/hog_flows/{id}/
OpenAPI operationId: hog_flows_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsUpdateInput = Parameters<typeof posthog.hogFlowsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsUpdateOutput = Awaited<ReturnType<typeof posthog.hogFlowsUpdate>>;

const result: HogFlowsUpdateOutput = await posthog.hogFlowsUpdate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.hogFlowsAssetsRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/assets/
OpenAPI operationId: hog_flows_assets_retrieve
Path params: id
Query params: action_id, after, before, distinct_id, invocation_id, limit, offset, parent_run_id, 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: ({ invocation_id: string; action_id: string; function_id: string; function_name: string; parent_run_id: string; kind: string; distinct_id: string; person_id: string; recipient: string; subject: string; status: string; s...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsAssetsRetrieveInput = Parameters<typeof posthog.hogFlowsAssetsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsAssetsRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsAssetsRetrieve>>;

const result: HogFlowsAssetsRetrieveOutput = await posthog.hogFlowsAssetsRetrieve();

// Result shape (from schema): ({ invocation_id: string; action_id: string; function_id: string; function_name: string; parent_run_id: string; kind: string; distinct_id: string; person_id: string; recipient: string; subject: string; status: string; s...

`posthog.hogFlowsAssetContentRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/assets/content/
OpenAPI operationId: hog_flows_asset_content_retrieve
Path params: id
Query params: action_id, invocation_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: string
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsAssetContentRetrieveInput = Parameters<typeof posthog.hogFlowsAssetContentRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsAssetContentRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsAssetContentRetrieve>>;

const result: HogFlowsAssetContentRetrieveOutput = await posthog.hogFlowsAssetContentRetrieve();

// Result shape (from schema): string

`posthog.hogFlowsBatchJobsList`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/batch_jobs/
OpenAPI operationId: hog_flows_batch_jobs_list
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; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; disti...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsBatchJobsListInput = Parameters<typeof posthog.hogFlowsBatchJobsList> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsBatchJobsListOutput = Awaited<ReturnType<typeof posthog.hogFlowsBatchJobsList>>;

const result: HogFlowsBatchJobsListOutput = await posthog.hogFlowsBatchJobsList();

// Result shape (from schema): ({ id: string; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; disti...

`posthog.hogFlowsBatchJobsCreate`

HTTP: POST /api/projects/{project_id}/hog_flows/{id}/batch_jobs/
OpenAPI operationId: hog_flows_batch_jobs_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; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; distin...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsBatchJobsCreateInput = Parameters<typeof posthog.hogFlowsBatchJobsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsBatchJobsCreateOutput = Awaited<ReturnType<typeof posthog.hogFlowsBatchJobsCreate>>;

const result: HogFlowsBatchJobsCreateOutput = await posthog.hogFlowsBatchJobsCreate();

// Result shape (from schema): { id: string; status?: "waiting" | "queued" | "active" | "completed" | "cancelled" | "failed"; hog_flow: string; filters?: unknown; variables?: unknown; created_at: string; created_by: { id: number; uuid: string; distin...

`posthog.hogFlowsGraphPartialUpdate`

HTTP: PATCH /api/projects/{project_id}/hog_flows/{id}/graph/
OpenAPI operationId: hog_flows_graph_partial_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsGraphPartialUpdateInput = Parameters<typeof posthog.hogFlowsGraphPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsGraphPartialUpdateOutput = Awaited<ReturnType<typeof posthog.hogFlowsGraphPartialUpdate>>;

const result: HogFlowsGraphPartialUpdateOutput = await posthog.hogFlowsGraphPartialUpdate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.hogFlowsInvocationResultsRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/invocation_results/
OpenAPI operationId: hog_flows_invocation_results_retrieve
Path params: id
Query params: after, before, distinct_id, limit, status
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: ({ invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null; finished_at: string | null; duration_ms: numb...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsInvocationResultsRetrieveInput = Parameters<typeof posthog.hogFlowsInvocationResultsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsInvocationResultsRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsInvocationResultsRetrieve>>;

const result: HogFlowsInvocationResultsRetrieveOutput = await posthog.hogFlowsInvocationResultsRetrieve();

// Result shape (from schema): ({ invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null; finished_at: string | null; duration_ms: numb...

`posthog.hogFlowsInvocationResultRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/invocation_results/{invocation_id}/
OpenAPI operationId: hog_flows_invocation_result_retrieve
Path params: id, invocation_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: { invocation_globals: { [key: string]: unknown }; invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsInvocationResultRetrieveInput = Parameters<typeof posthog.hogFlowsInvocationResultRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsInvocationResultRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsInvocationResultRetrieve>>;

const result: HogFlowsInvocationResultRetrieveOutput = await posthog.hogFlowsInvocationResultRetrieve();

// Result shape (from schema): { invocation_globals: { [key: string]: unknown }; invocation_id: string; status: string; error_kind: string; error_message: string; distinct_id: string; person_id: string; scheduled_at: string; started_at: string | null...

`posthog.hogFlowsInvocationsCreate`

HTTP: POST /api/projects/{project_id}/hog_flows/{id}/invocations/
OpenAPI operationId: hog_flows_invocations_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: unknown
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsInvocationsCreateInput = Parameters<typeof posthog.hogFlowsInvocationsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsInvocationsCreateOutput = Awaited<ReturnType<typeof posthog.hogFlowsInvocationsCreate>>;

const result: HogFlowsInvocationsCreateOutput = await posthog.hogFlowsInvocationsCreate();

// Result shape (from schema): unknown

`posthog.hogFlowsLogsRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/logs/
OpenAPI operationId: hog_flows_logs_retrieve
Path params: id
Query params: after, before, instance_id, level, limit, 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: unknown
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsLogsRetrieveInput = Parameters<typeof posthog.hogFlowsLogsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsLogsRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsLogsRetrieve>>;

const result: HogFlowsLogsRetrieveOutput = await posthog.hogFlowsLogsRetrieve();

// Result shape (from schema): unknown

`posthog.hogFlowsMetricsRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/metrics/
OpenAPI operationId: hog_flows_metrics_retrieve
Path params: id
Query params: after, before, breakdown_by, instance_id, interval, kind, 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: { labels: (string)[]; series: ({ name: string; values: (number)[] })[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsMetricsRetrieveInput = Parameters<typeof posthog.hogFlowsMetricsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsMetricsRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsMetricsRetrieve>>;

const result: HogFlowsMetricsRetrieveOutput = await posthog.hogFlowsMetricsRetrieve();

// Result shape (from schema): { labels: (string)[]; series: ({ name: string; values: (number)[] })[] }

`posthog.hogFlowsMetricsTotalsRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/metrics/totals/
OpenAPI operationId: hog_flows_metrics_totals_retrieve
Path params: id
Query params: after, before, breakdown_by, instance_id, interval, kind, 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: { totals: { [key: string]: number | undefined } }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsMetricsTotalsRetrieveInput = Parameters<typeof posthog.hogFlowsMetricsTotalsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsMetricsTotalsRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsMetricsTotalsRetrieve>>;

const result: HogFlowsMetricsTotalsRetrieveOutput = await posthog.hogFlowsMetricsTotalsRetrieve();

// Result shape (from schema): { totals: { [key: string]: number | undefined } }

`posthog.hogFlowsRerunCreate`

HTTP: POST /api/projects/{project_id}/hog_flows/{id}/rerun/
What it does: Rerun past invocations of this hog flow from their stored payloads.

Because rerun replays historical event/person/group data, it requires person:read and group:read on top of hog_flow:write.

OpenAPI operationId: hog_flows_rerun_create
Path params: id
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: { rerun_job_id: string; queued_count: number; skipped_count: number }
OpenAPI response codes: 200, 400

import posthog from "@utdk/posthog";

type HogFlowsRerunCreateInput = Parameters<typeof posthog.hogFlowsRerunCreate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsRerunCreateOutput = Awaited<ReturnType<typeof posthog.hogFlowsRerunCreate>>;

const result: HogFlowsRerunCreateOutput = await posthog.hogFlowsRerunCreate();

// Result shape (from schema): { rerun_job_id: string; queued_count: number; skipped_count: number }

`posthog.hogFlowsSchedulesList`

HTTP: GET /api/projects/{project_id}/hog_flows/{id}/schedules/
OpenAPI operationId: hog_flows_schedules_list
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; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string })[]
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsSchedulesListInput = Parameters<typeof posthog.hogFlowsSchedulesList> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsSchedulesListOutput = Awaited<ReturnType<typeof posthog.hogFlowsSchedulesList>>;

const result: HogFlowsSchedulesListOutput = await posthog.hogFlowsSchedulesList();

// Result shape (from schema): ({ id: string; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string })[]

`posthog.hogFlowsSchedulesCreate`

HTTP: POST /api/projects/{project_id}/hog_flows/{id}/schedules/
OpenAPI operationId: hog_flows_schedules_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; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsSchedulesCreateInput = Parameters<typeof posthog.hogFlowsSchedulesCreate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsSchedulesCreateOutput = Awaited<ReturnType<typeof posthog.hogFlowsSchedulesCreate>>;

const result: HogFlowsSchedulesCreateOutput = await posthog.hogFlowsSchedulesCreate();

// Result shape (from schema): { id: string; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }

`posthog.hogFlowsSchedulesDestroy`

HTTP: DELETE /api/projects/{project_id}/hog_flows/{id}/schedules/{schedule_id}/
OpenAPI operationId: hog_flows_schedules_destroy
Path params: id, schedule_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 HogFlowsSchedulesDestroyInput = Parameters<typeof posthog.hogFlowsSchedulesDestroy> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsSchedulesDestroyOutput = Awaited<ReturnType<typeof posthog.hogFlowsSchedulesDestroy>>;

const result: HogFlowsSchedulesDestroyOutput = await posthog.hogFlowsSchedulesDestroy();

// Result shape (from schema): unknown

`posthog.hogFlowsSchedulesPartialUpdate`

HTTP: PATCH /api/projects/{project_id}/hog_flows/{id}/schedules/{schedule_id}/
OpenAPI operationId: hog_flows_schedules_partial_update
Path params: id, schedule_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; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsSchedulesPartialUpdateInput = Parameters<typeof posthog.hogFlowsSchedulesPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsSchedulesPartialUpdateOutput = Awaited<ReturnType<typeof posthog.hogFlowsSchedulesPartialUpdate>>;

const result: HogFlowsSchedulesPartialUpdateOutput = await posthog.hogFlowsSchedulesPartialUpdate();

// Result shape (from schema): { id: string; rrule: string; starts_at: string; timezone?: string; variables?: unknown; status: "active" | "paused" | "completed"; next_run_at: string | null; created_at: string; updated_at: string }

`posthog.hogFlowsBulkDeleteCreate`

HTTP: POST /api/projects/{project_id}/hog_flows/bulk_delete/
OpenAPI operationId: hog_flows_bulk_delete_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: { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsBulkDeleteCreateInput = Parameters<typeof posthog.hogFlowsBulkDeleteCreate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsBulkDeleteCreateOutput = Awaited<ReturnType<typeof posthog.hogFlowsBulkDeleteCreate>>;

const result: HogFlowsBulkDeleteCreateOutput = await posthog.hogFlowsBulkDeleteCreate();

// Result shape (from schema): { id: string; name?: string | null; description?: string; version: number; status?: "draft" | "active" | "archived"; created_at: string; created_by: { id: number; uuid: string; distinct_id?: string | null; first_name?: ...

`posthog.hogFlowsMetricsGlobalRetrieve`

HTTP: GET /api/projects/{project_id}/hog_flows/metrics/global/
OpenAPI operationId: hog_flows_metrics_global_retrieve
Path params: None
Query params: after, before
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

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

Outputs

Client return type: ({ workflow_id: string; succeeded: number; failed: number })[]
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsMetricsGlobalRetrieveInput = Parameters<typeof posthog.hogFlowsMetricsGlobalRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsMetricsGlobalRetrieveOutput = Awaited<ReturnType<typeof posthog.hogFlowsMetricsGlobalRetrieve>>;

const result: HogFlowsMetricsGlobalRetrieveOutput = await posthog.hogFlowsMetricsGlobalRetrieve();

// Result shape (from schema): ({ workflow_id: string; succeeded: number; failed: number })[]

`posthog.hogFlowsUserBlastRadiusCreate`

HTTP: POST /api/projects/{project_id}/hog_flows/user_blast_radius/
OpenAPI operationId: hog_flows_user_blast_radius_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: { affected: number; total: number; limit: number; dedupe_key: "email" | null }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type HogFlowsUserBlastRadiusCreateInput = Parameters<typeof posthog.hogFlowsUserBlastRadiusCreate> extends [infer T, ...unknown[]] ? T : undefined;
type HogFlowsUserBlastRadiusCreateOutput = Awaited<ReturnType<typeof posthog.hogFlowsUserBlastRadiusCreate>>;

const result: HogFlowsUserBlastRadiusCreateOutput = await posthog.hogFlowsUserBlastRadiusCreate();

// Result shape (from schema): { affected: number; total: number; limit: number; dedupe_key: "email" | null }