@getuserfeedback/protocol 0.6.1 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getuserfeedback/protocol",
-	"version": "0.6.1",
+	"version": "0.8.0",
 	"description": "getuserfeedback widget protocol — host surface and (later) wire protocol",
 	"keywords": [
 		"getuserfeedback",
@@ -8,82 +8,101 @@
 		"protocol"
 	],
 	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/getuserfeedback/getuserfeedback.git"
+	},
 	"publishConfig": {
 		"access": "public"
 	},
 	"type": "module",
 	"sideEffects": false,
 	"files": [
-		"dist"
+		"dist",
+		"src"
 	],
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
+			"bun": "./src/index.ts",
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
 		"./host": {
 			"types": "./dist/host/index.d.ts",
+			"bun": "./src/host/index.ts",
 			"import": "./dist/host/index.js",
 			"default": "./dist/host/index.js"
 		},
 		"./host/sdk-types": {
 			"types": "./dist/host/sdk-types.d.ts",
+			"bun": "./src/host/sdk-types.ts",
 			"import": "./dist/host/sdk-types.js",
 			"default": "./dist/host/sdk-types.js"
 		},
 		"./host/host-event-contract": {
 			"types": "./dist/host/host-event-contract.d.ts",
+			"bun": "./src/host/host-event-contract.ts",
 			"import": "./dist/host/host-event-contract.js",
 			"default": "./dist/host/host-event-contract.js"
 		},
 		"./host/constants": {
 			"types": "./dist/host/constants.d.ts",
+			"bun": "./src/host/constants.ts",
 			"import": "./dist/host/constants.js",
 			"default": "./dist/host/constants.js"
 		},
 		"./host/command-dispatch": {
 			"types": "./dist/host/command-dispatch.d.ts",
+			"bun": "./src/host/command-dispatch.ts",
 			"import": "./dist/host/command-dispatch.js",
 			"default": "./dist/host/command-dispatch.js"
 		},
 		"./host/command-settlement": {
 			"types": "./dist/host/command-settlement.d.ts",
+			"bun": "./src/host/command-settlement.ts",
 			"import": "./dist/host/command-settlement.js",
 			"default": "./dist/host/command-settlement.js"
 		},
 		"./host/sdk": {
 			"types": "./dist/host/sdk.d.ts",
+			"bun": "./src/host/sdk.ts",
 			"import": "./dist/host/sdk.js",
 			"default": "./dist/host/sdk.js"
 		},
 		"./host/request-id": {
 			"types": "./dist/host/request-id.d.ts",
+			"bun": "./src/host/request-id.ts",
 			"import": "./dist/host/request-id.js",
 			"default": "./dist/host/request-id.js"
 		},
 		"./host/unique-id": {
 			"types": "./dist/host/unique-id.d.ts",
+			"bun": "./src/host/unique-id.ts",
 			"import": "./dist/host/unique-id.js",
 			"default": "./dist/host/unique-id.js"
 		},
 		"./host/lazy-handle-client": {
 			"types": "./dist/host/lazy-handle-client.d.ts",
+			"bun": "./src/host/lazy-handle-client.ts",
 			"import": "./dist/host/lazy-handle-client.js",
 			"default": "./dist/host/lazy-handle-client.js"
 		},
 		"./version-resolution": {
 			"types": "./dist/version-resolution.d.ts",
+			"bun": "./src/version-resolution.ts",
 			"import": "./dist/version-resolution.js",
 			"default": "./dist/version-resolution.js"
 		},
 		"./flow-assignments": {
 			"types": "./dist/flow-assignments.d.ts",
+			"bun": "./src/flow-assignments.ts",
 			"import": "./dist/flow-assignments.js",
 			"default": "./dist/flow-assignments.js"
 		},
 		"./trpc-envelope": {
 			"types": "./dist/trpc-envelope.d.ts",
+			"bun": "./src/trpc-envelope.ts",
 			"import": "./dist/trpc-envelope.js",
 			"default": "./dist/trpc-envelope.js"
 		}
@@ -91,6 +110,7 @@
 	"scripts": {
 		"lint": "ultracite check .",
 		"build": "bun ../../scripts/clean-build-output.ts dist tsconfig.tsbuildinfo && tsc -b tsconfig.json",
+		"types": "bun ../../scripts/clean-build-output.ts dist tsconfig.tsbuildinfo && tsc -b tsconfig.json --emitDeclarationOnly",
 		"typecheck": "tsc -b tsconfig.json",
 		"test": "bun test --dots",
 		"pack:verify": "node ../../scripts/pack-and-verify.cjs",

package/src/app-event.ts

@@ -0,0 +1,235 @@
+import * as z from "zod/mini";
+import { appEventIdentityTypeSchema } from "./identity-type.js";
+
+export { appEventIdentityTypeSchema } from "./identity-type.js";
+
+export const appEventIdentitySchema = z.object({
+	type: appEventIdentityTypeSchema,
+	value: z.string().check(z.trim(), z.minLength(1)),
+});
+
+type AppEventFlagValue =
+	| string
+	| number
+	| boolean
+	| null
+	| AppEventFlagValue[]
+	| { [key: string]: AppEventFlagValue };
+
+export type AppEventJsonValue =
+	| string
+	| number
+	| boolean
+	| null
+	| AppEventJsonValue[]
+	| { [key: string]: AppEventJsonValue };
+
+const appEventFlagValueSchema: z.ZodMiniType<AppEventFlagValue> = z.lazy(() =>
+	z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null(),
+		z.array(appEventFlagValueSchema),
+		z.record(z.string(), appEventFlagValueSchema),
+	]),
+);
+
+const appEventJsonNumberSchema = z.number().check(
+	z.refine(Number.isFinite, {
+		message: "Expected a finite JSON number.",
+	}),
+);
+
+const appEventJsonValueSchema: z.ZodMiniType<AppEventJsonValue> = z.lazy(() =>
+	z.union([
+		z.string(),
+		appEventJsonNumberSchema,
+		z.boolean(),
+		z.null(),
+		z.array(appEventJsonValueSchema),
+		z.record(z.string(), appEventJsonValueSchema),
+	]),
+);
+
+const appEventJsonObjectSchema = z.record(z.string(), appEventJsonValueSchema);
+
+export const appEventFlagProviderSchema = z.object({
+	name: z.string().check(z.trim(), z.minLength(1)),
+	project: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	environment: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+
+export const appEventFlagSchema = z.object({
+	key: z.string().check(z.trim(), z.minLength(1)),
+	target: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	value: appEventFlagValueSchema,
+	variant: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	origin: z.optional(
+		z.enum(["runtime_config", "trigger_context", "provider_sync", "api"]),
+	),
+	provider: z.optional(appEventFlagProviderSchema),
+	status: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	reason: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	evaluatedAt: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+
+export const appEventCapabilitySchema = z.object({
+	key: z.string().check(z.trim(), z.minLength(1)),
+	source: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	provider: z.optional(appEventFlagProviderSchema),
+});
+
+const appEventPageSchema = z.object({
+	path: z.optional(z.string()),
+	referrer: z.optional(z.string()),
+	search: z.optional(z.string()),
+});
+
+const externalIdTypeSchema = z.string().check(
+	z.trim(),
+	z.minLength(1),
+	z.regex(/^[a-z0-9][a-z0-9_.-]*$/, {
+		message:
+			"External ID type must start with a lowercase letter or number and may contain lowercase letters, numbers, underscores, dots, or hyphens.",
+	}),
+);
+
+export const appEventExternalIdSchema = z.object({
+	id: z.pipe(
+		z.string().check(z.trim(), z.minLength(1)),
+		z.transform((value) => value.trim()),
+	),
+	type: externalIdTypeSchema,
+	collection: z.literal("users"),
+	encoding: z.literal("none"),
+});
+
+export type AppEventExternalId = z.output<typeof appEventExternalIdSchema>;
+
+export const appEventContextSchema = z.object({
+	page: z.optional(appEventPageSchema),
+	locale: z.optional(z.string()),
+	userAgent: z.optional(z.string()),
+	externalIds: z.optional(
+		z.array(appEventExternalIdSchema).check(z.maxLength(20)),
+	),
+	flags: z.optional(z.array(appEventFlagSchema)),
+	capabilities: z.optional(z.array(appEventCapabilitySchema)),
+});
+
+export const appEventBaseSchema = z.object({
+	traits: z.optional(z.record(z.string(), z.unknown())),
+	identities: z.optional(z.array(appEventIdentitySchema)),
+	context: z.optional(appEventContextSchema),
+	messageId: z.optional(z.string()),
+	timestamp: z.optional(z.number()),
+});
+
+const appEventSurveyReferenceSchema = z.object({
+	surveyId: z.string(),
+});
+
+export const reservedSystemAppEventNames = [
+	"Response Submitted",
+	"Flow Viewed",
+	"Flow Dismissed",
+	"Identified",
+] as const;
+const reservedSystemAppEventNameLowercaseSet = new Set<string>(
+	reservedSystemAppEventNames.map((event) => event.toLowerCase()),
+);
+
+const appEventSystemTrackNameSchema = z.enum(["Flow Viewed", "Flow Dismissed"]);
+
+const appEventCustomerNameSchema = z.string().check(
+	z.trim(),
+	z.minLength(1),
+	z.maxLength(255),
+	z.check<string>((ctx) => {
+		if (!reservedSystemAppEventNameLowercaseSet.has(ctx.value.toLowerCase())) {
+			return;
+		}
+		ctx.issues.push({
+			code: "custom",
+			input: ctx.value,
+			message:
+				"Customer app event names cannot use reserved system event names.",
+			continue: false,
+		});
+	}),
+);
+
+export const appEventSystemBaseSchema = z.extend(appEventBaseSchema, {
+	origin: z.literal("system"),
+});
+
+const normalizeSystemAppEventOrigin = <T extends { origin?: "system" }>(
+	input: T,
+): Omit<T, "origin"> & { origin: "system" } => {
+	const { origin: _origin, ...rest } = input;
+	return {
+		...rest,
+		origin: "system" as const,
+	};
+};
+
+export const appEventSurveyViewedSchema = z.pipe(
+	z.extend(appEventBaseSchema, {
+		origin: z.optional(z.literal("system")),
+		event: z.literal("Flow Viewed"),
+		references: appEventSurveyReferenceSchema,
+	}),
+	z.transform(normalizeSystemAppEventOrigin),
+);
+
+export const appEventFlowDismissedSchema = z.pipe(
+	z.extend(appEventBaseSchema, {
+		origin: z.optional(z.literal("system")),
+		event: z.literal("Flow Dismissed"),
+		references: appEventSurveyReferenceSchema,
+	}),
+	z.transform(normalizeSystemAppEventOrigin),
+);
+
+export const appEventSystemTrackSchema = z.extend(appEventSystemBaseSchema, {
+	event: appEventSystemTrackNameSchema,
+	references: appEventSurveyReferenceSchema,
+});
+
+const appEventLegacySystemTrackSchema = z.pipe(
+	z.extend(appEventBaseSchema, {
+		origin: z.optional(z.literal("system")),
+		event: appEventSystemTrackNameSchema,
+		references: appEventSurveyReferenceSchema,
+	}),
+	z.transform(normalizeSystemAppEventOrigin),
+);
+
+export const appEventCustomerTrackSchema = z.extend(appEventBaseSchema, {
+	origin: z.literal("customer"),
+	event: appEventCustomerNameSchema,
+	// TODO(migration): Normalize Date values in event properties to ISO strings.
+	//   [from=manual-date-property-serialization] [to=protocol-date-property-normalization] [scope=slice] [priority=medium] [impact=medium] [risk=low]
+	properties: z.optional(appEventJsonObjectSchema),
+});
+
+export const appEventTrackSchema = z.union([
+	appEventLegacySystemTrackSchema,
+	appEventCustomerTrackSchema,
+]);
+
+const appEventDiscriminatedPayloadSchema = z.discriminatedUnion("origin", [
+	appEventSystemTrackSchema,
+	appEventCustomerTrackSchema,
+]);
+
+export const appEventPayloadSchema = z.union([
+	appEventLegacySystemTrackSchema,
+	appEventDiscriminatedPayloadSchema,
+]);
+
+export type AppEventTrackInput = z.output<typeof appEventTrackSchema>;
+export type AppEventPayload = z.output<typeof appEventPayloadSchema>;
+export type AppEventFlag = z.output<typeof appEventFlagSchema>;
+export type AppEventCapability = z.output<typeof appEventCapabilitySchema>;

package/src/client-meta.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/mini";
+
+export const clientMetaSchema = z.object({
+	loader: z.enum(["sdk", "gtm", "segment", "rudderstack", "tealium", "custom"]),
+	clientName: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	clientVersion: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	integrator: z.optional(
+		z.object({
+			name: z.optional(z.string().check(z.trim(), z.minLength(1))),
+			version: z.optional(z.string().check(z.trim(), z.minLength(1))),
+		}),
+	),
+	transport: z.optional(
+		z.enum(["script-tag", "esm", "loader", "tag-manager", "snippet"]),
+	),
+	runtime: z.optional(
+		z.object({
+			framework: z.optional(z.enum(["next", "vite", "webpack", "plain"])),
+			runtime: z.optional(z.enum(["browser", "edge"])),
+		}),
+	),
+	notes: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+
+export type ClientMeta = z.output<typeof clientMetaSchema>;

package/src/defaults.ts

@@ -0,0 +1,4 @@
+export const DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS: readonly [
+	"class",
+	"data-theme",
+] = ["class", "data-theme"];

package/src/errors.ts

@@ -0,0 +1,58 @@
+import * as z from "zod/mini";
+
+import { clientMetaSchema } from "./client-meta.js";
+
+// ---------------------------------------------------------------------------
+// Error-telemetry definitions shared across widget / host.
+// ---------------------------------------------------------------------------
+
+export const ErrorCategory = {
+	INTERNAL: "INTERNAL",
+	INVALID_USAGE: "INVALID_USAGE",
+	HOST: "HOST",
+} as const;
+
+export type ErrorCategory = (typeof ErrorCategory)[keyof typeof ErrorCategory];
+
+export const ErrorCategorySchema = z.enum([
+	ErrorCategory.INTERNAL,
+	ErrorCategory.INVALID_USAGE,
+	ErrorCategory.HOST,
+]);
+
+export const ErrorEventSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	message: z.string(),
+	stack: z.optional(z.string()),
+	category: ErrorCategorySchema,
+	timestamp: z.number(),
+	probability: z.optional(z.number()),
+	context: z.object({
+		widgetVersion: z.string(),
+		clientMeta: z.optional(clientMetaSchema),
+		/** When true, telemetry was captured with debug mode on (affects how to interpret context). */
+		debug: z.optional(z.boolean()),
+	}),
+});
+
+export type ErrorEvent = z.output<typeof ErrorEventSchema>;
+
+export type ProtocolErrorCode = "PARSE" | "VERSION" | "UNKNOWN_TYPE";
+
+const MAX_DETAIL_LENGTH = 80;
+
+export class ProtocolError extends Error {
+	code: ProtocolErrorCode;
+	details: string;
+
+	constructor(code: ProtocolErrorCode, details: string) {
+		const short =
+			details.length > MAX_DETAIL_LENGTH
+				? details.slice(0, MAX_DETAIL_LENGTH)
+				: details;
+		super(short);
+		this.code = code;
+		this.details = short;
+	}
+}

package/src/flow-assignments.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "bun:test";
+import {
+	claimPendingFlowAssignmentsRequestSchema,
+	flowAssignmentRecipientRequestSchema,
+	updateFlowAssignmentLifecycleRequestSchema,
+} from "./flow-assignments";
+
+describe("flow assignment request contracts", () => {
+	it("accepts runtime targeting context for listPending", () => {
+		const result = flowAssignmentRecipientRequestSchema.parse({
+			identities: [{ type: "userId", value: "user_1" }],
+			context: {
+				flags: [{ key: "new_checkout", value: true }],
+				capabilities: [{ key: "checkout.drawer", source: "host-app" }],
+			},
+		});
+
+		expect(result.context?.flags?.[0]).toEqual({
+			key: "new_checkout",
+			value: true,
+		});
+		expect(result.context?.capabilities?.[0]).toEqual({
+			key: "checkout.drawer",
+			source: "host-app",
+		});
+	});
+
+	it("accepts runtime targeting context for claimPending", () => {
+		const result = claimPendingFlowAssignmentsRequestSchema.parse({
+			holdOwnerKey: "inst_1",
+			context: {
+				flags: [{ key: "pricing_test", value: "variant_a" }],
+				capabilities: [{ key: "billing.portal" }],
+			},
+		});
+
+		expect(result.identities).toEqual([]);
+		expect(result.context?.flags?.[0]?.key).toBe("pricing_test");
+		expect(result.context?.capabilities?.[0]?.key).toBe("billing.portal");
+	});
+
+	it("accepts external ID identities for recipient continuity", () => {
+		const result = claimPendingFlowAssignmentsRequestSchema.parse({
+			holdOwnerKey: "inst_1",
+			identities: [
+				{
+					type: "externalId.shopify_customer_id",
+					value: "gid://shopify/Customer/123",
+				},
+			],
+		});
+
+		expect(result.identities).toEqual([
+			{
+				type: "externalId.shopify_customer_id",
+				value: "gid://shopify/Customer/123",
+			},
+		]);
+	});
+
+	it("accepts runtime targeting context for lifecycle updates", () => {
+		const result = updateFlowAssignmentLifecycleRequestSchema.parse({
+			identities: [{ type: "userId", value: "user_1" }],
+			flowAssignmentId: "flasn_1",
+			flowVersionId: "flv_1",
+			holdGroupToken: "fahold_1",
+			context: {
+				flags: [{ key: "new_checkout", value: true }],
+				capabilities: [{ key: "checkout.drawer", source: "host-app" }],
+			},
+		});
+
+		expect(result.context?.flags?.[0]).toEqual({
+			key: "new_checkout",
+			value: true,
+		});
+		expect(result.context?.capabilities?.[0]).toEqual({
+			key: "checkout.drawer",
+			source: "host-app",
+		});
+	});
+});

package/src/flow-assignments.ts

@@ -0,0 +1,151 @@
+import * as z from "zod/mini";
+
+import {
+	appEventCapabilitySchema,
+	appEventFlagSchema,
+	appEventIdentityTypeSchema,
+} from "./app-event.js";
+import type { IdentityTypeValue } from "./identity-type.js";
+
+export type FlowAssignmentExternalIdIdentityTypeValue = `externalId.${string}`;
+export type FlowAssignmentIdentityTypeValue =
+	| IdentityTypeValue
+	| FlowAssignmentExternalIdIdentityTypeValue;
+
+const flowAssignmentExternalIdIdentityTypeSchema = z.string().check(
+	z.trim(),
+	z.minLength(1),
+	z.regex(/^externalId\.[a-z0-9][a-z0-9_.-]*$/, {
+		message:
+			"External ID identity type must use externalId.<type> with a lowercase Segment external ID type.",
+	}),
+) as z.ZodMiniType<
+	FlowAssignmentExternalIdIdentityTypeValue,
+	FlowAssignmentExternalIdIdentityTypeValue
+>;
+
+const flowAssignmentIdentitySchema = z.object({
+	type: z.union([
+		appEventIdentityTypeSchema,
+		flowAssignmentExternalIdIdentityTypeSchema,
+	]),
+	value: z.string().check(z.trim(), z.minLength(1)),
+});
+
+export const flowAssignmentStatusSchema = z.enum([
+	"pending",
+	"held",
+	"presented",
+	"completed",
+	"expired",
+	"superseded",
+	"withdrawn_pending",
+	"withdrawn_presented",
+	"withdrawn_final",
+]);
+
+export const flowAssignmentTargetingContextSchema = z.object({
+	flags: z.optional(z.array(appEventFlagSchema)),
+	capabilities: z.optional(z.array(appEventCapabilitySchema)),
+});
+
+export const flowAssignmentRecipientRequestSchema = z.object({
+	identities: z._default(z.array(flowAssignmentIdentitySchema), []),
+	context: z.optional(flowAssignmentTargetingContextSchema),
+	at: z.optional(z.number()),
+});
+
+export const flowAssignmentRecordSchema = z.object({
+	flowAssignmentId: z.string().check(z.trim(), z.minLength(1)),
+	flowId: z.string().check(z.trim(), z.minLength(1)),
+	holdGroupToken: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	presentedFlowVersionId: z.optional(
+		z.string().check(z.trim(), z.minLength(1)),
+	),
+	latestFlowVersionId: z.string().check(z.trim(), z.minLength(1)),
+	status: flowAssignmentStatusSchema,
+	assignedAt: z.string(),
+	expiresAt: z.optional(z.string()),
+	heldAt: z.optional(z.string()),
+	holdExpiresAt: z.optional(z.string()),
+	presentedAt: z.optional(z.string()),
+	completedAt: z.optional(z.string()),
+	expiredAt: z.optional(z.string()),
+	supersededAt: z.optional(z.string()),
+	withdrawnAt: z.optional(z.string()),
+	withdrawnFinalAt: z.optional(z.string()),
+});
+
+export const listPendingFlowAssignmentsResponseSchema = z.object({
+	fetchedAt: z.string(),
+	flowAssignments: z.array(flowAssignmentRecordSchema),
+});
+
+export const claimPendingFlowAssignmentsRequestSchema = z.object({
+	identities: z._default(z.array(flowAssignmentIdentitySchema), []),
+	context: z.optional(flowAssignmentTargetingContextSchema),
+	holdOwnerKey: z.string().check(z.trim(), z.minLength(1)),
+	at: z.optional(z.number()),
+	limit: z.optional(z.number()),
+});
+
+export const claimPendingFlowAssignmentsResponseSchema = z.object({
+	fetchedAt: z.string(),
+	flowAssignments: z.array(flowAssignmentRecordSchema),
+});
+
+export const updateFlowAssignmentLifecycleRequestSchema = z.object({
+	identities: z._default(z.array(flowAssignmentIdentitySchema), []),
+	context: z.optional(flowAssignmentTargetingContextSchema),
+	flowAssignmentId: z.string().check(z.trim(), z.minLength(1)),
+	flowVersionId: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	holdGroupToken: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	at: z.optional(z.number()),
+});
+
+export const releaseFlowAssignmentClaimRequestSchema = z.object({
+	identities: z._default(z.array(flowAssignmentIdentitySchema), []),
+	holdGroupToken: z.string().check(z.trim(), z.minLength(1)),
+	holdOwnerKey: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	at: z.optional(z.number()),
+});
+
+export const releaseFlowAssignmentClaimResponseSchema = z.object({
+	releasedCount: z.number(),
+});
+
+export const updateFlowAssignmentLifecycleResponseSchema =
+	flowAssignmentRecordSchema;
+export const nullableUpdateFlowAssignmentLifecycleResponseSchema = z.nullable(
+	updateFlowAssignmentLifecycleResponseSchema,
+);
+
+export type FlowAssignmentStatus = z.output<typeof flowAssignmentStatusSchema>;
+export type FlowAssignmentRecipientRequest = z.output<
+	typeof flowAssignmentRecipientRequestSchema
+>;
+export type FlowAssignmentTargetingContext = z.output<
+	typeof flowAssignmentTargetingContextSchema
+>;
+export type FlowAssignmentRecord = z.output<typeof flowAssignmentRecordSchema>;
+export type ClaimPendingFlowAssignmentsRequest = z.output<
+	typeof claimPendingFlowAssignmentsRequestSchema
+>;
+export type ClaimPendingFlowAssignmentsResponse = z.output<
+	typeof claimPendingFlowAssignmentsResponseSchema
+>;
+export type ListPendingFlowAssignmentsResponse = z.output<
+	typeof listPendingFlowAssignmentsResponseSchema
+>;
+export type ReleaseFlowAssignmentClaimRequest = z.output<
+	typeof releaseFlowAssignmentClaimRequestSchema
+>;
+export type ReleaseFlowAssignmentClaimResponse = z.output<
+	typeof releaseFlowAssignmentClaimResponseSchema
+>;
+export type UpdateFlowAssignmentLifecycleRequest = z.output<
+	typeof updateFlowAssignmentLifecycleRequestSchema
+>;
+export type UpdateFlowAssignmentLifecycleResponse = z.output<
+	typeof updateFlowAssignmentLifecycleResponseSchema
+>;