@temelj/workflow 0.0.0-alpha.3 → 0.0.0-alpha.4

package/dist/schema/events.mjs

@@ -0,0 +1,235 @@
+import { discriminated, idSchema, nonBlankStringListSchema, nonBlankStringSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, telemetryContextSchema, temporalInstantSchema, temporalNonNegativeDurationSchema } from "./common.mjs";
+import { attributeValueSchema } from "../attributes.mjs";
+import { errorRecordSchema } from "./error.mjs";
+import { persistedValueSchema } from "./persisted-value.mjs";
+import { childWorkflowCancellationPolicySchema } from "./run.mjs";
+import { ss } from "@temelj/standard-schema";
+//#region src/schema/events.ts
+const messageWaitSourceSchema = ss.picklist(["hook", "webhook"]);
+const eventAttributesSchema = ss.record(attributeValueSchema);
+const eventBaseFields = { timestamp: temporalInstantSchema };
+const stepIdentityFields = {
+	stepId: idSchema,
+	stepName: nonBlankStringSchema
+};
+const countFields = { count: positiveSafeIntegerSchema };
+const attemptFields = { attempt: positiveSafeIntegerSchema };
+const messageWaiterStepIdsSchema = ss.refine(nonBlankStringListSchema, (items) => new Set(items).size === items.length, "Expected unique step ids");
+const startedEventSchema = ss.object({
+	...eventBaseFields,
+	kind: ss.literal("workflow_started")
+});
+const completedEventSchema = ss.object({
+	...eventBaseFields,
+	kind: ss.literal("workflow_completed")
+});
+const failedEventSchema = ss.object({
+	...eventBaseFields,
+	kind: ss.literal("workflow_failed")
+});
+const stepStartedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	...attemptFields,
+	kind: ss.literal("step_started"),
+	timeoutAt: ss.optional(temporalInstantSchema)
+});
+const stepCompletedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...attemptFields,
+	kind: ss.literal("step_completed"),
+	result: ss.optional(persistedValueSchema)
+});
+const stepFailedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...attemptFields,
+	kind: ss.literal("step_failed"),
+	error: errorRecordSchema
+});
+const sleepStartedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	kind: ss.literal("sleep_started"),
+	until: temporalInstantSchema,
+	duration: ss.optional(temporalNonNegativeDurationSchema)
+});
+const sleepCompletedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("sleep_completed")
+});
+const childWorkflowStartedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	...attemptFields,
+	kind: ss.literal("child_workflow_started"),
+	childRunId: idSchema,
+	workflowName: nonBlankStringSchema,
+	workflowVersion: ss.optional(nonBlankStringSchema),
+	cancellation: ss.optional(childWorkflowCancellationPolicySchema),
+	input: ss.optional(persistedValueSchema),
+	idempotencyKey: ss.optional(nonBlankStringSchema),
+	timeoutAt: ss.optional(temporalInstantSchema)
+});
+const childWorkflowCompletedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...attemptFields,
+	kind: ss.literal("child_workflow_completed"),
+	childRunId: idSchema,
+	result: ss.optional(persistedValueSchema)
+});
+const childWorkflowFailedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...attemptFields,
+	kind: ss.literal("child_workflow_failed"),
+	childRunId: idSchema,
+	error: errorRecordSchema
+});
+const messageSentEventSchema = ss.object({
+	...eventBaseFields,
+	kind: ss.literal("message_sent"),
+	messageId: idSchema,
+	payload: ss.optional(persistedValueSchema),
+	waiterStepIds: ss.optional(messageWaiterStepIdsSchema),
+	idempotencyKey: ss.optional(nonBlankStringSchema),
+	telemetryContext: ss.optional(telemetryContextSchema)
+});
+const messageSendStartedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	kind: ss.literal("message_send_started"),
+	targetRunId: idSchema,
+	messageId: idSchema,
+	payload: ss.optional(persistedValueSchema),
+	idempotencyKey: ss.optional(nonBlankStringSchema)
+});
+const messageSendCompletedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("message_send_completed"),
+	targetRunId: idSchema,
+	messageId: idSchema
+});
+const messageSendFailedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("message_send_failed"),
+	targetRunId: idSchema,
+	messageId: idSchema,
+	error: errorRecordSchema
+});
+const messageWaitStartedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	kind: ss.literal("message_wait_started"),
+	messageId: idSchema,
+	source: ss.optional(messageWaitSourceSchema),
+	timeoutAt: ss.optional(temporalInstantSchema)
+});
+const messageWaitCompletedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("message_wait_completed"),
+	messageId: idSchema,
+	payload: ss.optional(persistedValueSchema),
+	messageTimestamp: temporalInstantSchema,
+	telemetryContext: ss.optional(telemetryContextSchema)
+});
+const messageWaitFailedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("message_wait_failed"),
+	messageId: idSchema,
+	error: errorRecordSchema
+});
+const metadataSetEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	kind: ss.literal("metadata_set"),
+	metadata: persistedValueSchema
+});
+const attributesSetEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	kind: ss.literal("attributes_set"),
+	attributes: ss.optional(eventAttributesSchema),
+	removeAttributes: ss.optional(ss.array(nonBlankStringSchema))
+});
+const streamStartedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	kind: ss.literal("stream_started"),
+	streamId: idSchema,
+	contentType: ss.optional(nonBlankStringSchema),
+	metadata: ss.optional(persistedValueSchema)
+});
+const streamChunkEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("stream_chunk"),
+	streamId: idSchema,
+	index: nonNegativeSafeIntegerSchema,
+	chunk: ss.optional(persistedValueSchema)
+});
+const streamClosedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("stream_closed"),
+	streamId: idSchema
+});
+const streamFailedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	kind: ss.literal("stream_failed"),
+	streamId: idSchema,
+	error: errorRecordSchema
+});
+const deterministicValueRecordedEventSchema = ss.object({
+	...eventBaseFields,
+	...stepIdentityFields,
+	...countFields,
+	kind: ss.literal("deterministic_value_recorded"),
+	value: persistedValueSchema
+});
+const eventRecordSchema = discriminated("kind", {
+	workflow_started: startedEventSchema,
+	workflow_completed: completedEventSchema,
+	workflow_failed: failedEventSchema,
+	step_started: stepStartedEventSchema,
+	step_completed: stepCompletedEventSchema,
+	step_failed: stepFailedEventSchema,
+	sleep_started: sleepStartedEventSchema,
+	sleep_completed: sleepCompletedEventSchema,
+	child_workflow_started: childWorkflowStartedEventSchema,
+	child_workflow_completed: childWorkflowCompletedEventSchema,
+	child_workflow_failed: childWorkflowFailedEventSchema,
+	message_sent: messageSentEventSchema,
+	message_send_started: messageSendStartedEventSchema,
+	message_send_completed: messageSendCompletedEventSchema,
+	message_send_failed: messageSendFailedEventSchema,
+	message_wait_started: messageWaitStartedEventSchema,
+	message_wait_completed: messageWaitCompletedEventSchema,
+	message_wait_failed: messageWaitFailedEventSchema,
+	metadata_set: metadataSetEventSchema,
+	attributes_set: attributesSetEventSchema,
+	stream_started: streamStartedEventSchema,
+	stream_chunk: streamChunkEventSchema,
+	stream_closed: streamClosedEventSchema,
+	stream_failed: streamFailedEventSchema,
+	deterministic_value_recorded: deterministicValueRecordedEventSchema
+}, "Unsupported workflow event kind");
+const eventRecordListSchema = ss.array(eventRecordSchema);
+//#endregion
+export { eventRecordListSchema, eventRecordSchema };

package/dist/schema/pagination.d.mts

@@ -0,0 +1,5 @@
+//#region src/schema/pagination.d.ts
+export declare const cursorPayloadSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  key: import("@temelj/standard-schema").Schema<unknown, (string | number | boolean | null)[]>;
+}>>;
+//#endregion

package/dist/schema/pagination.mjs

@@ -0,0 +1,11 @@
+import { ss } from "@temelj/standard-schema";
+//#region src/schema/pagination.ts
+const cursorKeyPartSchema = ss.union([
+	ss.string(),
+	ss.number(),
+	ss.boolean(),
+	ss.literal(null)
+]);
+const cursorPayloadSchema = ss.object({ key: ss.refine(ss.array(cursorKeyPartSchema), (key) => key.length > 0, "Expected a cursor key") });
+//#endregion
+export { cursorPayloadSchema };

package/dist/schema/persisted-value.d.mts

@@ -0,0 +1,8 @@
+import { ValueIssue } from "../types/run.mjs";
+import { Schema } from "@temelj/standard-schema";
+import { StorageValue } from "@temelj/storage";
+//#region src/schema/persisted-value.d.ts
+export declare const persistedValueSchema: Schema<unknown, StorageValue>;
+/** Returns the first persistence validation issue for a workflow value, if one exists. */
+export declare function persistedValueIssue(value: unknown, path: string, seen: WeakSet<object>, allowUndefined: boolean): ValueIssue | undefined;
+//#endregion

package/dist/schema/persisted-value.mjs

@@ -0,0 +1,94 @@
+import { ss } from "@temelj/standard-schema";
+import { isBigInt, isBoolean, isFunction, isNumber, isObject, isPlainObject, isString, isSymbol } from "@temelj/value";
+import { isTemporalStorageValue } from "@temelj/storage";
+//#region src/schema/persisted-value.ts
+const persistedValueSchema = ss.schema((value) => {
+	const issue = persistedValueIssue(value, "value", /* @__PURE__ */ new WeakSet(), false);
+	return issue === void 0 ? ss.success(value) : ss.failure(issue.message);
+});
+/** Returns the first persistence validation issue for a workflow value, if one exists. */
+function persistedValueIssue(value, path, seen, allowUndefined) {
+	if (value === void 0) return allowUndefined ? void 0 : unsupportedUndefinedIssue(path);
+	if (value === null || isBoolean(value) || isString(value)) return;
+	if (isNumber(value)) return Number.isFinite(value) ? void 0 : {
+		path,
+		message: "number must be finite"
+	};
+	if (isBigInt(value)) return;
+	if (isFunction(value)) return {
+		path,
+		message: "function values are not supported"
+	};
+	if (isSymbol(value)) return {
+		path,
+		message: "symbol values are not supported"
+	};
+	if (!isObject(value)) return {
+		path,
+		message: "value type is not supported"
+	};
+	if (seen.has(value)) return {
+		path,
+		message: "circular references are not supported"
+	};
+	if (value instanceof Date) return Number.isFinite(value.getTime()) ? void 0 : {
+		path,
+		message: "Date must be valid"
+	};
+	if (isTemporalStorageValue(value) || value instanceof RegExp || value instanceof Uint8Array) return;
+	seen.add(value);
+	try {
+		if (value instanceof Map) return persistedMapIssue(value, path, seen);
+		if (value instanceof Set) return persistedSetIssue(value, path, seen);
+		if (Array.isArray(value)) return persistedArrayIssue(value, path, seen);
+		if (isPlainObject(value)) {
+			if (Object.getOwnPropertySymbols(value).some((key) => Object.prototype.propertyIsEnumerable.call(value, key))) return {
+				path,
+				message: "symbol keys are not supported"
+			};
+			for (const [key, item] of Object.entries(value)) {
+				const issue = persistedValueIssue(item, `${path}.${key}`, seen, false);
+				if (issue !== void 0) return issue;
+			}
+			return;
+		}
+		return {
+			path,
+			message: "object type is not supported"
+		};
+	} finally {
+		seen.delete(value);
+	}
+}
+function persistedArrayIssue(value, path, seen) {
+	for (const [index, item] of value.entries()) {
+		const issue = persistedValueIssue(item, `${path}[${index}]`, seen, false);
+		if (issue !== void 0) return issue;
+	}
+}
+function persistedMapIssue(value, path, seen) {
+	let index = 0;
+	for (const [key, item] of value) {
+		const keyIssue = persistedValueIssue(key, `${path}.<key:${index}>`, seen, false);
+		if (keyIssue !== void 0) return keyIssue;
+		const itemIssue = persistedValueIssue(item, `${path}.<value:${index}>`, seen, false);
+		if (itemIssue !== void 0) return itemIssue;
+		index++;
+	}
+}
+function persistedSetIssue(value, path, seen) {
+	let index = 0;
+	for (const item of value) {
+		const issue = persistedValueIssue(item, `${path}.<value:${index}>`, seen, false);
+		if (issue !== void 0) return issue;
+		index++;
+	}
+}
+function unsupportedUndefinedIssue(path) {
+	return {
+		path,
+		message: "undefined is not supported here"
+	};
+}
+//#endregion
+export { persistedValueIssue, persistedValueSchema };

package/dist/schema/run.d.mts

@@ -0,0 +1,51 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import "../mod.mjs";
+//#region src/schema/run.d.ts
+export declare const terminalRunStatusSchema: import("@temelj/standard-schema").Schema<unknown, "canceled" | "completed" | "failed">;
+export declare const materializedStepTypeSchema: import("@temelj/standard-schema").Schema<unknown, "deterministic" | "message-send" | "message-wait" | "run" | "sleep" | "stream" | "workflow">;
+export declare const runRecordSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  id: import("@temelj/standard-schema").Schema<unknown, string>;
+  namespace: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowName: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowVersion: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  status: import("@temelj/standard-schema").Schema<unknown, "canceled" | "completed" | "failed" | "pending" | "running" | "waiting">;
+  input: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  context: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  telemetryContext: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+    traceparent: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+    tracestate: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  }> | undefined>;
+  metadata: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  attributes: import("@temelj/standard-schema").Schema<unknown, Record<string, string | number | boolean | null> | undefined>;
+  output: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  error: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+    code: import("@temelj/standard-schema").Schema<unknown, WorkflowErrorCode | undefined>;
+    name: import("@temelj/standard-schema").Schema<unknown, string>;
+    message: import("@temelj/standard-schema").Schema<unknown, string>;
+    stack: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+    details: import("@temelj/standard-schema").Schema<unknown, Record<string, string | number | boolean | null | undefined> | undefined>;
+  }> | undefined>;
+  attempts: import("@temelj/standard-schema").Schema<unknown, number | undefined>;
+  idempotencyKey: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  parentRunId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  parentStepId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  parentStepName: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  parentStepAttempt: import("@temelj/standard-schema").Schema<unknown, number | undefined>;
+  workerId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  createdAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  updatedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  lastTransitionAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  lastTransitionReason: import("@temelj/standard-schema").Schema<unknown, "canceled" | "claimed" | "completed" | "created" | "deadline" | "failed" | "lease_released" | "manual_retry" | "missing_implementation" | "permanent_failure" | "reclaimed" | "rescheduled" | "retry" | "started" | "waiting">;
+  availableAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  retryAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  retryReason: import("@temelj/standard-schema").Schema<unknown, "missing_implementation" | "step" | "workflow" | undefined>;
+  retryAttempt: import("@temelj/standard-schema").Schema<unknown, number | undefined>;
+  retryStepId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  retryStepName: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  deadlineAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  leaseExpiresAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  startedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  finishedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+}>>;
+export declare const childWorkflowCancellationPolicySchema: import("@temelj/standard-schema").Schema<unknown, "cascade" | "detach">;
+//#endregion

package/dist/schema/run.mjs

@@ -0,0 +1,88 @@
+import { idSchema, nonBlankStringSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, telemetryContextSchema, temporalInstantSchema } from "./common.mjs";
+import { runAttributesSchema } from "../attributes.mjs";
+import { errorRecordSchema } from "./error.mjs";
+import { persistedValueSchema } from "./persisted-value.mjs";
+import { ss } from "@temelj/standard-schema";
+//#region src/schema/run.ts
+const runStatusSchema = ss.picklist([
+	"pending",
+	"running",
+	"waiting",
+	"completed",
+	"failed",
+	"canceled"
+]);
+const terminalRunStatusSchema = ss.picklist([
+	"completed",
+	"failed",
+	"canceled"
+]);
+const runRetryReasonSchema = ss.picklist([
+	"workflow",
+	"step",
+	"missing_implementation"
+]);
+const runTransitionReasonSchema = ss.picklist([
+	"created",
+	"claimed",
+	"reclaimed",
+	"started",
+	"waiting",
+	"rescheduled",
+	"lease_released",
+	"manual_retry",
+	"permanent_failure",
+	"retry",
+	"missing_implementation",
+	"completed",
+	"failed",
+	"deadline",
+	"canceled"
+]);
+const materializedStepTypeSchema = ss.picklist([
+	"run",
+	"sleep",
+	"workflow",
+	"message-send",
+	"message-wait",
+	"stream",
+	"deterministic"
+]);
+const runRecordSchema = ss.object({
+	id: idSchema,
+	namespace: nonBlankStringSchema,
+	workflowName: nonBlankStringSchema,
+	workflowVersion: ss.optional(nonBlankStringSchema),
+	status: runStatusSchema,
+	input: ss.optional(persistedValueSchema),
+	context: ss.optional(persistedValueSchema),
+	telemetryContext: ss.optional(telemetryContextSchema),
+	metadata: ss.optional(persistedValueSchema),
+	attributes: ss.optional(runAttributesSchema),
+	output: ss.optional(persistedValueSchema),
+	error: ss.optional(errorRecordSchema),
+	attempts: ss.optional(nonNegativeSafeIntegerSchema),
+	idempotencyKey: ss.optional(nonBlankStringSchema),
+	parentRunId: ss.optional(idSchema),
+	parentStepId: ss.optional(idSchema),
+	parentStepName: ss.optional(nonBlankStringSchema),
+	parentStepAttempt: ss.optional(positiveSafeIntegerSchema),
+	workerId: ss.optional(idSchema),
+	createdAt: temporalInstantSchema,
+	updatedAt: temporalInstantSchema,
+	lastTransitionAt: temporalInstantSchema,
+	lastTransitionReason: runTransitionReasonSchema,
+	availableAt: ss.optional(temporalInstantSchema),
+	retryAt: ss.optional(temporalInstantSchema),
+	retryReason: ss.optional(runRetryReasonSchema),
+	retryAttempt: ss.optional(positiveSafeIntegerSchema),
+	retryStepId: ss.optional(idSchema),
+	retryStepName: ss.optional(nonBlankStringSchema),
+	deadlineAt: ss.optional(temporalInstantSchema),
+	leaseExpiresAt: ss.optional(temporalInstantSchema),
+	startedAt: ss.optional(temporalInstantSchema),
+	finishedAt: ss.optional(temporalInstantSchema)
+});
+const childWorkflowCancellationPolicySchema = ss.picklist(["cascade", "detach"]);
+//#endregion
+export { childWorkflowCancellationPolicySchema, materializedStepTypeSchema, runRecordSchema, terminalRunStatusSchema };

package/dist/schema/store.d.mts

@@ -0,0 +1,94 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import "../mod.mjs";
+//#region src/schema/store.d.ts
+export declare const lockRecordSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  key: import("@temelj/standard-schema").Schema<unknown, string>;
+  namespace: import("@temelj/standard-schema").Schema<unknown, string>;
+  holderId: import("@temelj/standard-schema").Schema<unknown, string>;
+  holderRunId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  holderStepId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  fencingToken: import("@temelj/standard-schema").Schema<unknown, number>;
+  acquiredAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  leaseExpiresAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  releasedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+}>>;
+export declare const cleanupModeSchema: import("@temelj/standard-schema").Schema<unknown, "best_effort">;
+export declare const cleanupMarkerRecordSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  mode: import("@temelj/standard-schema").Schema<unknown, "best_effort">;
+  runId: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowName: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowVersion: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  status: import("@temelj/standard-schema").Schema<unknown, "canceled" | "completed" | "failed">;
+  createdAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  finishedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  cleanupStartedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  events: import("@temelj/standard-schema").Schema<unknown, number>;
+  stepAttempts: import("@temelj/standard-schema").Schema<unknown, number>;
+  idempotencyKeys: import("@temelj/standard-schema").Schema<unknown, number>;
+  messageIdempotencyKeys: import("@temelj/standard-schema").Schema<unknown, number>;
+}>>;
+export declare const scheduleRecordSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  id: import("@temelj/standard-schema").Schema<unknown, string>;
+  namespace: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowName: import("@temelj/standard-schema").Schema<unknown, string>;
+  workflowVersion: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  input: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  context: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  status: import("@temelj/standard-schema").Schema<unknown, "active" | "archived" | "deleted" | "paused">;
+  every: import("@temelj/standard-schema").Schema<unknown, Temporal.Duration>;
+  catchUp: import("@temelj/standard-schema").Schema<unknown, "all" | "one" | "skip">;
+  maxCatchUpRuns: import("@temelj/standard-schema").Schema<unknown, number | undefined>;
+  maxLateness: import("@temelj/standard-schema").Schema<unknown, Temporal.Duration | undefined>;
+  overlap: import("@temelj/standard-schema").Schema<unknown, "allow" | "buffer" | "cancel" | "skip">;
+  createdAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  updatedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  nextFireAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  endAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  bufferedFireAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  lastFireAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  lastRunId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  tickCount: import("@temelj/standard-schema").Schema<unknown, number>;
+}>>;
+export declare const stepAttemptStatusSchema: import("@temelj/standard-schema").Schema<unknown, "abandoned" | "completed" | "failed" | "running">;
+export declare const stepAttemptRecordSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  runId: import("@temelj/standard-schema").Schema<unknown, string>;
+  stepId: import("@temelj/standard-schema").Schema<unknown, string>;
+  stepName: import("@temelj/standard-schema").Schema<unknown, string>;
+  kind: import("@temelj/standard-schema").Schema<unknown, "deterministic" | "message-send" | "message-wait" | "run" | "sleep" | "stream" | "workflow">;
+  status: import("@temelj/standard-schema").Schema<unknown, "abandoned" | "completed" | "failed" | "running">;
+  attempt: import("@temelj/standard-schema").Schema<unknown, number>;
+  count: import("@temelj/standard-schema").Schema<unknown, number | undefined>;
+  output: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  error: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+    code: import("@temelj/standard-schema").Schema<unknown, WorkflowErrorCode | undefined>;
+    name: import("@temelj/standard-schema").Schema<unknown, string>;
+    message: import("@temelj/standard-schema").Schema<unknown, string>;
+    stack: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+    details: import("@temelj/standard-schema").Schema<unknown, Record<string, string | number | boolean | null | undefined> | undefined>;
+  }> | undefined>;
+  until: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  duration: import("@temelj/standard-schema").Schema<unknown, Temporal.Duration | undefined>;
+  childRunId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  workflowName: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  workflowVersion: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  cancellation: import("@temelj/standard-schema").Schema<unknown, "cascade" | "detach" | undefined>;
+  input: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  timeoutAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  messageId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  targetRunId: import("@temelj/standard-schema").Schema<unknown, string | undefined>;
+  payload: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue | undefined>;
+  messageTimestamp: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+  createdAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  startedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+  finishedAt: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant | undefined>;
+}>>;
+export declare const cleanupIndexKeySchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  key: import("@temelj/standard-schema").Schema<unknown, string>;
+  value: import("@temelj/standard-schema").Schema<unknown, import("@temelj/storage").StorageValue>;
+}>>;
+export declare const messageIdempotencyIndexSchema: import("@temelj/standard-schema").Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  runId: import("@temelj/standard-schema").Schema<unknown, string>;
+  messageId: import("@temelj/standard-schema").Schema<unknown, string>;
+  timestamp: import("@temelj/standard-schema").Schema<unknown, Temporal.Instant>;
+}>>;
+//#endregion