@keystrokehq/posthog 0.0.1

package/dist/surveys.mjs

@@ -0,0 +1,208 @@
+import { createPosthogManagementClient } from "./client.mjs";
+import { paginatedResponseSchema, projectIdInputShape, surveySchema } from "./schemas.mjs";
+import { t as posthogOperation } from "./factory-DYDvHOGb.mjs";
+import { z } from "zod";
+
+//#region src/surveys.ts
+/**
+* posthog/surveys.ts
+*
+* Survey CRUD + activity. Uses the management client.
+*
+* Docs: https://posthog.com/docs/api/surveys
+*/
+const idInput = {
+	...projectIdInputShape,
+	id: z.string().min(1)
+};
+const writeShape = {
+	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()
+};
+const listSurveys = posthogOperation({
+	id: "posthog_surveys_list",
+	name: "PostHog List Surveys",
+	description: "List surveys in a project",
+	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, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		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
+			}
+		});
+	}
+});
+const getSurvey = posthogOperation({
+	id: "posthog_surveys_get",
+	name: "PostHog Get Survey",
+	description: "Retrieve a survey by id",
+	input: z.object(idInput),
+	output: surveySchema,
+	run: async (input, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/${input.id}/`
+		});
+	}
+});
+const createSurvey = posthogOperation({
+	id: "posthog_surveys_create",
+	name: "PostHog Create Survey",
+	description: "Create a new survey",
+	input: z.object({
+		...projectIdInputShape,
+		...writeShape,
+		name: z.string().min(1)
+	}),
+	output: surveySchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, ...body } = input;
+		return client.request({
+			method: "POST",
+			path: `/api/projects/${projectId}/surveys/`,
+			body
+		});
+	}
+});
+const updateSurvey = posthogOperation({
+	id: "posthog_surveys_update",
+	name: "PostHog Update Survey",
+	description: "Partial update to a survey",
+	input: z.object({
+		...idInput,
+		...writeShape
+	}),
+	output: surveySchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		const { projectId: _pid, id, ...body } = input;
+		return client.request({
+			method: "PATCH",
+			path: `/api/projects/${projectId}/surveys/${id}/`,
+			body
+		});
+	}
+});
+const deleteSurvey = posthogOperation({
+	id: "posthog_surveys_delete",
+	name: "PostHog Delete Survey",
+	description: "Delete (archive) a survey",
+	input: z.object(idInput),
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		await client.request({
+			method: "DELETE",
+			path: `/api/projects/${projectId}/surveys/${input.id}/`
+		});
+		return { success: true };
+	}
+});
+const getSurveyActivity = posthogOperation({
+	id: "posthog_surveys_activity",
+	name: "PostHog Survey Activity",
+	description: "Fetch activity log for a survey",
+	input: z.object({
+		...idInput,
+		limit: z.number().int().min(1).max(200).optional()
+	}),
+	output: z.object({ results: z.array(z.record(z.string(), z.unknown())) }),
+	run: async (input, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/${input.id}/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+const getSurveysActivityFeed = posthogOperation({
+	id: "posthog_surveys_activity_feed",
+	name: "PostHog Surveys Activity Feed",
+	description: "Fetch project-wide survey activity feed",
+	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, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/activity/`,
+			query: { limit: input.limit }
+		});
+	}
+});
+const getSurveyResponsesCount = posthogOperation({
+	id: "posthog_surveys_responses_count",
+	name: "PostHog Survey Responses Count",
+	description: "Fetch the responses count for all surveys",
+	input: z.object(projectIdInputShape),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/responses_count/`
+		});
+	}
+});
+const getSurveyStats = posthogOperation({
+	id: "posthog_surveys_stats",
+	name: "PostHog Survey Stats",
+	description: "Fetch aggregate statistics for a survey",
+	input: z.object(idInput),
+	output: z.record(z.string(), z.unknown()),
+	run: async (input, credentials) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(input.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/${input.id}/stats/`
+		});
+	}
+});
+
+//#endregion
+export { createSurvey, deleteSurvey, getSurvey, getSurveyActivity, getSurveyResponsesCount, getSurveyStats, getSurveysActivityFeed, listSurveys, updateSurvey };

package/dist/triggers.d.mts

@@ -0,0 +1,115 @@
+import { n as posthog } from "./integration-CsCBBu4d.mjs";
+import { z } from "zod";
+import { IntegrationTriggerBindingOptions, createPollingTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+import { BoundTrigger } from "@keystrokehq/core";
+import { PollingTriggerManifest } from "@keystrokehq/core/trigger";
+
+//#region src/triggers.d.ts
+type PosthogCredentialSets = readonly [typeof posthog];
+type Schedule = Parameters<typeof createPollingTriggerBindingFactory>[0]['schedule'];
+type PosthogPollingBoundTrigger<TResponse extends z.ZodTypeAny, TOutput = z.output<TResponse>> = BoundTrigger<z.output<TResponse>, PosthogCredentialSets, PollingTriggerManifest, TOutput>;
+interface PosthogPollingBindingOptions<TResponse extends z.ZodTypeAny, TOutput = z.output<TResponse>> extends IntegrationTriggerBindingOptions<z.output<TResponse>, TOutput> {
+  readonly schedule?: Schedule;
+  readonly idempotencyKey?: (response: z.output<TResponse>) => string | number;
+}
+declare const eventPageSchema: z.ZodObject<{
+  results: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodString>;
+    distinct_id: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const genericItemPageSchema: z.ZodObject<{
+  results: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  count: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface NewEventParams {
+  readonly event?: string;
+  readonly distinctId?: string;
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+interface NewRecordingParams {
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+interface NewPersonParams {
+  readonly projectId?: string | number;
+  readonly limit?: number;
+  readonly search?: string;
+}
+interface CohortMemberParams {
+  readonly cohortId: number;
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+interface InsightAlertParams {
+  readonly insightId: number;
+  readonly projectId?: string | number;
+}
+interface BatchExportRunParams {
+  readonly batchExportId: string;
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+interface ExperimentResultParams {
+  readonly experimentId: number;
+  readonly projectId?: string | number;
+}
+interface FeatureFlagActivityParams {
+  readonly flagId: number;
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+interface NewAnnotationParams {
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+interface AppMetricFailureParams {
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+interface SurveyResponseParams {
+  readonly surveyId: string;
+  readonly projectId?: string | number;
+}
+interface SubscriptionParams {
+  readonly projectId?: string | number;
+  readonly limit?: number;
+}
+declare function newEvent<TOutput = z.output<typeof eventPageSchema>>(input: NewEventParams & PosthogPollingBindingOptions<typeof eventPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof eventPageSchema, TOutput>;
+declare function newSessionRecording<TOutput = z.output<typeof genericItemPageSchema>>(input?: NewRecordingParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function newPerson<TOutput = z.output<typeof genericItemPageSchema>>(input?: NewPersonParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function newCohortMember<TOutput = z.output<typeof genericItemPageSchema>>(input: CohortMemberParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function insightAlert<TOutput = z.output<typeof genericItemPageSchema>>(input: InsightAlertParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function batchExportRun<TOutput = z.output<typeof genericItemPageSchema>>(input: BatchExportRunParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function experimentResult<TOutput = z.output<typeof genericItemPageSchema>>(input: ExperimentResultParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function featureFlagActivity<TOutput = z.output<typeof genericItemPageSchema>>(input: FeatureFlagActivityParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function newAnnotation<TOutput = z.output<typeof genericItemPageSchema>>(input?: NewAnnotationParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function pluginFailure<TOutput = z.output<typeof genericItemPageSchema>>(input?: AppMetricFailureParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function surveyResponse<TOutput = z.output<typeof genericItemPageSchema>>(input: SurveyResponseParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+declare function newSubscription<TOutput = z.output<typeof genericItemPageSchema>>(input?: SubscriptionParams & PosthogPollingBindingOptions<typeof genericItemPageSchema, TOutput>): PosthogPollingBoundTrigger<typeof genericItemPageSchema, TOutput>;
+/**
+ * Namespace object for authored workflows. Prefer the individual
+ * exports for new code; `polling` is kept for authoring ergonomics.
+ */
+declare const polling: Readonly<{
+  newEvent: typeof newEvent;
+  newSessionRecording: typeof newSessionRecording;
+  newPerson: typeof newPerson;
+  newCohortMember: typeof newCohortMember;
+  insightAlert: typeof insightAlert;
+  batchExportRun: typeof batchExportRun;
+  experimentResult: typeof experimentResult;
+  featureFlagActivity: typeof featureFlagActivity;
+  newAnnotation: typeof newAnnotation;
+  pluginFailure: typeof pluginFailure;
+  surveyResponse: typeof surveyResponse;
+  newSubscription: typeof newSubscription;
+}>;
+//#endregion
+export { batchExportRun, experimentResult, featureFlagActivity, insightAlert, newAnnotation, newCohortMember, newEvent, newPerson, newSessionRecording, newSubscription, pluginFailure, polling, surveyResponse };

package/dist/triggers.mjs

@@ -0,0 +1,330 @@
+import { t as posthog } from "./integration-Doy2Dwli.mjs";
+import { createPosthogManagementClient } from "./client.mjs";
+import { z } from "zod";
+import { createPollingTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+
+//#region src/triggers.ts
+function withDefaultSchedule(schedule) {
+	if (schedule === void 0) return "1m";
+	return schedule;
+}
+function extractCredentials(ctx) {
+	return ctx.credentials.posthog;
+}
+function createPosthogPollingBindingFactory(config) {
+	return createPollingTriggerBindingFactory({
+		defaultName: config.defaultName,
+		defaultDescription: config.defaultDescription,
+		schedule: withDefaultSchedule(config.schedule),
+		credentialSets: [posthog],
+		response: config.responseSchema,
+		poll: async (ctx) => {
+			const creds = extractCredentials(ctx);
+			return config.callback(creds, ctx.lastPolledAt);
+		},
+		idempotencyKey: (response) => {
+			const key = config.idempotencyKey ? config.idempotencyKey(response) : config.defaultIdempotencyKey(response);
+			return String(key);
+		}
+	});
+}
+function splitOptions(input) {
+	return {
+		schedule: input?.schedule,
+		idempotencyKey: input?.idempotencyKey,
+		bindOptions: {
+			...input?.name ? { name: input.name } : {},
+			...input?.description ? { description: input.description } : {},
+			...input?.filter ? { filter: input.filter } : {},
+			...input?.transform ? { transform: input.transform } : {}
+		}
+	};
+}
+function bindTrigger(definition, params, input) {
+	const { schedule, idempotencyKey, bindOptions } = splitOptions(input);
+	return createPosthogPollingBindingFactory({
+		responseSchema: definition.responseSchema,
+		defaultName: definition.defaultName,
+		defaultDescription: definition.defaultDescription,
+		callback: (credentials, lastPolledAt) => definition.poll(params, credentials, lastPolledAt),
+		defaultIdempotencyKey: definition.defaultIdempotencyKey,
+		schedule,
+		idempotencyKey
+	})(bindOptions);
+}
+function defineTrigger(definition) {
+	return definition;
+}
+const eventPageSchema = z.object({
+	results: z.array(z.object({
+		id: z.string().optional(),
+		event: z.string().optional(),
+		distinct_id: z.string().optional(),
+		timestamp: z.string().optional(),
+		properties: z.record(z.string(), z.unknown()).optional()
+	})),
+	next: z.string().nullable().optional()
+});
+const genericItemPageSchema = z.object({
+	results: z.array(z.record(z.string(), z.unknown())),
+	next: z.string().nullable().optional(),
+	count: z.number().int().optional()
+});
+function isoMinusSeconds(value) {
+	if (!value) return void 0;
+	const parsed = Date.parse(value);
+	if (!Number.isFinite(parsed)) return void 0;
+	return new Date(parsed).toISOString();
+}
+const newEventDefinition = defineTrigger({
+	responseSchema: eventPageSchema,
+	defaultName: "PostHog New Event",
+	defaultDescription: "Poll for new analytics events matching a filter",
+	poll: async (params, credentials, lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		const after = isoMinusSeconds(lastPolledAt);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/events/`,
+			query: {
+				limit: params.limit ?? 100,
+				event: params.event,
+				distinct_id: params.distinctId,
+				after
+			}
+		});
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.id ?? "no-events"
+});
+const newRecordingDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog New Session Recording",
+	defaultDescription: "Poll for new session recordings in a project",
+	poll: async (params, credentials, lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/session_recordings/`,
+			query: {
+				limit: params.limit ?? 50,
+				date_from: isoMinusSeconds(lastPolledAt)
+			}
+		});
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.id ?? "no-recordings"
+});
+const newPersonDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog New Person",
+	defaultDescription: "Poll for newly created or identified persons",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/persons/`,
+			query: {
+				limit: params.limit ?? 100,
+				search: params.search
+			}
+		});
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.uuid ?? (response.results[0]?.id)?.toString() ?? "no-persons"
+});
+const newCohortMemberDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog New Cohort Member",
+	defaultDescription: "Poll for newly added members of a cohort",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/cohorts/${params.cohortId}/persons/`,
+			query: { limit: params.limit ?? 100 }
+		});
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.uuid ?? "no-members"
+});
+const insightAlertDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog Insight Alert",
+	defaultDescription: "Poll an insight and emit on value changes (threshold-style)",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return { results: [await client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/insights/${params.insightId}/`
+		})] };
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.last_refresh ?? "no-refresh"
+});
+const batchExportRunDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog Batch Export Run",
+	defaultDescription: "Poll for batch export run state transitions",
+	poll: async (params, credentials, lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/batch_exports/${params.batchExportId}/runs/`,
+			query: {
+				limit: params.limit ?? 50,
+				cursor: lastPolledAt
+			}
+		});
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.id ?? "no-runs"
+});
+const experimentResultDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog Experiment Significant Result",
+	defaultDescription: "Poll experiment results and emit when significance is reached",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return { results: [await client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/experiments/${params.experimentId}/results/`
+		})] };
+	},
+	defaultIdempotencyKey: (response) => (response.results[0]?.significant)?.toString() ?? "no-results"
+});
+const featureFlagActivityDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog Feature Flag Rollout Change",
+	defaultDescription: "Poll the activity feed of a feature flag for rollout edits",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/feature_flags/${params.flagId}/activity/`,
+			query: { limit: params.limit ?? 50 }
+		});
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.created_at ?? "no-activity"
+});
+const newAnnotationDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog New Annotation",
+	defaultDescription: "Poll for newly created annotations",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/annotations/`,
+			query: { limit: params.limit ?? 100 }
+		});
+	},
+	defaultIdempotencyKey: (response) => (response.results[0]?.id)?.toString() ?? "no-annotations"
+});
+const appMetricFailureDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog Plugin Failure",
+	defaultDescription: "Poll app_metrics for pipeline / plugin failures",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/app_metrics/`,
+			query: {
+				limit: params.limit ?? 50,
+				category: "error"
+			}
+		});
+	},
+	defaultIdempotencyKey: (response) => response.results[0]?.timestamp ?? "no-failures"
+});
+const surveyResponseDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog Survey Response",
+	defaultDescription: "Poll survey stats and emit when response counts change",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return { results: [await client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/surveys/${params.surveyId}/stats/`
+		})] };
+	},
+	defaultIdempotencyKey: (response) => (response.results[0]?.total)?.toString() ?? "no-responses"
+});
+const newSubscriptionDefinition = defineTrigger({
+	responseSchema: genericItemPageSchema,
+	defaultName: "PostHog New Subscription",
+	defaultDescription: "Poll for newly scheduled subscriptions (insight/dashboard digests)",
+	poll: async (params, credentials, _lastPolledAt) => {
+		const client = createPosthogManagementClient(credentials);
+		const projectId = client.projectId(params.projectId);
+		return client.request({
+			method: "GET",
+			path: `/api/projects/${projectId}/subscriptions/`,
+			query: { limit: params.limit ?? 50 }
+		});
+	},
+	defaultIdempotencyKey: (response) => (response.results[0]?.id)?.toString() ?? "no-subscriptions"
+});
+function newEvent(input) {
+	return bindTrigger(newEventDefinition, input, input);
+}
+function newSessionRecording(input) {
+	return bindTrigger(newRecordingDefinition, input ?? {}, input);
+}
+function newPerson(input) {
+	return bindTrigger(newPersonDefinition, input ?? {}, input);
+}
+function newCohortMember(input) {
+	return bindTrigger(newCohortMemberDefinition, input, input);
+}
+function insightAlert(input) {
+	return bindTrigger(insightAlertDefinition, input, input);
+}
+function batchExportRun(input) {
+	return bindTrigger(batchExportRunDefinition, input, input);
+}
+function experimentResult(input) {
+	return bindTrigger(experimentResultDefinition, input, input);
+}
+function featureFlagActivity(input) {
+	return bindTrigger(featureFlagActivityDefinition, input, input);
+}
+function newAnnotation(input) {
+	return bindTrigger(newAnnotationDefinition, input ?? {}, input);
+}
+function pluginFailure(input) {
+	return bindTrigger(appMetricFailureDefinition, input ?? {}, input);
+}
+function surveyResponse(input) {
+	return bindTrigger(surveyResponseDefinition, input, input);
+}
+function newSubscription(input) {
+	return bindTrigger(newSubscriptionDefinition, input ?? {}, input);
+}
+/**
+* Namespace object for authored workflows. Prefer the individual
+* exports for new code; `polling` is kept for authoring ergonomics.
+*/
+const polling = Object.freeze({
+	newEvent,
+	newSessionRecording,
+	newPerson,
+	newCohortMember,
+	insightAlert,
+	batchExportRun,
+	experimentResult,
+	featureFlagActivity,
+	newAnnotation,
+	pluginFailure,
+	surveyResponse,
+	newSubscription
+});
+
+//#endregion
+export { batchExportRun, experimentResult, featureFlagActivity, insightAlert, newAnnotation, newCohortMember, newEvent, newPerson, newSessionRecording, newSubscription, pluginFailure, polling, surveyResponse };