@keystrokehq/segment 0.0.1

package/dist/tracking.mjs

@@ -0,0 +1,255 @@
+import { createSegmentClient } from "./client.mjs";
+import { t as segmentOperation } from "./factory-CvfKfzMq.mjs";
+import { z } from "zod";
+
+//#region src/tracking.ts
+/**
+* segment/tracking.ts
+*
+* Tracking API operations: `identify`, `track`, `page`, `screen`, `group`,
+* `alias`, `batch`, `import`. Every call routes through
+* `client.tracking.send` (or `.batch` for the bulk envelope), which:
+*
+* - resolves the per-source write key from `SEGMENT_WRITE_KEYS_JSON`
+*   (when `sourceId` is provided) or `SEGMENT_DEFAULT_WRITE_KEY`;
+* - enforces the 32 KB-per-event and 500 KB-per-batch hard limits Segment
+*   documents at
+*   https://segment.com/docs/connections/sources/catalog/libraries/server/http-api/.
+*
+* `import` is sugar: Segment's public HTTP API does not document a
+* `/v1/import` endpoint (historical imports are sent as backdated `track` or
+* `batch` calls). We expose the action so authors keep the intent-based id
+* but implement it as `POST /v1/track` with a required `timestamp` and
+* populated `sentAt`.
+*/
+const contextSchema = z.object({
+	active: z.boolean().optional(),
+	app: z.record(z.string(), z.unknown()).optional(),
+	campaign: z.record(z.string(), z.unknown()).optional(),
+	device: z.record(z.string(), z.unknown()).optional(),
+	ip: z.string().optional(),
+	library: z.record(z.string(), z.unknown()).optional(),
+	locale: z.string().optional(),
+	location: z.record(z.string(), z.unknown()).optional(),
+	network: z.record(z.string(), z.unknown()).optional(),
+	os: z.record(z.string(), z.unknown()).optional(),
+	page: z.record(z.string(), z.unknown()).optional(),
+	referrer: z.record(z.string(), z.unknown()).optional(),
+	screen: z.record(z.string(), z.unknown()).optional(),
+	timezone: z.string().optional(),
+	userAgent: z.string().optional()
+}).catchall(z.unknown());
+const integrationsSchema = z.record(z.string(), z.unknown());
+const idFieldsSchema = z.object({
+	userId: z.string().min(1).optional(),
+	anonymousId: z.string().min(1).optional(),
+	messageId: z.string().min(1).optional(),
+	timestamp: z.iso.datetime({ offset: true }).optional()
+}).refine((v) => Boolean(v.userId) || Boolean(v.anonymousId), { message: "identify/track/… require either userId or anonymousId." });
+const commonEnvelopeSchema = z.object({
+	context: contextSchema.optional(),
+	integrations: integrationsSchema.optional(),
+	sourceId: z.string().min(1).optional()
+});
+const sendResponseSchema = z.object({
+	sent: z.boolean(),
+	method: z.enum([
+		"identify",
+		"track",
+		"page",
+		"screen",
+		"group",
+		"alias"
+	])
+});
+function toPayload(value) {
+	const out = {};
+	for (const [k, v] of Object.entries(value)) {
+		if (v === void 0) continue;
+		out[k] = v;
+	}
+	return out;
+}
+const identifyInputSchema = idFieldsSchema.and(commonEnvelopeSchema).and(z.object({ traits: z.record(z.string(), z.unknown()).optional() }));
+const identify = segmentOperation({
+	id: "segment.tracking.identify",
+	name: "Identify user",
+	description: "Associate a user with an identity and set/update traits.",
+	input: identifyInputSchema,
+	output: sendResponseSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { sourceId, ...rest } = input;
+		await client.tracking.send("identify", toPayload(rest), { sourceId });
+		return {
+			sent: true,
+			method: "identify"
+		};
+	}
+});
+const trackInputSchema = idFieldsSchema.and(commonEnvelopeSchema).and(z.object({
+	event: z.string().min(1),
+	properties: z.record(z.string(), z.unknown()).optional()
+}));
+const track = segmentOperation({
+	id: "segment.tracking.track",
+	name: "Track event",
+	description: "Record an arbitrary event for a user or anonymous profile.",
+	input: trackInputSchema,
+	output: sendResponseSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { sourceId, ...rest } = input;
+		await client.tracking.send("track", toPayload(rest), { sourceId });
+		return {
+			sent: true,
+			method: "track"
+		};
+	}
+});
+const pageInputSchema = idFieldsSchema.and(commonEnvelopeSchema).and(z.object({
+	name: z.string().min(1).optional(),
+	category: z.string().min(1).optional(),
+	properties: z.record(z.string(), z.unknown()).optional()
+}));
+const page = segmentOperation({
+	id: "segment.tracking.page",
+	name: "Page view",
+	description: "Record a web page view.",
+	input: pageInputSchema,
+	output: sendResponseSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { sourceId, ...rest } = input;
+		await client.tracking.send("page", toPayload(rest), { sourceId });
+		return {
+			sent: true,
+			method: "page"
+		};
+	}
+});
+const screenInputSchema = idFieldsSchema.and(commonEnvelopeSchema).and(z.object({
+	name: z.string().min(1).optional(),
+	category: z.string().min(1).optional(),
+	properties: z.record(z.string(), z.unknown()).optional()
+}));
+const screen = segmentOperation({
+	id: "segment.tracking.screen",
+	name: "Mobile screen view",
+	description: "Record a mobile app screen view.",
+	input: screenInputSchema,
+	output: sendResponseSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { sourceId, ...rest } = input;
+		await client.tracking.send("screen", toPayload(rest), { sourceId });
+		return {
+			sent: true,
+			method: "screen"
+		};
+	}
+});
+const groupInputSchema = idFieldsSchema.and(commonEnvelopeSchema).and(z.object({
+	groupId: z.string().min(1),
+	traits: z.record(z.string(), z.unknown()).optional()
+}));
+const group = segmentOperation({
+	id: "segment.tracking.group",
+	name: "Group user",
+	description: "Associate a user with a group (account, org, team) and set group traits.",
+	input: groupInputSchema,
+	output: sendResponseSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { sourceId, ...rest } = input;
+		await client.tracking.send("group", toPayload(rest), { sourceId });
+		return {
+			sent: true,
+			method: "group"
+		};
+	}
+});
+const aliasInputSchema = commonEnvelopeSchema.and(z.object({
+	userId: z.string().min(1),
+	previousId: z.string().min(1),
+	messageId: z.string().min(1).optional(),
+	timestamp: z.iso.datetime({ offset: true }).optional()
+}));
+const alias = segmentOperation({
+	id: "segment.tracking.alias",
+	name: "Alias user",
+	description: "Merge two user identities (previousId → userId). Note: many downstream destinations ignore alias calls; primarily used for warehouse identity resolution.",
+	input: aliasInputSchema,
+	output: sendResponseSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { sourceId, ...rest } = input;
+		await client.tracking.send("alias", toPayload(rest), { sourceId });
+		return {
+			sent: true,
+			method: "alias"
+		};
+	}
+});
+const batchEventSchema = z.object({ type: z.enum([
+	"identify",
+	"track",
+	"page",
+	"screen",
+	"group",
+	"alias"
+]) }).catchall(z.unknown());
+const batchInputSchema = commonEnvelopeSchema.and(z.object({ events: z.array(batchEventSchema).min(1) }));
+const batchOutputSchema = z.object({
+	chunksSent: z.number().int().nonnegative(),
+	rejected: z.array(batchEventSchema)
+});
+const batch = segmentOperation({
+	id: "segment.tracking.batch",
+	name: "Batch events",
+	description: "Send many tracking events in a single request (automatically split into multiple calls to respect Segment’s 500 KB-per-batch and 32 KB-per-event limits).",
+	input: batchInputSchema,
+	output: batchOutputSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const result = await createSegmentClient(credentials).tracking.batch(input.events, { sourceId: input.sourceId });
+		return {
+			chunksSent: result.chunksSent,
+			rejected: [...result.rejected]
+		};
+	}
+});
+const importInputSchema = idFieldsSchema.and(commonEnvelopeSchema).and(z.object({
+	event: z.string().min(1),
+	properties: z.record(z.string(), z.unknown()).optional(),
+	timestamp: z.iso.datetime({ offset: true })
+}));
+const importEvent = segmentOperation({
+	id: "segment.tracking.import",
+	name: "Historical import",
+	description: "Send a backdated historical event. Segment has no dedicated import endpoint; we send a `track` call with the required `timestamp` and the current time as `sentAt`. Only destinations that accept historical data (warehouses, Mixpanel, Amplitude) will backfill.",
+	input: importInputSchema,
+	output: sendResponseSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSegmentClient(credentials);
+		const { sourceId, ...rest } = input;
+		await client.tracking.send("track", toPayload({
+			...rest,
+			sentAt: (/* @__PURE__ */ new Date()).toISOString()
+		}), { sourceId });
+		return {
+			sent: true,
+			method: "track"
+		};
+	}
+});
+
+//#endregion
+export { alias, batch, group, identify, importEvent, page, screen, track };

package/dist/transformations.d.mts

@@ -0,0 +1,188 @@
+import { z } from "zod";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+
+//#region src/transformations.d.ts
+declare const transformationSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  destinationId: z.ZodOptional<z.ZodString>;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  if: z.ZodOptional<z.ZodString>;
+  newEventName: z.ZodOptional<z.ZodString>;
+  propertyRenames: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  propertyValueTransformations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const listTransformations: _keystrokehq_core0.Operation<z.ZodIntersection<z.ZodObject<{
+  pageSize: z.ZodOptional<z.ZodNumber>;
+  pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>, z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodOptional<z.ZodString>;
+    destinationId: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    if: z.ZodOptional<z.ZodString>;
+    newEventName: z.ZodOptional<z.ZodString>;
+    propertyRenames: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    propertyValueTransformations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  }, z.core.$catchall<z.ZodUnknown>>>;
+  nextPageToken: z.ZodOptional<z.ZodString>;
+  totalEntries: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"segment", z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getTransformation: _keystrokehq_core0.Operation<z.ZodObject<{
+  [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  destinationId: z.ZodOptional<z.ZodString>;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  if: z.ZodOptional<z.ZodString>;
+  newEventName: z.ZodOptional<z.ZodString>;
+  propertyRenames: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  propertyValueTransformations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"segment", z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const createTransformation: _keystrokehq_core0.Operation<z.ZodObject<{
+  [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  destinationId: z.ZodOptional<z.ZodString>;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  if: z.ZodOptional<z.ZodString>;
+  newEventName: z.ZodOptional<z.ZodString>;
+  propertyRenames: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  propertyValueTransformations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"segment", z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const updateTransformation: _keystrokehq_core0.Operation<z.ZodObject<{
+  [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  destinationId: z.ZodOptional<z.ZodString>;
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  if: z.ZodOptional<z.ZodString>;
+  newEventName: z.ZodOptional<z.ZodString>;
+  propertyRenames: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  propertyValueTransformations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"segment", z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const deleteTransformation: _keystrokehq_core0.Operation<z.ZodObject<{
+  [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>, z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"segment", z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+  SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+    us: "us";
+    eu: "eu";
+  }>>;
+  SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+  SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+  SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+  SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { createTransformation, deleteTransformation, getTransformation, listTransformations, transformationSchema, updateTransformation };

package/dist/transformations.mjs

@@ -0,0 +1,83 @@
+import { a as segmentLooseObjectSchema, n as segmentIdSchema } from "./common-CdGiJbjq.mjs";
+import { n as crudList, r as crudMutate, t as crudGet } from "./crud-SWa_79Hg.mjs";
+import { z } from "zod";
+
+//#region src/transformations.ts
+/**
+* segment/transformations.ts — source/destination transformations. 5 actions
+* (PLAN § 6.11).
+*/
+const transformationSchema = segmentLooseObjectSchema({
+	id: segmentIdSchema,
+	name: z.string().optional(),
+	sourceId: z.string().optional(),
+	destinationId: z.string().optional(),
+	enabled: z.boolean().optional(),
+	if: z.string().optional(),
+	newEventName: z.string().optional(),
+	propertyRenames: z.array(z.record(z.string(), z.unknown())).optional(),
+	propertyValueTransformations: z.array(z.record(z.string(), z.unknown())).optional()
+});
+const listTransformations = crudList({
+	id: "segment.transformations.list",
+	name: "List transformations",
+	description: "List source/destination transformations.",
+	path: "/transformations",
+	itemsKey: "transformations",
+	item: transformationSchema
+});
+const getTransformation = crudGet({
+	id: "segment.transformations.get",
+	name: "Get transformation",
+	description: "Fetch a transformation by id.",
+	path: "/transformations/{id}",
+	output: transformationSchema,
+	unwrapKey: "transformation"
+});
+const createTransformation = crudMutate({
+	id: "segment.transformations.create",
+	name: "Create transformation",
+	description: "Create a source/destination transformation.",
+	method: "POST",
+	path: "/transformations",
+	bodyShape: {
+		name: z.string().min(1),
+		sourceId: z.string().optional(),
+		destinationId: z.string().optional(),
+		if: z.string().optional(),
+		newEventName: z.string().optional(),
+		propertyRenames: z.array(z.record(z.string(), z.unknown())).optional(),
+		propertyValueTransformations: z.array(z.record(z.string(), z.unknown())).optional(),
+		enabled: z.boolean().optional()
+	},
+	output: transformationSchema,
+	unwrapKey: "transformation"
+});
+const updateTransformation = crudMutate({
+	id: "segment.transformations.update",
+	name: "Update transformation",
+	description: "Patch a transformation.",
+	method: "PATCH",
+	path: "/transformations/{id}",
+	bodyShape: {
+		name: z.string().optional(),
+		if: z.string().optional(),
+		newEventName: z.string().optional(),
+		propertyRenames: z.array(z.record(z.string(), z.unknown())).optional(),
+		propertyValueTransformations: z.array(z.record(z.string(), z.unknown())).optional(),
+		enabled: z.boolean().optional()
+	},
+	output: transformationSchema,
+	unwrapKey: "transformation"
+});
+const deleteTransformation = crudMutate({
+	id: "segment.transformations.delete",
+	name: "Delete transformation",
+	description: "Delete a transformation.",
+	method: "DELETE",
+	path: "/transformations/{id}",
+	output: z.object({}).catchall(z.unknown())
+});
+
+//#endregion
+export { createTransformation, deleteTransformation, getTransformation, listTransformations, transformationSchema, updateTransformation };

package/dist/triggers.d.mts

@@ -0,0 +1,54 @@
+import { r as segment } from "./integration-D2yRaKFR.mjs";
+import { SegmentAudienceEvent, SegmentAudienceSyncEvent, SegmentComputedTraitEvent, SegmentDeletionRegulationEvent, SegmentDestinationCreatedEvent, SegmentFunctionVersionEvent, SegmentMonitoringEvent, SegmentReverseEtlRunEvent, SegmentSourceCreatedEvent, SegmentTrackingPlanViolationEvent, segmentAudienceWebhookEnvelopeSchema, segmentMonitoringAlertEnvelopeSchema } from "./events.mjs";
+import { z } from "zod";
+import { IntegrationTriggerBindingOptions } from "@keystrokehq/integration-authoring";
+import { BoundTrigger, WebhookRequest } from "@keystrokehq/core";
+import { PollingTriggerManifest, WebhookTriggerManifest } from "@keystrokehq/core/trigger";
+
+//#region src/triggers.d.ts
+type SegmentCredentialSets = readonly [typeof segment];
+type SegmentWebhookBindingOptions<TPayload, TOutput = TPayload> = IntegrationTriggerBindingOptions<TPayload, TOutput, WebhookRequest>;
+type SegmentWebhookBinding<TPayload> = <TOutput = TPayload>(options?: SegmentWebhookBindingOptions<TPayload, TOutput>) => BoundTrigger<z.output<typeof segmentAudienceWebhookEnvelopeSchema> | z.output<typeof segmentMonitoringAlertEnvelopeSchema>, SegmentCredentialSets, WebhookTriggerManifest, TOutput, WebhookRequest>;
+declare const webhooks: Readonly<{
+  audienceEntered: SegmentWebhookBinding<SegmentAudienceEvent>;
+  audienceExited: SegmentWebhookBinding<SegmentAudienceEvent>;
+  computedTraitsUpdated: SegmentWebhookBinding<SegmentComputedTraitEvent>;
+  functionsInvocationFailed: SegmentWebhookBinding<SegmentMonitoringEvent>;
+  deliveryFailureSpike: SegmentWebhookBinding<SegmentMonitoringEvent>;
+}>;
+type SegmentPollingBindingOptions<TEvent, TOutput = TEvent> = IntegrationTriggerBindingOptions<TEvent, TOutput> & {
+  readonly schedule?: string;
+};
+type SegmentPollingBoundTrigger<TEvent, TOutput = TEvent> = BoundTrigger<TEvent, SegmentCredentialSets, PollingTriggerManifest, TOutput>;
+interface AudienceSyncPollParams {
+  readonly spaceId: string;
+  readonly audienceId: string;
+}
+declare function audienceSyncCompleted<TOutput = SegmentAudienceSyncEvent>(params: AudienceSyncPollParams, options?: SegmentPollingBindingOptions<SegmentAudienceSyncEvent, TOutput>): SegmentPollingBoundTrigger<SegmentAudienceSyncEvent, TOutput>;
+interface ReverseEtlRunPollParams {
+  readonly modelId: string;
+}
+declare function reverseEtlRunSucceeded<TOutput = SegmentReverseEtlRunEvent>(params: ReverseEtlRunPollParams, options?: SegmentPollingBindingOptions<SegmentReverseEtlRunEvent, TOutput>): SegmentPollingBoundTrigger<SegmentReverseEtlRunEvent, TOutput>;
+declare function reverseEtlRunFailed<TOutput = SegmentReverseEtlRunEvent>(params: ReverseEtlRunPollParams, options?: SegmentPollingBindingOptions<SegmentReverseEtlRunEvent, TOutput>): SegmentPollingBoundTrigger<SegmentReverseEtlRunEvent, TOutput>;
+declare function reverseEtlRunStarted<TOutput = SegmentReverseEtlRunEvent>(params: ReverseEtlRunPollParams, options?: SegmentPollingBindingOptions<SegmentReverseEtlRunEvent, TOutput>): SegmentPollingBoundTrigger<SegmentReverseEtlRunEvent, TOutput>;
+interface FunctionVersionPollParams {
+  readonly functionId: string;
+}
+declare function functionsDeploymentCompleted<TOutput = SegmentFunctionVersionEvent>(params: FunctionVersionPollParams, options?: SegmentPollingBindingOptions<SegmentFunctionVersionEvent, TOutput>): SegmentPollingBoundTrigger<SegmentFunctionVersionEvent, TOutput>;
+declare function trackingPlanViolationDetected<TOutput = SegmentTrackingPlanViolationEvent>(options?: SegmentPollingBindingOptions<SegmentTrackingPlanViolationEvent, TOutput>): SegmentPollingBoundTrigger<SegmentTrackingPlanViolationEvent, TOutput>;
+declare function sourceCreated<TOutput = SegmentSourceCreatedEvent>(options?: SegmentPollingBindingOptions<SegmentSourceCreatedEvent, TOutput>): SegmentPollingBoundTrigger<SegmentSourceCreatedEvent, TOutput>;
+declare function destinationCreated<TOutput = SegmentDestinationCreatedEvent>(options?: SegmentPollingBindingOptions<SegmentDestinationCreatedEvent, TOutput>): SegmentPollingBoundTrigger<SegmentDestinationCreatedEvent, TOutput>;
+declare function deletionRegulationCompleted<TOutput = SegmentDeletionRegulationEvent>(options?: SegmentPollingBindingOptions<SegmentDeletionRegulationEvent, TOutput>): SegmentPollingBoundTrigger<SegmentDeletionRegulationEvent, TOutput>;
+declare const polling: Readonly<{
+  audienceSyncCompleted: typeof audienceSyncCompleted;
+  reverseEtlRunSucceeded: typeof reverseEtlRunSucceeded;
+  reverseEtlRunFailed: typeof reverseEtlRunFailed;
+  reverseEtlRunStarted: typeof reverseEtlRunStarted;
+  functionsDeploymentCompleted: typeof functionsDeploymentCompleted;
+  trackingPlanViolationDetected: typeof trackingPlanViolationDetected;
+  sourceCreated: typeof sourceCreated;
+  destinationCreated: typeof destinationCreated;
+  deletionRegulationCompleted: typeof deletionRegulationCompleted;
+}>;
+//#endregion
+export { AudienceSyncPollParams, FunctionVersionPollParams, ReverseEtlRunPollParams, audienceSyncCompleted, deletionRegulationCompleted, destinationCreated, functionsDeploymentCompleted, polling, reverseEtlRunFailed, reverseEtlRunStarted, reverseEtlRunSucceeded, sourceCreated, trackingPlanViolationDetected, webhooks };