@voltro/protocol 0.84.0 → 0.86.0

package/dist/inspect.d.ts

@@ -1,74 +1,74 @@
 import { ParseOptions } from 'effect/SchemaAST';
 import { Schema } from 'effect';
 
-export declare const decodeInspectBackfillInput: (u: unknown, overrideOptions?: ParseOptions) => {
+export declare const decodeInspectBackfillInput: (input: unknown, options?: ParseOptions) => {
+    readonly requestId: string;
     readonly name: string;
     readonly from: string;
-    readonly limit: number;
     readonly to: string;
-    readonly requestId: string;
     readonly confirm: boolean;
+    readonly limit: number;
 };
 
 export declare type InspectBackfillInput = typeof InspectBackfillInputSchema.Type;
 
 export declare const InspectBackfillInputSchema: Schema.Struct<{
-    requestId: Schema.filter<Schema.filter<typeof Schema.String>>;
-    name: Schema.filter<Schema.filter<typeof Schema.String>>;
-    from: Schema.filter<typeof Schema.String>;
-    to: Schema.filter<typeof Schema.String>;
-    confirm: typeof Schema.Boolean;
-    limit: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly requestId: Schema.String;
+    readonly name: Schema.String;
+    readonly from: Schema.String;
+    readonly to: Schema.String;
+    readonly confirm: Schema.Boolean;
+    readonly limit: Schema.Number;
 }>;
 
 export declare type InspectBackfillReceipt = typeof InspectBackfillReceiptSchema.Type;
 
 export declare const InspectBackfillReceiptSchema: Schema.Struct<{
-    id: Schema.filter<Schema.filter<typeof Schema.String>>;
-    name: Schema.filter<Schema.filter<typeof Schema.String>>;
-    from: Schema.filter<typeof Schema.String>;
-    to: Schema.filter<typeof Schema.String>;
-    occurrences: Schema.Array$<typeof Schema.Number>;
-    status: Schema.Literal<["queued", "running", "completed", "interrupted"]>;
-    owner: Schema.NullOr<typeof Schema.String>;
-    createdAt: Schema.filter<typeof Schema.String>;
-    updatedAt: Schema.filter<typeof Schema.String>;
-    cursor: typeof Schema.Number;
-    activeIndex: Schema.NullOr<typeof Schema.Number>;
-    results: Schema.Array$<Schema.Struct<{
-        runId: Schema.filter<Schema.filter<typeof Schema.String>>;
-        status: Schema.Literal<["succeeded", "failed", "skipped", "missed"]>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly from: Schema.String;
+    readonly to: Schema.String;
+    readonly occurrences: Schema.$Array<Schema.Number>;
+    readonly status: Schema.Literals<readonly ["queued", "running", "completed", "interrupted"]>;
+    readonly owner: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly cursor: Schema.Number;
+    readonly activeIndex: Schema.NullOr<Schema.Number>;
+    readonly results: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "skipped", "missed"]>;
     }>>;
-    error: Schema.NullOr<typeof Schema.String>;
+    readonly error: Schema.NullOr<Schema.String>;
 }>;
 
 export declare type InspectBackfillResult = typeof InspectBackfillResultSchema.Type;
 
-export declare const InspectBackfillResultSchema: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["accepted"]>;
-    request: Schema.Struct<{
-        id: Schema.filter<Schema.filter<typeof Schema.String>>;
-        name: Schema.filter<Schema.filter<typeof Schema.String>>;
-        from: Schema.filter<typeof Schema.String>;
-        to: Schema.filter<typeof Schema.String>;
-        occurrences: Schema.Array$<typeof Schema.Number>;
-        status: Schema.Literal<["queued", "running", "completed", "interrupted"]>;
-        owner: Schema.NullOr<typeof Schema.String>;
-        createdAt: Schema.filter<typeof Schema.String>;
-        updatedAt: Schema.filter<typeof Schema.String>;
-        cursor: typeof Schema.Number;
-        activeIndex: Schema.NullOr<typeof Schema.Number>;
-        results: Schema.Array$<Schema.Struct<{
-            runId: Schema.filter<Schema.filter<typeof Schema.String>>;
-            status: Schema.Literal<["succeeded", "failed", "skipped", "missed"]>;
+export declare const InspectBackfillResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"accepted">;
+    readonly request: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly from: Schema.String;
+        readonly to: Schema.String;
+        readonly occurrences: Schema.$Array<Schema.Number>;
+        readonly status: Schema.Literals<readonly ["queued", "running", "completed", "interrupted"]>;
+        readonly owner: Schema.NullOr<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly cursor: Schema.Number;
+        readonly activeIndex: Schema.NullOr<Schema.Number>;
+        readonly results: Schema.$Array<Schema.Struct<{
+            readonly runId: Schema.String;
+            readonly status: Schema.Literals<readonly ["succeeded", "failed", "skipped", "missed"]>;
         }>>;
-        error: Schema.NullOr<typeof Schema.String>;
+        readonly error: Schema.NullOr<Schema.String>;
     }>;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["refused"]>;
-    name: Schema.filter<Schema.filter<typeof Schema.String>>;
-    occurrences: typeof Schema.Number;
-    reason: typeof Schema.String;
+    readonly kind: Schema.Literal<"refused">;
+    readonly name: Schema.String;
+    readonly occurrences: Schema.Number;
+    readonly reason: Schema.String;
 }>]>;
 
 export declare type InspectCommandRejection = typeof InspectCommandRejectionSchema.Type;
@@ -78,9 +78,9 @@ export declare const inspectCommandRejection: (status: number, message: string)
 /** Explicit non-acceptance from an Inspect command endpoint. Transport errors,
  * conflicts with an earlier request and server failures are not this outcome. */
 export declare const InspectCommandRejectionSchema: Schema.Struct<{
-    kind: Schema.Literal<["rejected"]>;
-    status: Schema.Literal<[400, 401, 403, 404]>;
-    message: typeof Schema.String;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly status: Schema.Literals<readonly [400, 401, 403, 404]>;
+    readonly message: Schema.String;
 }>;
 
 export declare type InspectReplicaSelection = {
@@ -94,75 +94,75 @@ export declare type InspectWorkflowExecutionObservation = typeof InspectWorkflow
 
 /** A projection of engine evidence, not a run-row or recorder-entry claim.
  * Deliberately excludes payloads, outputs, raw causes and journal identifiers. */
-export declare const InspectWorkflowExecutionObservationSchema: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["not-observed"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+export declare const InspectWorkflowExecutionObservationSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"not-observed">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["pending"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"pending">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["delivery-failed"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"delivery-failed">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["suspended"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"suspended">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["completed"]>;
-    outcome: Schema.Literal<["succeeded", "failed", "cancelled"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly kind: Schema.Literal<"completed">;
+    readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>]>;
 
 export declare type InspectWorkflowExecutionTarget = typeof InspectWorkflowExecutionTargetSchema.Type;
 
 /** Read an existing execution identity; this is never a start command. */
 export declare const InspectWorkflowExecutionTargetSchema: Schema.Struct<{
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly executionId: Schema.NonEmptyString;
 }>;
 
 export declare type InspectWorkflowQueuedStartObservation = typeof InspectWorkflowQueuedStartObservationSchema.Type;
 
 /** Read-only admission evidence. Accepted means an execution exists, not that it succeeded. */
-export declare const InspectWorkflowQueuedStartObservationSchema: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["pending"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+export declare const InspectWorkflowQueuedStartObservationSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"pending">;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["accepted"]>;
-    executionId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+    readonly kind: Schema.Literal<"accepted">;
+    readonly executionId: Schema.NonEmptyString;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>, Schema.Struct<{
-    kind: Schema.Literal<["not-executed"]>;
-    reason: Schema.Literal<["dropped", "skipped", "superseded", "cancelled", "abandoned", "rejected"]>;
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+    readonly kind: Schema.Literal<"not-executed">;
+    readonly reason: Schema.Literals<readonly ["dropped", "skipped", "superseded", "cancelled", "abandoned", "rejected"]>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>]>;
 
 export declare type InspectWorkflowQueuedStartTarget = typeof InspectWorkflowQueuedStartTargetSchema.Type;
 
 /** A caller receipt, never an execution or a reusable admission slot. */
 export declare const InspectWorkflowQueuedStartTargetSchema: Schema.Struct<{
-    workflowName: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    receiptId: Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>;
-    tenantId: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyString>>>;
+    readonly workflowName: Schema.NonEmptyString;
+    readonly receiptId: Schema.NonEmptyString;
+    readonly tenantId: Schema.NullOr<Schema.NonEmptyString>;
 }>;
 
 export declare class InvalidReplicaSelection extends Error {
     readonly name = "InvalidReplicaSelection";
 }
 
-export declare const isInspectCommandRejection: (u: unknown, overrideOptions?: ParseOptions | number) => u is {
-    readonly status: 400 | 401 | 403 | 404;
+export declare const isInspectCommandRejection: <I>(input: I) => input is I & {
     readonly kind: "rejected";
+    readonly status: 400 | 401 | 403 | 404;
     readonly message: string;
 };
 

package/dist/inspect.js

@@ -1,206 +1,30 @@
-import { Schema as e } from "effect";
-//#region src/inspectWorkflowQueuedStart.ts
-var t = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(e))), n = e.Struct({
-	workflowName: t,
-	receiptId: t,
-	tenantId: e.NullOr(t)
-}), r = n.fields, i = e.Union(e.Struct({
-	...r,
-	kind: e.Literal("pending")
-}), e.Struct({
-	...r,
-	kind: e.Literal("accepted"),
-	executionId: t
-}), e.Struct({
-	...r,
-	kind: e.Literal("not-executed"),
-	reason: e.Literal("dropped", "skipped", "superseded", "cancelled", "abandoned", "rejected")
-})), a = e.Struct({
-	kind: e.Literal("rejected"),
-	status: e.Literal(400, 401, 403, 404),
-	message: e.String
-}), o = e.is(a), s = (e, t) => {
-	let n = {
-		kind: "rejected",
-		status: e,
-		message: t
-	};
-	return o(n) ? n : void 0;
-}, c = e.String.pipe(e.filter((e) => Number.isFinite(Date.parse(e)))), l = e.String.pipe(e.minLength(1), e.maxLength(256)), u = e.Struct({
-	id: l,
-	name: l,
-	from: c,
-	to: c,
-	occurrences: e.Array(e.Number),
-	status: e.Literal("queued", "running", "completed", "interrupted"),
-	owner: e.NullOr(e.String),
-	createdAt: c,
-	updatedAt: c,
-	cursor: e.Number,
-	activeIndex: e.NullOr(e.Number),
-	results: e.Array(e.Struct({
-		runId: l,
-		status: e.Literal("succeeded", "failed", "skipped", "missed")
-	})),
-	error: e.NullOr(e.String)
-}), d = e.Struct({
-	requestId: l,
-	name: l,
-	from: c,
-	to: c,
-	confirm: e.Boolean,
-	limit: e.Number.pipe(e.int(), e.between(1, 1e4))
-}), f = e.decodeUnknownSync(d), p = e.Union(e.Struct({
-	kind: e.Literal("accepted"),
-	request: u
-}), e.Struct({
-	kind: e.Literal("refused"),
-	name: l,
-	occurrences: e.Number,
-	reason: e.String
-})), m = class extends Error {
-	name = "ScheduleBackfillRequestConflict";
-}, h = e.NonEmptyString.pipe(e.maxLength(1024), e.filter((e) => e.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(e))), g = e.Struct({
-	workflowName: h,
-	executionId: h
-}), _ = g.fields, v = e.Union(e.Struct({
-	..._,
-	kind: e.Literal("not-observed")
-}), e.Struct({
-	..._,
-	kind: e.Literal("pending")
-}), e.Struct({
-	..._,
-	kind: e.Literal("delivery-failed")
-}), e.Struct({
-	..._,
-	kind: e.Literal("suspended")
-}), e.Struct({
-	..._,
-	kind: e.Literal("completed"),
-	outcome: e.Literal("succeeded", "failed", "cancelled")
-})), y = (e) => typeof e == "object" && e && !Array.isArray(e) ? e : void 0, b = (e) => Array.isArray(e) && e.every((e) => y(e) !== void 0) ? e : void 0, x = (e) => typeof e == "number" && Number.isFinite(e) ? e : 0, S = /* @__PURE__ */ new Set([
-	"counter",
-	"gauge",
-	"histogram",
-	"summary",
-	"frequency"
-]), C = (e) => {
-	let t = b(e);
-	return t?.every((e) => typeof e.name == "string" && S.has(String(e.type))) ? t : void 0;
-}, w = (e) => {
-	let t = y(e), n = y(t?.data), r = b(n?.results);
-	if (!t || !n?.selection || !r) return e;
-	let i = r.filter((e) => e.status === "answered").map((e) => ({
-		replicaId: String(e.replicaId),
-		observation: y(e.observation),
-		data: y(e.observation)?.data
-	}));
-	if (i.length === 0) throw Error("None of the selected replicas answered. Check replica availability and retry.");
-	let a = i.map((e) => ({
-		...e,
-		object: y(e.data)
-	})), o = (e) => a.reduce((t, n) => t + x(n.object?.[e]), 0), s = Math.max(...i.map((e) => x(e.observation?.capturedAt))), c = {
-		capturedAt: s,
-		bufferSize: o("bufferSize"),
-		bufferCapacity: o("bufferCapacity")
-	}, l;
-	if (a.every((e) => b(e.object?.records))) {
-		let e = a.flatMap((e) => b(e.object?.records).map((t) => ({
-			...t,
-			fields: {
-				...y(t.fields),
-				"voltro.replica": e.replicaId
-			}
-		}))).sort((e, t) => x(e.ts) - x(t.ts));
-		l = {
-			...c,
-			returned: e.length,
-			records: e
-		};
-	} else if (a.every((e) => b(e.object?.traces))) {
-		let e = /* @__PURE__ */ new Map();
-		for (let t of a) for (let n of b(t.object?.traces)) {
-			let r = String(n.traceId), i = (b(n.spans) ?? []).map((e) => ({
-				...e,
-				attributes: {
-					...y(e.attributes),
-					"voltro.replica": t.replicaId
-				}
-			})), a = e.get(r) ?? [];
-			a.push({
-				...n,
-				spans: i
-			}), e.set(r, a);
-		}
-		let t = [...e.values()].map((e) => {
-			let t = e.flatMap((e) => b(e.spans) ?? []).sort((e, t) => x(e.startMs) - x(t.startMs)), n = [...e].sort((e, t) => x(e.startMs) - x(t.startMs))[0], r = Math.min(...e.map((e) => x(e.startMs))), i = Math.max(...e.map((e) => x(e.startMs) + x(e.durationMs)));
-			return {
-				...n,
-				startMs: r,
-				durationMs: Math.max(0, i - r),
-				spanCount: t.length,
-				hasError: e.some((e) => e.hasError === !0),
-				spans: t,
-				...e.some((e) => e.deliveryCount !== void 0) ? { deliveryCount: e.reduce((e, t) => e + x(t.deliveryCount), 0) } : {},
-				...e.some((e) => e.lastDeliveryMs !== void 0) ? { lastDeliveryMs: Math.max(...e.map((e) => x(e.lastDeliveryMs))) } : {}
-			};
-		}).sort((e, t) => t.startMs - e.startMs);
-		l = {
-			...c,
-			returned: t.length,
-			traces: t
-		};
-	} else if (a.every((e) => b(e.object?.buckets) && typeof e.object?.windowMs == "number")) l = {
-		capturedAt: s,
-		windowMs: Math.max(...a.map((e) => x(e.object?.windowMs))),
-		totalSamples: o("totalSamples"),
-		buckets: a.flatMap((e) => b(e.object?.buckets).map((t) => ({
-			...t,
-			tag: `${String(t.tag)} [${e.replicaId}]`
-		})))
-	};
-	else if (i.every((e) => C(e.data))) l = i.flatMap((e) => C(e.data).map((t) => ({
-		...t,
-		labels: {
-			...y(t.labels),
-			voltro_replica: e.replicaId
-		}
-	})));
-	else if (a.every((e) => C(e.object?.samples))) l = { samples: a.flatMap((e) => C(e.object?.samples).map((t) => ({
-		...t,
-		labels: {
-			...y(t.labels),
-			voltro_replica: e.replicaId
-		}
-	}))) };
-	else if (r.length === 1 && i.length === 1) l = i[0].data;
-	else throw Error("This view must compare observations per replica; its values cannot be safely combined.");
-	return {
-		...t,
-		data: l
-	};
-}, T = class extends Error {
+import { InspectWorkflowQueuedStartObservationSchema as e, InspectWorkflowQueuedStartTargetSchema as t } from "./inspectWorkflowQueuedStart.js";
+import { InspectCommandRejectionSchema as n, inspectCommandRejection as r, isInspectCommandRejection as i } from "./inspectCommandRejection.js";
+import { InspectBackfillInputSchema as a, InspectBackfillReceiptSchema as o, InspectBackfillResultSchema as s, ScheduleBackfillRequestConflict as c, decodeInspectBackfillInput as l } from "./inspectBackfill.js";
+import { InspectWorkflowExecutionObservationSchema as u, InspectWorkflowExecutionTargetSchema as d } from "./inspectWorkflowExecution.js";
+import { projectReplicaObservation as f } from "./inspectProjection.js";
+//#region src/inspectSelection.ts
+var p = class extends Error {
 	name = "InvalidReplicaSelection";
-}, E = (e) => {
+}, m = (e) => {
 	let t = e.getAll("replicas"), n = e.getAll("replica");
 	if (t.length !== 0 || n.length !== 0) {
-		if (t.length > 1 || t.length === 1 && t[0] !== "all" || t.length > 0 && n.length > 0) throw new T("Choose all replicas or explicit replica IDs, not both.");
+		if (t.length > 1 || t.length === 1 && t[0] !== "all" || t.length > 0 && n.length > 0) throw new p("Choose all replicas or explicit replica IDs, not both.");
 		if (t[0] === "all") return { mode: "all" };
-		if (n.some((e) => e.trim().length === 0 || e.length > 512 || /[\u0000-\u001f\u007f]/.test(e))) throw new T("Replica IDs must be nonempty and contain no control characters.");
+		if (n.some((e) => e.trim().length === 0 || e.length > 512 || /[\u0000-\u001f\u007f]/.test(e))) throw new p("Replica IDs must be nonempty and contain no control characters.");
 		return {
 			mode: "selected",
 			replicaIds: [...new Set(n)].sort()
 		};
 	}
-}, D = (e, t) => {
+}, h = (e, t) => {
 	let n = e.indexOf("#"), r = n < 0 ? "" : e.slice(n), i = n < 0 ? e : e.slice(0, n), a = i.indexOf("?"), o = a < 0 ? i : i.slice(0, a), s = new URLSearchParams(a < 0 ? "" : i.slice(a + 1));
 	if (s.delete("replica"), s.delete("replicas"), t.mode === "all") s.set("replicas", "all");
 	else {
-		if (t.replicaIds.length === 0) throw new T("Select at least one replica.");
+		if (t.replicaIds.length === 0) throw new p("Select at least one replica.");
 		for (let e of [...new Set(t.replicaIds)].sort()) s.append("replica", e);
 	}
-	return E(s), `${o}?${s}${r}`;
+	return m(s), `${o}?${s}${r}`;
 };
 //#endregion
-export { d as InspectBackfillInputSchema, u as InspectBackfillReceiptSchema, p as InspectBackfillResultSchema, a as InspectCommandRejectionSchema, v as InspectWorkflowExecutionObservationSchema, g as InspectWorkflowExecutionTargetSchema, i as InspectWorkflowQueuedStartObservationSchema, n as InspectWorkflowQueuedStartTargetSchema, T as InvalidReplicaSelection, m as ScheduleBackfillRequestConflict, f as decodeInspectBackfillInput, s as inspectCommandRejection, o as isInspectCommandRejection, E as parseReplicaSelection, w as projectReplicaObservation, D as withReplicaSelection };
+export { a as InspectBackfillInputSchema, o as InspectBackfillReceiptSchema, s as InspectBackfillResultSchema, n as InspectCommandRejectionSchema, u as InspectWorkflowExecutionObservationSchema, d as InspectWorkflowExecutionTargetSchema, e as InspectWorkflowQueuedStartObservationSchema, t as InspectWorkflowQueuedStartTargetSchema, p as InvalidReplicaSelection, c as ScheduleBackfillRequestConflict, l as decodeInspectBackfillInput, r as inspectCommandRejection, i as isInspectCommandRejection, m as parseReplicaSelection, f as projectReplicaObservation, h as withReplicaSelection };

package/dist/inspectBackfill.js

@@ -0,0 +1,52 @@
+import { Schema as e } from "effect";
+//#region src/inspectBackfill.ts
+var t = e.String.pipe(e.check(e.makeFilter((e) => Number.isFinite(Date.parse(e))))), n = e.String.pipe(e.check(e.isMinLength(1)), e.check(e.isMaxLength(256))), r = e.Struct({
+	id: n,
+	name: n,
+	from: t,
+	to: t,
+	occurrences: e.Array(e.Number),
+	status: e.Literals([
+		"queued",
+		"running",
+		"completed",
+		"interrupted"
+	]),
+	owner: e.NullOr(e.String),
+	createdAt: t,
+	updatedAt: t,
+	cursor: e.Number,
+	activeIndex: e.NullOr(e.Number),
+	results: e.Array(e.Struct({
+		runId: n,
+		status: e.Literals([
+			"succeeded",
+			"failed",
+			"skipped",
+			"missed"
+		])
+	})),
+	error: e.NullOr(e.String)
+}), i = e.Struct({
+	requestId: n,
+	name: n,
+	from: t,
+	to: t,
+	confirm: e.Boolean,
+	limit: e.Number.pipe(e.check(e.isInt()), e.check(e.isBetween({
+		minimum: 1,
+		maximum: 1e4
+	})))
+}), a = e.decodeUnknownSync(i), o = e.Union([e.Struct({
+	kind: e.Literal("accepted"),
+	request: r
+}), e.Struct({
+	kind: e.Literal("refused"),
+	name: n,
+	occurrences: e.Number,
+	reason: e.String
+})]), s = class extends Error {
+	name = "ScheduleBackfillRequestConflict";
+};
+//#endregion
+export { i as InspectBackfillInputSchema, r as InspectBackfillReceiptSchema, o as InspectBackfillResultSchema, s as ScheduleBackfillRequestConflict, a as decodeInspectBackfillInput };

package/dist/inspectCommandRejection.js

@@ -0,0 +1,21 @@
+import { Schema as e } from "effect";
+//#region src/inspectCommandRejection.ts
+var t = e.Struct({
+	kind: e.Literal("rejected"),
+	status: e.Literals([
+		400,
+		401,
+		403,
+		404
+	]),
+	message: e.String
+}), n = e.is(t), r = (e, t) => {
+	let r = {
+		kind: "rejected",
+		status: e,
+		message: t
+	};
+	return n(r) ? r : void 0;
+};
+//#endregion
+export { t as InspectCommandRejectionSchema, r as inspectCommandRejection, n as isInspectCommandRejection };