@keystrokehq/posthog 0.0.9 → 0.0.16-integration-id-canonicalization.0

package/dist/surveys-update.operation-C0MYZZ04.mjs

@@ -0,0 +1,3836 @@
+import { t as posthogCredentialSet } from "./posthog.credential-set-DwYnDkeD.mjs";
+import { actionSchema, analyticsEventSchema, annotationSchema, captureResponseSchema, cohortSchema, dashboardCollaboratorSchema, dashboardSchema, dashboardTemplateSchema, decideResponseSchema, eventDefinitionSchema, featureFlagFiltersSchema, featureFlagRoleAccessSchema, featureFlagSchema, insightSchema, localEvaluationResponseSchema, organizationSchema, paginatedResponseSchema, personSchema, projectIdInputShape, projectMemberSchema, projectSchema, propertiesBagSchema, sessionRecordingPlaylistSchema, sessionRecordingSchema, sharingConfigurationSchema, surveySchema } from "./schemas/index.mjs";
+import { n as createPosthogIngestClient, r as createPosthogManagementClient, t as createPosthogDecideClient } from "./client-BZWd9-On.mjs";
+import { Operation } from "@keystrokehq/core";
+import { z } from "zod";
+
+//#region src/utils/domain-inputs/webhook-management.ts
+const actionIdInput = {
+	...projectIdInputShape,
+	actionId: z.number().int()
+};
+
+//#endregion
+//#region src/operations/action-webhooks-attach.operation.ts
+const actionWebhooksAttachOperation = new Operation({
+	id: "posthog.action-webhooks-attach",
+	name: "PostHog Attach Action Webhook",
+	description: "Enable Slack-webhook posting on an action with a message format",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...actionIdInput,
+		slack_message_format: z.string().min(1)
+	}),
+	output: actionSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/actions/${input.actionId}/`,
+			body: {
+				post_to_slack: true,
+				slack_message_format: input.slack_message_format
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/action-webhooks-detach.operation.ts
+const actionWebhooksDetachOperation = new Operation({
+	id: "posthog.action-webhooks-detach",
+	name: "PostHog Detach Action Webhook",
+	description: "Disable Slack-webhook posting on an action",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(actionIdInput),
+	output: actionSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/actions/${input.actionId}/`,
+			body: {
+				post_to_slack: false,
+				slack_message_format: null
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/action-webhooks-list.operation.ts
+const actionWebhooksListOperation = new Operation({
+	id: "posthog.action-webhooks-list",
+	name: "PostHog List Action Webhooks",
+	description: "List actions configured to post to a Slack webhook",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional()
+	}),
+	output: paginatedResponseSchema(actionSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/actions/`,
+			query: {
+				limit: input.limit,
+				post_to_slack: true
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/surveys.ts
+const idInput$3 = {
+	...projectIdInputShape,
+	id: z.string().min(1)
+};
+const writeShape$1 = {
+	name: z.string().optional(),
+	description: z.string().nullable().optional(),
+	type: z.enum([
+		"popover",
+		"api",
+		"widget",
+		"button",
+		"full_screen",
+		"email"
+	]).optional(),
+	questions: z.array(z.record(z.string(), z.unknown())).optional(),
+	conditions: z.record(z.string(), z.unknown()).nullable().optional(),
+	appearance: z.record(z.string(), z.unknown()).nullable().optional(),
+	targeting_flag_id: z.number().int().nullable().optional(),
+	start_date: z.string().nullable().optional(),
+	end_date: z.string().nullable().optional(),
+	responses_limit: z.number().int().nullable().optional(),
+	archived: z.boolean().optional()
+};
+
+//#endregion
+//#region src/operations/actions-create.operation.ts
+const actionsCreateOperation = new Operation({
+	id: "posthog.actions-create",
+	name: "PostHog Create Action",
+	description: "Create a new action",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		...writeShape$1,
+		name: z.string().min(1)
+	}),
+	output: actionSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/actions/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/actions-delete.operation.ts
+const actionsDeleteOperation = new Operation({
+	id: "posthog.actions-delete",
+	name: "PostHog Delete Action",
+	description: "Soft-delete an action",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: actionSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/actions/${input.id}/`,
+			body: { deleted: true }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/actions-get.operation.ts
+const actionsGetOperation = new Operation({
+	id: "posthog.actions-get",
+	name: "PostHog Get Action",
+	description: "Retrieve an action by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: actionSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/actions/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/actions-list.operation.ts
+const actionsListOperation = new Operation({
+	id: "posthog.actions-list",
+	name: "PostHog List Actions",
+	description: "List actions in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional()
+	}),
+	output: paginatedResponseSchema(actionSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/actions/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/actions-update.operation.ts
+const actionsUpdateOperation = new Operation({
+	id: "posthog.actions-update",
+	name: "PostHog Update Action",
+	description: "Partial update to an action",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		...writeShape$1
+	}),
+	output: actionSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/actions/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/alias-person.operation.ts
+const aliasPersonOperation = new Operation({
+	id: "posthog.alias-person",
+	name: "PostHog Alias Person",
+	description: "Merge one distinct_id into another via a $create_alias event",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		distinctId: z.string().min(1),
+		alias: z.string().min(1),
+		timestamp: z.iso.datetime().optional()
+	}),
+	output: captureResponseSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogIngestClient(context.credentials.posthog);
+		return client.request({
+			method: "POST",
+			path: "/capture/",
+			body: {
+				api_key: client.projectApiKey(),
+				event: "$create_alias",
+				distinct_id: input.distinctId,
+				properties: { alias: input.alias },
+				...input.timestamp ? { timestamp: input.timestamp } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/annotations-create.operation.ts
+const annotationsCreateOperation = new Operation({
+	id: "posthog.annotations-create",
+	name: "PostHog Create Annotation",
+	description: "Create a new annotation",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		...writeShape$1,
+		content: z.string().min(1),
+		date_marker: z.string().min(1)
+	}),
+	output: annotationSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/annotations/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/annotations-delete.operation.ts
+const annotationsDeleteOperation = new Operation({
+	id: "posthog.annotations-delete",
+	name: "PostHog Delete Annotation",
+	description: "Delete an annotation",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/annotations/${input.id}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/annotations-get.operation.ts
+const annotationsGetOperation = new Operation({
+	id: "posthog.annotations-get",
+	name: "PostHog Get Annotation",
+	description: "Retrieve an annotation by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: annotationSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/annotations/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/annotations-list.operation.ts
+const annotationsListOperation = new Operation({
+	id: "posthog.annotations-list",
+	name: "PostHog List Annotations",
+	description: "List annotations in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional(),
+		scope: z.enum([
+			"dashboard_item",
+			"project",
+			"organization"
+		]).optional(),
+		dashboardItemId: z.number().int().optional()
+	}),
+	output: paginatedResponseSchema(annotationSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/annotations/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search,
+				scope: input.scope,
+				dashboardItemId: input.dashboardItemId
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/annotations-update.operation.ts
+const annotationsUpdateOperation = new Operation({
+	id: "posthog.annotations-update",
+	name: "PostHog Update Annotation",
+	description: "Partial update to an annotation",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		...writeShape$1
+	}),
+	output: annotationSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/annotations/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/capture-batch-events.operation.ts
+const captureBatchEventsOperation = new Operation({
+	id: "posthog.capture-batch-events",
+	name: "PostHog Capture Batch",
+	description: "Capture up to 100 analytics events via the PostHog /batch endpoint",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({ events: z.array(z.object({
+		event: z.string().min(1),
+		distinct_id: z.string().min(1),
+		properties: propertiesBagSchema.optional(),
+		timestamp: z.iso.datetime().optional(),
+		uuid: z.string().optional()
+	})).min(1) }),
+	output: captureResponseSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogIngestClient(context.credentials.posthog);
+		return client.request({
+			method: "POST",
+			path: "/batch/",
+			body: {
+				api_key: client.projectApiKey(),
+				batch: input.events
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/capture.ts
+const eventNameInput = {
+	event: z.string().min(1),
+	distinctId: z.string().min(1),
+	timestamp: z.iso.datetime().optional(),
+	uuid: z.string().optional(),
+	properties: propertiesBagSchema.optional()
+};
+
+//#endregion
+//#region src/operations/capture-event.operation.ts
+const captureEventOperation = new Operation({
+	id: "posthog.capture-event",
+	name: "PostHog Capture Event",
+	description: "Capture a single analytics event via the PostHog /capture endpoint",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(eventNameInput),
+	output: captureResponseSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogIngestClient(context.credentials.posthog);
+		return client.request({
+			method: "POST",
+			path: "/capture/",
+			body: {
+				api_key: client.projectApiKey(),
+				event: input.event,
+				distinct_id: input.distinctId,
+				...input.properties ? { properties: input.properties } : {},
+				...input.timestamp ? { timestamp: input.timestamp } : {},
+				...input.uuid ? { uuid: input.uuid } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-activity.operation.ts
+const cohortsActivityOperation = new Operation({
+	id: "posthog.cohorts-activity",
+	name: "PostHog Cohort Activity",
+	description: "Fetch activity log for a cohort",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/cohorts/${input.id}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-create.operation.ts
+const cohortsCreateOperation = new Operation({
+	id: "posthog.cohorts-create",
+	name: "PostHog Create Cohort",
+	description: "Create a new cohort",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		...writeShape$1,
+		name: z.string().min(1)
+	}),
+	output: cohortSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/cohorts/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-delete.operation.ts
+const cohortsDeleteOperation = new Operation({
+	id: "posthog.cohorts-delete",
+	name: "PostHog Delete Cohort",
+	description: "Soft-delete a cohort",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: cohortSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/cohorts/${input.id}/`,
+			body: { deleted: true }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-duplicate-as-static.operation.ts
+const cohortsDuplicateAsStaticOperation = new Operation({
+	id: "posthog.cohorts-duplicate-as-static",
+	name: "PostHog Duplicate Cohort As Static",
+	description: "Duplicate a cohort as a static cohort",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: cohortSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/cohorts/${input.id}/duplicate_as_static_cohort/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-get.operation.ts
+const cohortsGetOperation = new Operation({
+	id: "posthog.cohorts-get",
+	name: "PostHog Get Cohort",
+	description: "Retrieve a cohort by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: cohortSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/cohorts/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-list.operation.ts
+const cohortsListOperation = new Operation({
+	id: "posthog.cohorts-list",
+	name: "PostHog List Cohorts",
+	description: "List cohorts in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional()
+	}),
+	output: paginatedResponseSchema(cohortSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/cohorts/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-persons.operation.ts
+const cohortsPersonsOperation = new Operation({
+	id: "posthog.cohorts-persons",
+	name: "PostHog List Cohort Persons",
+	description: "List persons in a cohort",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: paginatedResponseSchema(personSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/cohorts/${input.id}/persons/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/cohorts-update.operation.ts
+const cohortsUpdateOperation = new Operation({
+	id: "posthog.cohorts-update",
+	name: "PostHog Update Cohort",
+	description: "Partial update to a cohort",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		...writeShape$1
+	}),
+	output: cohortSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/cohorts/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboard-templates-create.operation.ts
+const dashboardTemplatesCreateOperation = new Operation({
+	id: "posthog.dashboard-templates-create",
+	name: "PostHog Create Dashboard Template",
+	description: "Create a dashboard template from a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		template_name: z.string().min(1),
+		dashboard_description: z.string().nullable().optional(),
+		dashboard_filters: z.record(z.string(), z.unknown()).nullable().optional(),
+		tags: z.array(z.string()).optional(),
+		tiles: z.array(z.record(z.string(), z.unknown())).optional()
+	}),
+	output: dashboardTemplateSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/dashboard_templates/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboard-templates-delete.operation.ts
+const dashboardTemplatesDeleteOperation = new Operation({
+	id: "posthog.dashboard-templates-delete",
+	name: "PostHog Delete Dashboard Template",
+	description: "Delete a dashboard template",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		templateId: z.string().min(1)
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/dashboard_templates/${input.templateId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/dashboard-templates-get.operation.ts
+const dashboardTemplatesGetOperation = new Operation({
+	id: "posthog.dashboard-templates-get",
+	name: "PostHog Get Dashboard Template",
+	description: "Retrieve a dashboard template by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		templateId: z.string().min(1)
+	}),
+	output: dashboardTemplateSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/dashboard_templates/${input.templateId}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboard-templates-list.operation.ts
+const dashboardTemplatesListOperation = new Operation({
+	id: "posthog.dashboard-templates-list",
+	name: "PostHog List Dashboard Templates",
+	description: "List dashboard templates available in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(200).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: paginatedResponseSchema(dashboardTemplateSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/dashboard_templates/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboard-templates-update.operation.ts
+const dashboardTemplatesUpdateOperation = new Operation({
+	id: "posthog.dashboard-templates-update",
+	name: "PostHog Update Dashboard Template",
+	description: "Partial update to a dashboard template",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		templateId: z.string().min(1),
+		template_name: z.string().optional(),
+		dashboard_description: z.string().nullable().optional(),
+		dashboard_filters: z.record(z.string(), z.unknown()).nullable().optional(),
+		tags: z.array(z.string()).optional(),
+		tiles: z.array(z.record(z.string(), z.unknown())).optional(),
+		deleted: z.boolean().optional()
+	}),
+	output: dashboardTemplateSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, templateId, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/dashboard_templates/${templateId}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-activity.operation.ts
+const dashboardsActivityOperation = new Operation({
+	id: "posthog.dashboards-activity",
+	name: "PostHog Dashboard Activity",
+	description: "Fetch activity log for a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-collaborators-add.operation.ts
+const dashboardsCollaboratorsAddOperation = new Operation({
+	id: "posthog.dashboards-collaborators-add",
+	name: "PostHog Add Dashboard Collaborator",
+	description: "Add a collaborator to a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		user_uuid: z.string().min(1),
+		access_level: z.enum(["can_view", "can_edit"]).default("can_view")
+	}),
+	output: dashboardCollaboratorSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/collaborators/`,
+			body: {
+				user_uuid: input.user_uuid,
+				level: input.access_level
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-collaborators-list.operation.ts
+const dashboardsCollaboratorsListOperation = new Operation({
+	id: "posthog.dashboards-collaborators-list",
+	name: "PostHog List Dashboard Collaborators",
+	description: "List collaborators on a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: paginatedResponseSchema(dashboardCollaboratorSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/collaborators/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-collaborators-remove.operation.ts
+const dashboardsCollaboratorsRemoveOperation = new Operation({
+	id: "posthog.dashboards-collaborators-remove",
+	name: "PostHog Remove Dashboard Collaborator",
+	description: "Remove a collaborator from a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		collaboratorId: z.number().int()
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/collaborators/${input.collaboratorId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-create.operation.ts
+const dashboardsCreateOperation = new Operation({
+	id: "posthog.dashboards-create",
+	name: "PostHog Create Dashboard",
+	description: "Create a new dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		...writeShape$1,
+		name: z.string().min(1)
+	}),
+	output: dashboardSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/dashboards/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-delete.operation.ts
+const dashboardsDeleteOperation = new Operation({
+	id: "posthog.dashboards-delete",
+	name: "PostHog Delete Dashboard",
+	description: "Soft-delete a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: dashboardSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/`,
+			body: { deleted: true }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-get.operation.ts
+const dashboardsGetOperation = new Operation({
+	id: "posthog.dashboards-get",
+	name: "PostHog Get Dashboard",
+	description: "Retrieve a dashboard by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: dashboardSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-list.operation.ts
+const dashboardsListOperation = new Operation({
+	id: "posthog.dashboards-list",
+	name: "PostHog List Dashboards",
+	description: "List dashboards in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional(),
+		pinned: z.boolean().optional()
+	}),
+	output: paginatedResponseSchema(dashboardSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/dashboards/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search,
+				pinned: input.pinned
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-sharing-get.operation.ts
+const dashboardsSharingGetOperation = new Operation({
+	id: "posthog.dashboards-sharing-get",
+	name: "PostHog Get Dashboard Sharing",
+	description: "Fetch sharing configuration for a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: sharingConfigurationSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/sharing/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-sharing-update.operation.ts
+const dashboardsSharingUpdateOperation = new Operation({
+	id: "posthog.dashboards-sharing-update",
+	name: "PostHog Update Dashboard Sharing",
+	description: "Enable or disable sharing for a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		enabled: z.boolean()
+	}),
+	output: sharingConfigurationSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/dashboards/${input.id}/sharing/`,
+			body: { enabled: input.enabled }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/dashboards-update.operation.ts
+const dashboardsUpdateOperation = new Operation({
+	id: "posthog.dashboards-update",
+	name: "PostHog Update Dashboard",
+	description: "Partial update to a dashboard",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		...writeShape$1
+	}),
+	output: dashboardSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/dashboards/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/decide-feature-flags.operation.ts
+const decideFeatureFlagsOperation = new Operation({
+	id: "posthog.decide-feature-flags",
+	name: "PostHog Decide Feature Flags",
+	description: "Evaluate all feature flags for a distinct_id via the /decide endpoint",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		distinctId: z.string().min(1),
+		personProperties: propertiesBagSchema.optional(),
+		groups: z.record(z.string(), z.string()).optional(),
+		groupProperties: z.record(z.string(), propertiesBagSchema).optional(),
+		version: z.number().int().min(1).default(3)
+	}),
+	output: decideResponseSchema,
+	run: async (input, context) => {
+		const client = createPosthogDecideClient(context.credentials.posthog);
+		return client.request({
+			method: "POST",
+			path: "/decide/",
+			query: { v: input.version },
+			body: {
+				api_key: client.projectApiKey(),
+				distinct_id: input.distinctId,
+				...input.personProperties ? { person_properties: input.personProperties } : {},
+				...input.groups ? { groups: input.groups } : {},
+				...input.groupProperties ? { group_properties: input.groupProperties } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/decide-feature-flags-local.operation.ts
+const decideFeatureFlagsLocalOperation = new Operation({
+	id: "posthog.decide-feature-flags-local",
+	name: "PostHog Local Evaluation Payload",
+	description: "Fetch the local-evaluation payload for all feature flags in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		projectId: z.union([z.string(), z.number().int()]).optional(),
+		sendCohorts: z.boolean().default(true)
+	}),
+	output: localEvaluationResponseSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/local_evaluation/`,
+			query: { send_cohorts: input.sendCohorts }
+		});
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/events-management.ts
+const eventDefIdInput = {
+	...projectIdInputShape,
+	id: z.string().min(1)
+};
+
+//#endregion
+//#region src/operations/event-definitions-delete.operation.ts
+const eventDefinitionsDeleteOperation = new Operation({
+	id: "posthog.event-definitions-delete",
+	name: "PostHog Delete Event Definition",
+	description: "Delete an event definition",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(eventDefIdInput),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/event_definitions/${input.id}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/event-definitions-get.operation.ts
+const eventDefinitionsGetOperation = new Operation({
+	id: "posthog.event-definitions-get",
+	name: "PostHog Get Event Definition",
+	description: "Retrieve an event definition by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(eventDefIdInput),
+	output: eventDefinitionSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/event_definitions/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/event-definitions-list.operation.ts
+const eventDefinitionsListOperation = new Operation({
+	id: "posthog.event-definitions-list",
+	name: "PostHog List Event Definitions",
+	description: "List event definitions (the schema for captured events)",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional()
+	}),
+	output: paginatedResponseSchema(eventDefinitionSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/event_definitions/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/event-definitions-update.operation.ts
+const eventDefinitionsUpdateOperation = new Operation({
+	id: "posthog.event-definitions-update",
+	name: "PostHog Update Event Definition",
+	description: "Update description, owner, tags, or verified status on an event definition",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...eventDefIdInput,
+		description: z.string().nullable().optional(),
+		owner: z.number().int().nullable().optional(),
+		tags: z.array(z.string()).optional(),
+		verified: z.boolean().optional()
+	}),
+	output: eventDefinitionSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/event_definitions/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/events-get.operation.ts
+const eventsGetOperation = new Operation({
+	id: "posthog.events-get",
+	name: "PostHog Get Event",
+	description: "Retrieve a single event by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		id: z.string().min(1)
+	}),
+	output: analyticsEventSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/events/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/events-list.operation.ts
+const eventsListOperation = new Operation({
+	id: "posthog.events-list",
+	name: "PostHog List Events",
+	description: "Query captured events",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(1e3).optional(),
+		offset: z.number().int().min(0).optional(),
+		event: z.string().optional(),
+		distinct_id: z.string().optional(),
+		after: z.iso.datetime().optional(),
+		before: z.iso.datetime().optional(),
+		person_id: z.union([z.string(), z.number().int()]).optional()
+	}),
+	output: paginatedResponseSchema(analyticsEventSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/events/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				event: input.event,
+				distinct_id: input.distinct_id,
+				after: input.after,
+				before: input.before,
+				person_id: input.person_id
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/events-values.operation.ts
+const eventsValuesOperation = new Operation({
+	id: "posthog.events-values",
+	name: "PostHog Event Property Values",
+	description: "Fetch distinct values for an event property",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		key: z.string().min(1),
+		value: z.string().optional()
+	}),
+	output: z.array(z.record(z.string(), z.unknown())),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/events/values/`,
+			query: {
+				key: input.key,
+				value: input.value
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-activity.operation.ts
+const featureFlagsActivityOperation = new Operation({
+	id: "posthog.feature-flags-activity",
+	name: "PostHog Feature Flag Activity",
+	description: "Fetch activity log for a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/feature-flags.ts
+const idInput$2 = {
+	...projectIdInputShape,
+	id: z.number().int()
+};
+const flagWriteShape = {
+	key: z.string().min(1),
+	name: z.string().optional(),
+	filters: featureFlagFiltersSchema.optional(),
+	active: z.boolean().optional(),
+	deleted: z.boolean().optional(),
+	rollout_percentage: z.number().nullable().optional(),
+	ensure_experience_continuity: z.boolean().optional(),
+	tags: z.array(z.string()).optional()
+};
+const listInput = z.object({
+	...projectIdInputShape,
+	limit: z.number().int().min(1).max(500).optional(),
+	offset: z.number().int().min(0).optional(),
+	active: z.boolean().optional(),
+	search: z.string().optional(),
+	type: z.string().optional(),
+	created_by: z.number().int().optional()
+});
+const listOutput = paginatedResponseSchema(featureFlagSchema);
+
+//#endregion
+//#region src/operations/feature-flags-create.operation.ts
+const featureFlagsCreateOperation = new Operation({
+	id: "posthog.feature-flags-create",
+	name: "PostHog Create Feature Flag",
+	description: "Create a new feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		...flagWriteShape
+	}),
+	output: featureFlagSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _ignored, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/feature_flags/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-dashboards.operation.ts
+const featureFlagsDashboardsOperation = new Operation({
+	id: "posthog.feature-flags-dashboards",
+	name: "PostHog Feature Flag Dashboards",
+	description: "Fetch dashboards linked to a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/dashboards/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-delete.operation.ts
+const featureFlagsDeleteOperation = new Operation({
+	id: "posthog.feature-flags-delete",
+	name: "PostHog Delete Feature Flag",
+	description: "Soft-delete a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: featureFlagSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/`,
+			body: { deleted: true }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-disable.operation.ts
+const featureFlagsDisableOperation = new Operation({
+	id: "posthog.feature-flags-disable",
+	name: "PostHog Disable Feature Flag",
+	description: "Deactivate a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: featureFlagSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/`,
+			body: { active: false }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-enable.operation.ts
+const featureFlagsEnableOperation = new Operation({
+	id: "posthog.feature-flags-enable",
+	name: "PostHog Enable Feature Flag",
+	description: "Activate a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: featureFlagSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/`,
+			body: { active: true }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-get.operation.ts
+const featureFlagsGetOperation = new Operation({
+	id: "posthog.feature-flags-get",
+	name: "PostHog Get Feature Flag",
+	description: "Retrieve a feature flag by numeric id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: featureFlagSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-list.operation.ts
+const featureFlagsListOperation = new Operation({
+	id: "posthog.feature-flags-list",
+	name: "PostHog List Feature Flags",
+	description: "List feature flags for a project",
+	credentialSets: [posthogCredentialSet],
+	input: listInput,
+	output: listOutput,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				active: input.active,
+				search: input.search,
+				type: input.type,
+				created_by: input.created_by
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-my-flags.operation.ts
+const featureFlagsMyFlagsOperation = new Operation({
+	id: "posthog.feature-flags-my-flags",
+	name: "PostHog My Feature Flags",
+	description: "Fetch the feature flags evaluated for the calling user",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(projectIdInputShape),
+	output: z.array(z.record(z.string(), z.unknown())),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/my_flags/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-remote-config.operation.ts
+const featureFlagsRemoteConfigOperation = new Operation({
+	id: "posthog.feature-flags-remote-config",
+	name: "PostHog Feature Flag Remote Config",
+	description: "Fetch the remote-config payload for a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		distinctId: z.string().min(1)
+	}),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/remote_config/`,
+			query: { distinct_id: input.distinctId }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-role-access-create.operation.ts
+const featureFlagsRoleAccessCreateOperation = new Operation({
+	id: "posthog.feature-flags-role-access-create",
+	name: "PostHog Create Feature Flag Role Access",
+	description: "Grant a role access to a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		role: z.number().int()
+	}),
+	output: featureFlagRoleAccessSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/role_access/`,
+			body: { role: input.role }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-role-access-delete.operation.ts
+const featureFlagsRoleAccessDeleteOperation = new Operation({
+	id: "posthog.feature-flags-role-access-delete",
+	name: "PostHog Delete Feature Flag Role Access",
+	description: "Revoke a role access rule for a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		roleAccessId: z.number().int()
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/role_access/${input.roleAccessId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-role-access-list.operation.ts
+const featureFlagsRoleAccessListOperation = new Operation({
+	id: "posthog.feature-flags-role-access-list",
+	name: "PostHog List Feature Flag Role Access",
+	description: "List role access rules for a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: paginatedResponseSchema(featureFlagRoleAccessSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/role_access/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-status.operation.ts
+const featureFlagsStatusOperation = new Operation({
+	id: "posthog.feature-flags-status",
+	name: "PostHog Feature Flag Status",
+	description: "Fetch computed status summary for a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/${input.id}/status/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/feature-flags-update.operation.ts
+const featureFlagsUpdateOperation = new Operation({
+	id: "posthog.feature-flags-update",
+	name: "PostHog Update Feature Flag",
+	description: "Partially update a feature flag",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		key: z.string().min(1).optional(),
+		name: z.string().optional(),
+		filters: featureFlagFiltersSchema.optional(),
+		active: z.boolean().optional(),
+		deleted: z.boolean().optional(),
+		rollout_percentage: z.number().nullable().optional(),
+		ensure_experience_continuity: z.boolean().optional(),
+		tags: z.array(z.string()).optional()
+	}),
+	output: featureFlagSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/feature_flags/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/group-identify.operation.ts
+const groupIdentifyOperation = new Operation({
+	id: "posthog.group-identify",
+	name: "PostHog Group Identify",
+	description: "Attach properties to a group (organization, project, etc.) via $groupidentify",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		distinctId: z.string().min(1),
+		groupType: z.string().min(1),
+		groupKey: z.string().min(1),
+		groupProperties: propertiesBagSchema.optional(),
+		timestamp: z.iso.datetime().optional()
+	}),
+	output: captureResponseSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogIngestClient(context.credentials.posthog);
+		return client.request({
+			method: "POST",
+			path: "/capture/",
+			body: {
+				api_key: client.projectApiKey(),
+				event: "$groupidentify",
+				distinct_id: input.distinctId,
+				properties: {
+					$group_type: input.groupType,
+					$group_key: input.groupKey,
+					$group_set: input.groupProperties ?? {}
+				},
+				...input.timestamp ? { timestamp: input.timestamp } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/identify-person.operation.ts
+const identifyPersonOperation = new Operation({
+	id: "posthog.identify-person",
+	name: "PostHog Identify Person",
+	description: "Associate a distinct_id with person properties via a $identify event",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		distinctId: z.string().min(1),
+		properties: propertiesBagSchema.optional(),
+		propertiesOnce: propertiesBagSchema.optional(),
+		timestamp: z.iso.datetime().optional()
+	}),
+	output: captureResponseSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogIngestClient(context.credentials.posthog);
+		const properties = {};
+		if (input.properties) properties.$set = input.properties;
+		if (input.propertiesOnce) properties.$set_once = input.propertiesOnce;
+		return client.request({
+			method: "POST",
+			path: "/capture/",
+			body: {
+				api_key: client.projectApiKey(),
+				event: "$identify",
+				distinct_id: input.distinctId,
+				properties,
+				...input.timestamp ? { timestamp: input.timestamp } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-activity.operation.ts
+const insightsActivityOperation = new Operation({
+	id: "posthog.insights-activity",
+	name: "PostHog Insight Activity",
+	description: "Fetch activity log for an insight",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/insights/${input.id}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-activity-feed.operation.ts
+const insightsActivityFeedOperation = new Operation({
+	id: "posthog.insights-activity-feed",
+	name: "PostHog Insights Activity Feed",
+	description: "Fetch the project-wide insights activity feed",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/insights/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-create.operation.ts
+const insightsCreateOperation = new Operation({
+	id: "posthog.insights-create",
+	name: "PostHog Create Insight",
+	description: "Create a new insight",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		...writeShape$1
+	}),
+	output: insightSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/insights/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-delete.operation.ts
+const insightsDeleteOperation = new Operation({
+	id: "posthog.insights-delete",
+	name: "PostHog Delete Insight",
+	description: "Soft-delete an insight",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: insightSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/insights/${input.id}/`,
+			body: { deleted: true }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-funnel.operation.ts
+const insightsFunnelOperation = new Operation({
+	id: "posthog.insights-funnel",
+	name: "PostHog Insight Funnel",
+	description: "Execute a funnel query",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		query: z.record(z.string(), z.unknown())
+	}),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/insights/funnel/`,
+			body: input.query
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-get.operation.ts
+const insightsGetOperation = new Operation({
+	id: "posthog.insights-get",
+	name: "PostHog Get Insight",
+	description: "Retrieve a single insight by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: insightSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/insights/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-list.operation.ts
+const insightsListOperation = new Operation({
+	id: "posthog.insights-list",
+	name: "PostHog List Insights",
+	description: "List insights in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional(),
+		favorited: z.boolean().optional(),
+		saved: z.boolean().optional(),
+		created_by: z.number().int().optional(),
+		dashboards: z.array(z.number().int()).optional()
+	}),
+	output: paginatedResponseSchema(insightSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/insights/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search,
+				favorited: input.favorited,
+				saved: input.saved,
+				created_by: input.created_by,
+				...input.dashboards ? { dashboards: input.dashboards.join(",") } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-my-insights.operation.ts
+const insightsMyInsightsOperation = new Operation({
+	id: "posthog.insights-my-insights",
+	name: "PostHog My Insights",
+	description: "Fetch insights owned by the calling user",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional()
+	}),
+	output: paginatedResponseSchema(insightSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/insights/my_last_viewed/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-path.operation.ts
+const insightsPathOperation = new Operation({
+	id: "posthog.insights-path",
+	name: "PostHog Insight Path",
+	description: "Execute a user-path query",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		query: z.record(z.string(), z.unknown())
+	}),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/insights/path/`,
+			body: input.query
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-retention.operation.ts
+const insightsRetentionOperation = new Operation({
+	id: "posthog.insights-retention",
+	name: "PostHog Insight Retention",
+	description: "Fetch retention report for an insight/query combination",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		query: z.record(z.string(), z.unknown())
+	}),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/insights/retention/`,
+			body: input.query
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-sharing-get.operation.ts
+const insightsSharingGetOperation = new Operation({
+	id: "posthog.insights-sharing-get",
+	name: "PostHog Get Insight Sharing",
+	description: "Fetch sharing configuration for an insight",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: sharingConfigurationSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/insights/${input.id}/sharing/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-sharing-update.operation.ts
+const insightsSharingUpdateOperation = new Operation({
+	id: "posthog.insights-sharing-update",
+	name: "PostHog Update Insight Sharing",
+	description: "Enable or disable sharing for an insight",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		enabled: z.boolean()
+	}),
+	output: sharingConfigurationSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/insights/${input.id}/sharing/`,
+			body: { enabled: input.enabled }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-trend.operation.ts
+const insightsTrendOperation = new Operation({
+	id: "posthog.insights-trend",
+	name: "PostHog Execute Insight Query",
+	description: "Execute an ad-hoc trend/funnel/retention/etc. query",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		query: z.record(z.string(), z.unknown()),
+		refresh: z.boolean().optional()
+	}),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/query/`,
+			body: {
+				query: input.query,
+				refresh: input.refresh ?? false
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-trend-chart.operation.ts
+const insightsTrendChartOperation = new Operation({
+	id: "posthog.insights-trend-chart",
+	name: "PostHog Insight Trend",
+	description: "Execute a trend query",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		query: z.record(z.string(), z.unknown())
+	}),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/insights/trend/`,
+			body: input.query
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-update.operation.ts
+const insightsUpdateOperation = new Operation({
+	id: "posthog.insights-update",
+	name: "PostHog Update Insight",
+	description: "Partial update to an insight",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		...writeShape$1
+	}),
+	output: insightSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/insights/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/insights-viewed.operation.ts
+const insightsViewedOperation = new Operation({
+	id: "posthog.insights-viewed",
+	name: "PostHog Mark Insight Viewed",
+	description: "Record that the calling user viewed an insight",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/insights/${input.id}/viewed/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/organizations.ts
+const orgInput = { organizationId: z.string().min(1) };
+
+//#endregion
+//#region src/operations/organization-invites-create.operation.ts
+const organizationInvitesCreateOperation = new Operation({
+	id: "posthog.organization-invites-create",
+	name: "PostHog Create Organization Invite",
+	description: "Invite a user to an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		target_email: z.email(),
+		level: z.number().int().optional(),
+		first_name: z.string().optional()
+	}),
+	output: z.record(z.string(), z.unknown()),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const { organizationId, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/organizations/${organizationId}/invites/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/organization-invites-delete.operation.ts
+const organizationInvitesDeleteOperation = new Operation({
+	id: "posthog.organization-invites-delete",
+	name: "PostHog Delete Organization Invite",
+	description: "Revoke an organization invite",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		inviteId: z.string().min(1)
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		await createPosthogManagementClient(context.credentials.posthog).request({
+			method: "DELETE",
+			path: `/api/organizations/${input.organizationId}/invites/${input.inviteId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/organization-invites-list.operation.ts
+const organizationInvitesListOperation = new Operation({
+	id: "posthog.organization-invites-list",
+	name: "PostHog List Organization Invites",
+	description: "List outstanding invites for an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: paginatedResponseSchema(z.record(z.string(), z.unknown())),
+	run: async (input, context) => {
+		return createPosthogManagementClient(context.credentials.posthog).request({
+			method: "GET",
+			path: `/api/organizations/${input.organizationId}/invites/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/organization-members-list.operation.ts
+const organizationMembersListOperation = new Operation({
+	id: "posthog.organization-members-list",
+	name: "PostHog List Organization Members",
+	description: "List members of an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		limit: z.number().int().min(1).max(200).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: paginatedResponseSchema(projectMemberSchema),
+	run: async (input, context) => {
+		return createPosthogManagementClient(context.credentials.posthog).request({
+			method: "GET",
+			path: `/api/organizations/${input.organizationId}/members/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/organization-members-remove.operation.ts
+const organizationMembersRemoveOperation = new Operation({
+	id: "posthog.organization-members-remove",
+	name: "PostHog Remove Organization Member",
+	description: "Remove a user from an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		userUuid: z.string().min(1)
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		await createPosthogManagementClient(context.credentials.posthog).request({
+			method: "DELETE",
+			path: `/api/organizations/${input.organizationId}/members/${input.userUuid}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/organization-members-update.operation.ts
+const organizationMembersUpdateOperation = new Operation({
+	credentialSets: [posthogCredentialSet],
+	id: "posthog.organization-members-update",
+	name: "PostHog Update Organization Member",
+	description: "Update an organization member's role",
+	input: z.object({
+		...orgInput,
+		userUuid: z.string().min(1),
+		level: z.number().int()
+	}),
+	output: projectMemberSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		return createPosthogManagementClient(context.credentials.posthog).request({
+			method: "PATCH",
+			path: `/api/organizations/${input.organizationId}/members/${input.userUuid}/`,
+			body: { level: input.level }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/organizations-create.operation.ts
+const organizationsCreateOperation = new Operation({
+	id: "posthog.organizations-create",
+	name: "PostHog Create Organization",
+	description: "Create a new organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		name: z.string().min(1),
+		slug: z.string().optional()
+	}),
+	output: organizationSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		return createPosthogManagementClient(context.credentials.posthog).request({
+			method: "POST",
+			path: "/api/organizations/",
+			body: input
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/organizations-delete.operation.ts
+const organizationsDeleteOperation = new Operation({
+	id: "posthog.organizations-delete",
+	name: "PostHog Delete Organization",
+	description: "Delete an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(orgInput),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		await createPosthogManagementClient(context.credentials.posthog).request({
+			method: "DELETE",
+			path: `/api/organizations/${input.organizationId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/organizations-get.operation.ts
+const organizationsGetOperation = new Operation({
+	id: "posthog.organizations-get",
+	name: "PostHog Get Organization",
+	description: "Retrieve an organization by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(orgInput),
+	output: organizationSchema,
+	run: async (input, context) => {
+		return createPosthogManagementClient(context.credentials.posthog).request({
+			method: "GET",
+			path: `/api/organizations/${input.organizationId}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/organizations-list.operation.ts
+const organizationsListOperation = new Operation({
+	id: "posthog.organizations-list",
+	name: "PostHog List Organizations",
+	description: "List organizations the personal API key can access",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		limit: z.number().int().min(1).max(200).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: paginatedResponseSchema(organizationSchema),
+	run: async (input, context) => {
+		return createPosthogManagementClient(context.credentials.posthog).request({
+			method: "GET",
+			path: "/api/organizations/",
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/organizations-update.operation.ts
+const organizationsUpdateOperation = new Operation({
+	id: "posthog.organizations-update",
+	name: "PostHog Update Organization",
+	description: "Partial update to an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		name: z.string().optional(),
+		slug: z.string().optional()
+	}),
+	output: organizationSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const { organizationId, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/organizations/${organizationId}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-activity.operation.ts
+const personsActivityOperation = new Operation({
+	id: "posthog.persons-activity",
+	name: "PostHog Person Activity",
+	description: "Fetch recent activity for a person",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/persons/${input.id}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-activity-feed.operation.ts
+const personsActivityFeedOperation = new Operation({
+	id: "posthog.persons-activity-feed",
+	name: "PostHog Persons Activity Feed",
+	description: "Fetch the project-wide persons activity feed",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/persons/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-delete.operation.ts
+const personsDeleteOperation = new Operation({
+	id: "posthog.persons-delete",
+	name: "PostHog Delete Person",
+	description: "Delete a person and optionally their associated events",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		delete_events: z.boolean().optional()
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/persons/${input.id}/`,
+			query: input.delete_events !== void 0 ? { delete_events: input.delete_events } : void 0
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/persons-delete-property.operation.ts
+const personsDeletePropertyOperation = new Operation({
+	id: "posthog.persons-delete-property",
+	name: "PostHog Delete Person Property",
+	description: "Remove a single property from a person",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		key: z.string().min(1)
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/persons/${input.id}/delete_property/`,
+			body: { $unset: input.key }
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/persons.ts
+const idInput$1 = {
+	...projectIdInputShape,
+	id: z.union([z.number().int(), z.string()])
+};
+const listSchema = paginatedResponseSchema(personSchema);
+
+//#endregion
+//#region src/operations/persons-funnel.operation.ts
+const personsFunnelOperation = new Operation({
+	id: "posthog.persons-funnel",
+	name: "PostHog Persons Funnel",
+	description: "Fetch persons dropping through a funnel",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		filter: z.record(z.string(), z.unknown()),
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: listSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/persons/funnel/`,
+			body: input.filter,
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-get.operation.ts
+const personsGetOperation = new Operation({
+	id: "posthog.persons-get",
+	name: "PostHog Get Person",
+	description: "Retrieve a single person by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: personSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/persons/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-lifecycle.operation.ts
+const personsLifecycleOperation = new Operation({
+	id: "posthog.persons-lifecycle",
+	name: "PostHog Persons Lifecycle",
+	description: "Fetch persons matching a lifecycle query",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		filter: z.record(z.string(), z.unknown()),
+		limit: z.number().int().min(1).max(500).optional()
+	}),
+	output: listSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/persons/lifecycle/`,
+			body: input.filter,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-list.operation.ts
+const personsListOperation = new Operation({
+	id: "posthog.persons-list",
+	name: "PostHog List Persons",
+	description: "List persons with optional search, email, or distinct-id filters",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional(),
+		distinct_id: z.string().optional(),
+		email: z.email().optional(),
+		properties: z.array(z.record(z.string(), z.unknown())).optional()
+	}),
+	output: listSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/persons/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search,
+				distinct_id: input.distinct_id,
+				email: input.email,
+				...input.properties ? { properties: JSON.stringify(input.properties) } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-merge.operation.ts
+const personsMergeOperation = new Operation({
+	id: "posthog.persons-merge",
+	name: "PostHog Merge Persons",
+	description: "Merge two persons together (destination receives events from source)",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		source_id: z.union([z.number().int(), z.string()])
+	}),
+	output: personSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/persons/${input.id}/merge/`,
+			body: { ids: [input.source_id] }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-reset-name.operation.ts
+const personsResetNameOperation = new Operation({
+	id: "posthog.persons-reset-name",
+	name: "PostHog Reset Person Name",
+	description: "Reset a person displayed-name override",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: personSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/persons/${input.id}/reset_name/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-split.operation.ts
+const personsSplitOperation = new Operation({
+	id: "posthog.persons-split",
+	name: "PostHog Split Person",
+	description: "Split a person by separating their distinct_ids",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		main_distinct_id: z.string().optional()
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/persons/${input.id}/split/`,
+			body: input.main_distinct_id ? { main_distinct_id: input.main_distinct_id } : {}
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/persons-trends.operation.ts
+const personsTrendsOperation = new Operation({
+	id: "posthog.persons-trends",
+	name: "PostHog Persons Trends",
+	description: "Fetch persons matching a trend query",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		filter: z.record(z.string(), z.unknown()),
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: listSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/persons/trends/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				...Object.fromEntries(Object.entries(input.filter).map(([k, v]) => [k, typeof v === "string" ? v : JSON.stringify(v)]))
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-update.operation.ts
+const personsUpdateOperation = new Operation({
+	id: "posthog.persons-update",
+	name: "PostHog Update Person",
+	description: "Update a person (partial update)",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		properties: propertiesBagSchema.optional(),
+		name: z.string().optional()
+	}),
+	output: personSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/persons/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-update-property.operation.ts
+const personsUpdatePropertyOperation = new Operation({
+	id: "posthog.persons-update-property",
+	name: "PostHog Update Person Property",
+	description: "Set a single property on a person",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		key: z.string().min(1),
+		value: z.unknown()
+	}),
+	output: personSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/persons/${input.id}/update_property/`,
+			body: {
+				key: input.key,
+				value: input.value
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/persons-values.operation.ts
+const personsValuesOperation = new Operation({
+	id: "posthog.persons-values",
+	name: "PostHog Person Property Values",
+	description: "Fetch distinct values for a person property",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		key: z.string().min(1),
+		value: z.string().optional()
+	}),
+	output: z.array(z.record(z.string(), z.unknown())),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/persons/values/`,
+			query: {
+				key: input.key,
+				value: input.value
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/pipeline-destinations-create.operation.ts
+const pipelineDestinationsCreateOperation = new Operation({
+	id: "posthog.pipeline-destinations-create",
+	name: "PostHog Create Pipeline Destination",
+	description: "Configure a pipeline destination plugin (e.g. webhook delivery)",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		plugin: z.number().int(),
+		enabled: z.boolean().default(true),
+		order: z.number().int().optional(),
+		config: z.record(z.string(), z.unknown())
+	}),
+	output: z.record(z.string(), z.unknown()),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/plugin_configs/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/pipeline-destinations-delete.operation.ts
+const pipelineDestinationsDeleteOperation = new Operation({
+	id: "posthog.pipeline-destinations-delete",
+	name: "PostHog Delete Pipeline Destination",
+	description: "Remove a pipeline destination configuration",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		pluginConfigId: z.number().int()
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/plugin_configs/${input.pluginConfigId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/pipeline-destinations-list.operation.ts
+const pipelineDestinationsListOperation = new Operation({
+	id: "posthog.pipeline-destinations-list",
+	name: "PostHog List Pipeline Destinations",
+	description: "List configured pipeline destinations (plugin-configs)",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional()
+	}),
+	output: paginatedResponseSchema(z.record(z.string(), z.unknown())),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/plugin_configs/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/projects.ts
+const projectIdInput = { projectId: z.union([z.string(), z.number().int()]).optional() };
+const memberIdInput = {
+	...projectIdInput,
+	memberId: z.number().int()
+};
+const writeShape = {
+	name: z.string().optional(),
+	slack_incoming_webhook: z.string().nullable().optional(),
+	anonymize_ips: z.boolean().optional(),
+	completed_snippet_onboarding: z.boolean().optional(),
+	test_account_filters: z.array(z.record(z.string(), z.unknown())).optional(),
+	timezone: z.string().optional(),
+	access_control: z.boolean().optional(),
+	app_urls: z.array(z.string()).optional(),
+	session_recording_opt_in: z.boolean().optional(),
+	autocapture_opt_out: z.boolean().optional()
+};
+
+//#endregion
+//#region src/operations/project-members-add.operation.ts
+const projectMembersAddOperation = new Operation({
+	id: "posthog.project-members-add",
+	name: "PostHog Add Project Member",
+	description: "Add a user to a project with a given access level",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInput,
+		user_uuid: z.string().min(1),
+		level: z.number().int()
+	}),
+	output: projectMemberSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/explicit_members/`,
+			body: {
+				user_uuid: input.user_uuid,
+				level: input.level
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/project-members-list.operation.ts
+const projectMembersListOperation = new Operation({
+	id: "posthog.project-members-list",
+	name: "PostHog List Project Members",
+	description: "List members of a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInput,
+		limit: z.number().int().min(1).max(200).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: paginatedResponseSchema(projectMemberSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/explicit_members/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/project-members-remove.operation.ts
+const projectMembersRemoveOperation = new Operation({
+	id: "posthog.project-members-remove",
+	name: "PostHog Remove Project Member",
+	description: "Remove a user from a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(memberIdInput),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/explicit_members/${input.memberId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/project-members-update.operation.ts
+const projectMembersUpdateOperation = new Operation({
+	credentialSets: [posthogCredentialSet],
+	id: "posthog.project-members-update",
+	name: "PostHog Update Project Member",
+	description: "Update a project member's access level",
+	input: z.object({
+		...memberIdInput,
+		level: z.number().int()
+	}),
+	output: projectMemberSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/explicit_members/${input.memberId}/`,
+			body: { level: input.level }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-activity.operation.ts
+const projectsActivityOperation = new Operation({
+	id: "posthog.projects-activity",
+	name: "PostHog Project Activity",
+	description: "Fetch the project-level activity feed",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInput,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-add-user-integration.operation.ts
+const projectsAddUserIntegrationOperation = new Operation({
+	id: "posthog.projects-add-user-integration",
+	name: "PostHog Add Project User Integration",
+	description: "Attach arbitrary user-integration properties to a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInput,
+		properties: propertiesBagSchema
+	}),
+	output: z.record(z.string(), z.unknown()),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/add_user_interaction/`,
+			body: input.properties
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-create.operation.ts
+const projectsCreateOperation = new Operation({
+	id: "posthog.projects-create",
+	name: "PostHog Create Project",
+	description: "Create a new project in an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		...writeShape$1,
+		name: z.string().min(1)
+	}),
+	output: projectSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const { organizationId, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/organizations/${organizationId}/projects/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-delete.operation.ts
+const projectsDeleteOperation = new Operation({
+	id: "posthog.projects-delete",
+	name: "PostHog Delete Project",
+	description: "Delete a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(projectIdInput),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/projects-get.operation.ts
+const projectsGetOperation = new Operation({
+	id: "posthog.projects-get",
+	name: "PostHog Get Project",
+	description: "Retrieve a project by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(projectIdInput),
+	output: projectSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-is-generic-email-provider.operation.ts
+const projectsIsGenericEmailProviderOperation = new Operation({
+	id: "posthog.projects-is-generic-email-provider",
+	name: "PostHog Check Generic Email",
+	description: "Check if an email domain is a generic provider",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInput,
+		email: z.email()
+	}),
+	output: z.object({ is_generic_email_provider: z.boolean() }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/is_generic_email_provider/`,
+			query: { email: input.email }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-list.operation.ts
+const projectsListOperation = new Operation({
+	id: "posthog.projects-list",
+	name: "PostHog List Projects",
+	description: "List projects in an organization",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...orgInput,
+		limit: z.number().int().min(1).max(200).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: paginatedResponseSchema(projectSchema),
+	run: async (input, context) => {
+		return createPosthogManagementClient(context.credentials.posthog).request({
+			method: "GET",
+			path: `/api/organizations/${input.organizationId}/projects/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-reset-token.operation.ts
+const projectsResetTokenOperation = new Operation({
+	id: "posthog.projects-reset-token",
+	name: "PostHog Rotate Project API Key",
+	description: "Reset (rotate) the project API token",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(projectIdInput),
+	output: projectSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/reset_token/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/projects-update.operation.ts
+const projectsUpdateOperation = new Operation({
+	id: "posthog.projects-update",
+	name: "PostHog Update Project",
+	description: "Partial update to a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInput,
+		...writeShape$1
+	}),
+	output: projectSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/property-definitions-get.operation.ts
+const propertyDefinitionsGetOperation = new Operation({
+	id: "posthog.property-definitions-get",
+	name: "PostHog Get Property Definition",
+	description: "Retrieve a property definition by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(eventDefIdInput),
+	output: eventDefinitionSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/property_definitions/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/property-definitions-list.operation.ts
+const propertyDefinitionsListOperation = new Operation({
+	id: "posthog.property-definitions-list",
+	name: "PostHog List Property Definitions",
+	description: "List property definitions",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(500).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional(),
+		type: z.string().optional(),
+		event_names: z.array(z.string()).optional()
+	}),
+	output: paginatedResponseSchema(eventDefinitionSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/property_definitions/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search,
+				type: input.type,
+				...input.event_names ? { event_names: input.event_names.join(",") } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/property-definitions-update.operation.ts
+const propertyDefinitionsUpdateOperation = new Operation({
+	id: "posthog.property-definitions-update",
+	name: "PostHog Update Property Definition",
+	description: "Update description, owner, tags, or verified status on a property definition",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...eventDefIdInput,
+		description: z.string().nullable().optional(),
+		tags: z.array(z.string()).optional(),
+		verified: z.boolean().optional()
+	}),
+	output: eventDefinitionSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/property_definitions/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/utils/domain-inputs/session-recordings.ts
+const idInput = {
+	...projectIdInputShape,
+	id: z.string().min(1)
+};
+const playlistIdInput = {
+	...projectIdInputShape,
+	playlistId: z.union([z.string(), z.number().int()])
+};
+
+//#endregion
+//#region src/operations/session-recording-playlists-add-recording.operation.ts
+const sessionRecordingPlaylistsAddRecordingOperation = new Operation({
+	id: "posthog.session-recording-playlists-add-recording",
+	name: "PostHog Add Recording To Playlist",
+	description: "Add a recording to a session replay playlist",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...playlistIdInput,
+		session_recording_id: z.string().min(1)
+	}),
+	output: z.record(z.string(), z.unknown()),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/session_recording_playlists/${input.playlistId}/recordings/${input.session_recording_id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recording-playlists-create.operation.ts
+const sessionRecordingPlaylistsCreateOperation = new Operation({
+	id: "posthog.session-recording-playlists-create",
+	name: "PostHog Create Replay Playlist",
+	description: "Create a new session replay playlist",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		name: z.string().optional(),
+		description: z.string().nullable().optional(),
+		pinned: z.boolean().optional(),
+		filters: z.record(z.string(), z.unknown()).optional()
+	}),
+	output: sessionRecordingPlaylistSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/session_recording_playlists/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recording-playlists-delete.operation.ts
+const sessionRecordingPlaylistsDeleteOperation = new Operation({
+	id: "posthog.session-recording-playlists-delete",
+	name: "PostHog Delete Replay Playlist",
+	description: "Delete a session replay playlist",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(playlistIdInput),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/session_recording_playlists/${input.playlistId}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/session-recording-playlists-get.operation.ts
+const sessionRecordingPlaylistsGetOperation = new Operation({
+	id: "posthog.session-recording-playlists-get",
+	name: "PostHog Get Replay Playlist",
+	description: "Retrieve a session replay playlist by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(playlistIdInput),
+	output: sessionRecordingPlaylistSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recording_playlists/${input.playlistId}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recording-playlists-list.operation.ts
+const sessionRecordingPlaylistsListOperation = new Operation({
+	id: "posthog.session-recording-playlists-list",
+	name: "PostHog List Replay Playlists",
+	description: "List session replay playlists",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(200).optional(),
+		offset: z.number().int().min(0).optional()
+	}),
+	output: paginatedResponseSchema(sessionRecordingPlaylistSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recording_playlists/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recording-playlists-recordings-list.operation.ts
+const sessionRecordingPlaylistsRecordingsListOperation = new Operation({
+	id: "posthog.session-recording-playlists-recordings-list",
+	name: "PostHog List Playlist Recordings",
+	description: "List recordings in a session replay playlist",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...playlistIdInput,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: paginatedResponseSchema(sessionRecordingSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recording_playlists/${input.playlistId}/recordings/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recording-playlists-remove-recording.operation.ts
+const sessionRecordingPlaylistsRemoveRecordingOperation = new Operation({
+	id: "posthog.session-recording-playlists-remove-recording",
+	name: "PostHog Remove Recording From Playlist",
+	description: "Remove a recording from a session replay playlist",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...playlistIdInput,
+		session_recording_id: z.string().min(1)
+	}),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/session_recording_playlists/${input.playlistId}/recordings/${input.session_recording_id}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/session-recording-playlists-update.operation.ts
+const sessionRecordingPlaylistsUpdateOperation = new Operation({
+	id: "posthog.session-recording-playlists-update",
+	name: "PostHog Update Replay Playlist",
+	description: "Partial update to a session replay playlist",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...playlistIdInput,
+		name: z.string().optional(),
+		description: z.string().nullable().optional(),
+		pinned: z.boolean().optional(),
+		filters: z.record(z.string(), z.unknown()).optional(),
+		deleted: z.boolean().optional()
+	}),
+	output: sessionRecordingPlaylistSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, playlistId, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/session_recording_playlists/${playlistId}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recordings-delete.operation.ts
+const sessionRecordingsDeleteOperation = new Operation({
+	id: "posthog.session-recordings-delete",
+	name: "PostHog Delete Session Recording",
+	description: "Delete a session recording",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/session_recordings/${input.id}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/session-recordings-get.operation.ts
+const sessionRecordingsGetOperation = new Operation({
+	id: "posthog.session-recordings-get",
+	name: "PostHog Get Session Recording",
+	description: "Retrieve a session recording by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: sessionRecordingSchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recordings/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recordings-list.operation.ts
+const sessionRecordingsListOperation = new Operation({
+	id: "posthog.session-recordings-list",
+	name: "PostHog List Session Recordings",
+	description: "List session recordings, optionally filtered",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(100).optional(),
+		offset: z.number().int().min(0).optional(),
+		distinct_id: z.string().optional(),
+		date_from: z.string().optional(),
+		date_to: z.string().optional(),
+		person_uuid: z.string().optional()
+	}),
+	output: paginatedResponseSchema(sessionRecordingSchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recordings/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				distinct_id: input.distinct_id,
+				date_from: input.date_from,
+				date_to: input.date_to,
+				person_uuid: input.person_uuid
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recordings-properties.operation.ts
+const sessionRecordingsPropertiesOperation = new Operation({
+	id: "posthog.session-recordings-properties",
+	name: "PostHog Session Recording Properties",
+	description: "Fetch aggregated properties for a session recording",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recordings/${input.id}/properties/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recordings-snapshots.operation.ts
+const sessionRecordingsSnapshotsOperation = new Operation({
+	id: "posthog.session-recordings-snapshots",
+	name: "PostHog Session Recording Snapshots",
+	description: "Fetch rrweb snapshot urls for a session recording",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		source: z.enum(["realtime", "blob"]).optional()
+	}),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recordings/${input.id}/snapshots/`,
+			query: { source: input.source }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/session-recordings-update.operation.ts
+const sessionRecordingsUpdateOperation = new Operation({
+	id: "posthog.session-recordings-update",
+	name: "PostHog Update Session Recording",
+	description: "Mark a session recording as viewed or update summary metadata",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		viewed: z.boolean().optional(),
+		analyzed: z.boolean().optional()
+	}),
+	output: sessionRecordingSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/session_recordings/${input.id}/`,
+			body: {
+				viewed: input.viewed,
+				analyzed: input.analyzed
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/set-person-properties.operation.ts
+const setPersonPropertiesOperation = new Operation({
+	id: "posthog.set-person-properties",
+	name: "PostHog Set Person Properties",
+	description: "Set (overwrite) properties on a person via a $set event",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		distinctId: z.string().min(1),
+		properties: propertiesBagSchema,
+		timestamp: z.iso.datetime().optional()
+	}),
+	output: captureResponseSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogIngestClient(context.credentials.posthog);
+		return client.request({
+			method: "POST",
+			path: "/capture/",
+			body: {
+				api_key: client.projectApiKey(),
+				event: "$set",
+				distinct_id: input.distinctId,
+				properties: { $set: input.properties },
+				...input.timestamp ? { timestamp: input.timestamp } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/set-person-properties-once.operation.ts
+const setPersonPropertiesOnceOperation = new Operation({
+	id: "posthog.set-person-properties-once",
+	name: "PostHog Set Person Properties Once",
+	description: "Set properties on a person only if not already set ($set_once)",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		distinctId: z.string().min(1),
+		properties: propertiesBagSchema,
+		timestamp: z.iso.datetime().optional()
+	}),
+	output: captureResponseSchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogIngestClient(context.credentials.posthog);
+		return client.request({
+			method: "POST",
+			path: "/capture/",
+			body: {
+				api_key: client.projectApiKey(),
+				event: "$set",
+				distinct_id: input.distinctId,
+				properties: { $set_once: input.properties },
+				...input.timestamp ? { timestamp: input.timestamp } : {}
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-activity.operation.ts
+const surveysActivityOperation = new Operation({
+	id: "posthog.surveys-activity",
+	name: "PostHog Survey Activity",
+	description: "Fetch activity log for a survey",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/${input.id}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-activity-feed.operation.ts
+const surveysActivityFeedOperation = new Operation({
+	id: "posthog.surveys-activity-feed",
+	name: "PostHog Surveys Activity Feed",
+	description: "Fetch project-wide survey activity feed",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-create.operation.ts
+const surveysCreateOperation = new Operation({
+	id: "posthog.surveys-create",
+	name: "PostHog Create Survey",
+	description: "Create a new survey",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		...writeShape$1,
+		name: z.string().min(1)
+	}),
+	output: surveySchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/surveys/`,
+			body
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-delete.operation.ts
+const surveysDeleteOperation = new Operation({
+	id: "posthog.surveys-delete",
+	name: "PostHog Delete Survey",
+	description: "Delete (archive) a survey",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/surveys/${input.id}/`
+		});
+		return { success: true };
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-get.operation.ts
+const surveysGetOperation = new Operation({
+	id: "posthog.surveys-get",
+	name: "PostHog Get Survey",
+	description: "Retrieve a survey by id",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: surveySchema,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/${input.id}/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-list.operation.ts
+const surveysListOperation = new Operation({
+	id: "posthog.surveys-list",
+	name: "PostHog List Surveys",
+	description: "List surveys in a project",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...projectIdInputShape,
+		limit: z.number().int().min(1).max(200).optional(),
+		offset: z.number().int().min(0).optional(),
+		search: z.string().optional()
+	}),
+	output: paginatedResponseSchema(surveySchema),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/`,
+			query: {
+				limit: input.limit,
+				offset: input.offset,
+				search: input.search
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-responses-count.operation.ts
+const surveysResponsesCountOperation = new Operation({
+	id: "posthog.surveys-responses-count",
+	name: "PostHog Survey Responses Count",
+	description: "Fetch the responses count for all surveys",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(projectIdInputShape),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/responses_count/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-stats.operation.ts
+const surveysStatsOperation = new Operation({
+	id: "posthog.surveys-stats",
+	name: "PostHog Survey Stats",
+	description: "Fetch aggregate statistics for a survey",
+	credentialSets: [posthogCredentialSet],
+	input: z.object(idInput$3),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/${input.id}/stats/`
+		});
+	}
+});
+
+//#endregion
+//#region src/operations/surveys-update.operation.ts
+const surveysUpdateOperation = new Operation({
+	id: "posthog.surveys-update",
+	name: "PostHog Update Survey",
+	description: "Partial update to a survey",
+	credentialSets: [posthogCredentialSet],
+	input: z.object({
+		...idInput$3,
+		...writeShape$1
+	}),
+	output: surveySchema,
+	needsApproval: true,
+	run: async (input, context) => {
+		const client = createPosthogManagementClient(context.credentials.posthog);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/surveys/${id}/`,
+			body
+		});
+	}
+});
+
+//#endregion
+export { personsLifecycleOperation as $, eventDefinitionsUpdateOperation as $t, projectsResetTokenOperation as A, captureBatchEventsOperation as An, insightsCreateOperation as At, projectMembersListOperation as B, actionsDeleteOperation as Bn, featureFlagsRemoteConfigOperation as Bt, sessionRecordingPlaylistsDeleteOperation as C, cohortsListOperation as Cn, insightsRetentionOperation as Ct, propertyDefinitionsListOperation as D, cohortsCreateOperation as Dn, insightsGetOperation as Dt, propertyDefinitionsUpdateOperation as E, cohortsDeleteOperation as En, insightsListOperation as Et, projectsCreateOperation as F, annotationsCreateOperation as Fn, featureFlagsUpdateOperation as Ft, personsValuesOperation as G, featureFlagsDisableOperation as Gt, pipelineDestinationsListOperation as H, actionWebhooksListOperation as Hn, featureFlagsListOperation as Ht, projectsAddUserIntegrationOperation as I, aliasPersonOperation as In, featureFlagsStatusOperation as It, personsTrendsOperation as J, featureFlagsCreateOperation as Jt, personsUpdatePropertyOperation as K, featureFlagsDeleteOperation as Kt, projectsActivityOperation as L, actionsUpdateOperation as Ln, featureFlagsRoleAccessListOperation as Lt, projectsIsGenericEmailProviderOperation as M, annotationsListOperation as Mn, insightsActivityOperation as Mt, projectsGetOperation as N, annotationsGetOperation as Nn, identifyPersonOperation as Nt, propertyDefinitionsGetOperation as O, cohortsActivityOperation as On, insightsFunnelOperation as Ot, projectsDeleteOperation as P, annotationsDeleteOperation as Pn, groupIdentifyOperation as Pt, personsListOperation as Q, eventsGetOperation as Qt, projectMembersUpdateOperation as R, actionsListOperation as Rn, featureFlagsRoleAccessDeleteOperation as Rt, sessionRecordingPlaylistsGetOperation as S, cohortsPersonsOperation as Sn, insightsSharingGetOperation as St, sessionRecordingPlaylistsAddRecordingOperation as T, cohortsDuplicateAsStaticOperation as Tn, insightsMyInsightsOperation as Tt, pipelineDestinationsDeleteOperation as U, actionWebhooksDetachOperation as Un, featureFlagsGetOperation as Ut, projectMembersAddOperation as V, actionsCreateOperation as Vn, featureFlagsMyFlagsOperation as Vt, pipelineDestinationsCreateOperation as W, actionWebhooksAttachOperation as Wn, featureFlagsEnableOperation as Wt, personsResetNameOperation as X, eventsValuesOperation as Xt, personsSplitOperation as Y, featureFlagsActivityOperation as Yt, personsMergeOperation as Z, eventsListOperation as Zt, sessionRecordingsDeleteOperation as _, dashboardTemplatesListOperation as _n, insightsViewedOperation as _t, surveysGetOperation as a, dashboardsUpdateOperation as an, personsActivityOperation as at, sessionRecordingPlaylistsRecordingsListOperation as b, dashboardTemplatesCreateOperation as bn, insightsTrendOperation as bt, surveysActivityFeedOperation as c, dashboardsListOperation as cn, organizationsGetOperation as ct, setPersonPropertiesOperation as d, dashboardsCreateOperation as dn, organizationMembersUpdateOperation as dt, eventDefinitionsListOperation as en, personsGetOperation as et, sessionRecordingsUpdateOperation as f, dashboardsCollaboratorsRemoveOperation as fn, organizationMembersRemoveOperation as ft, sessionRecordingsGetOperation as g, dashboardTemplatesUpdateOperation as gn, organizationInvitesCreateOperation as gt, sessionRecordingsListOperation as h, dashboardsActivityOperation as hn, organizationInvitesDeleteOperation as ht, surveysListOperation as i, decideFeatureFlagsOperation as in, personsActivityFeedOperation as it, projectsListOperation as j, annotationsUpdateOperation as jn, insightsActivityFeedOperation as jt, projectsUpdateOperation as k, captureEventOperation as kn, insightsDeleteOperation as kt, surveysActivityOperation as l, dashboardsGetOperation as ln, organizationsDeleteOperation as lt, sessionRecordingsPropertiesOperation as m, dashboardsCollaboratorsAddOperation as mn, organizationInvitesListOperation as mt, surveysStatsOperation as n, eventDefinitionsDeleteOperation as nn, personsDeletePropertyOperation as nt, surveysDeleteOperation as o, dashboardsSharingUpdateOperation as on, organizationsUpdateOperation as ot, sessionRecordingsSnapshotsOperation as p, dashboardsCollaboratorsListOperation as pn, organizationMembersListOperation as pt, personsUpdateOperation as q, featureFlagsDashboardsOperation as qt, surveysResponsesCountOperation as r, decideFeatureFlagsLocalOperation as rn, personsDeleteOperation as rt, surveysCreateOperation as s, dashboardsSharingGetOperation as sn, organizationsListOperation as st, surveysUpdateOperation as t, eventDefinitionsGetOperation as tn, personsFunnelOperation as tt, setPersonPropertiesOnceOperation as u, dashboardsDeleteOperation as un, organizationsCreateOperation as ut, sessionRecordingPlaylistsUpdateOperation as v, dashboardTemplatesGetOperation as vn, insightsUpdateOperation as vt, sessionRecordingPlaylistsCreateOperation as w, cohortsGetOperation as wn, insightsPathOperation as wt, sessionRecordingPlaylistsListOperation as x, cohortsUpdateOperation as xn, insightsSharingUpdateOperation as xt, sessionRecordingPlaylistsRemoveRecordingOperation as y, dashboardTemplatesDeleteOperation as yn, insightsTrendChartOperation as yt, projectMembersRemoveOperation as z, actionsGetOperation as zn, featureFlagsRoleAccessCreateOperation as zt };