@kortyx/telemetry-contracts 0.1.0 → 0.2.0

package/dist/index.js

@@ -21,13 +21,57 @@ var index_exports = {};
 __export(index_exports, {
   EnsureWorkflowTopologyRequestSchema: () => EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema: () => EnsureWorkflowTopologyResponseSchema,
+  STUDIO_TIME_RANGES: () => STUDIO_TIME_RANGES,
+  StudioCatalogsResponseSchema: () => StudioCatalogsResponseSchema,
+  StudioChangeResourceSchema: () => StudioChangeResourceSchema,
+  StudioChangeSchema: () => StudioChangeSchema,
+  StudioContextResponseSchema: () => StudioContextResponseSchema,
+  StudioDetailEventSchema: () => StudioDetailEventSchema,
+  StudioInterruptDetailResponseSchema: () => StudioInterruptDetailResponseSchema,
+  StudioInterruptInteractionModeSchema: () => StudioInterruptInteractionModeSchema,
+  StudioInterruptOptionSchema: () => StudioInterruptOptionSchema,
+  StudioInterruptSchema: () => StudioInterruptSchema,
+  StudioInterruptStatusSchema: () => StudioInterruptStatusSchema,
+  StudioInterruptTypeSchema: () => StudioInterruptTypeSchema,
+  StudioInterruptsResponseSchema: () => StudioInterruptsResponseSchema,
+  StudioMetricSchema: () => StudioMetricSchema,
+  StudioPricingSourceSchema: () => StudioPricingSourceSchema,
+  StudioPricingStatusSchema: () => StudioPricingStatusSchema,
+  StudioResumeOutcomeSchema: () => StudioResumeOutcomeSchema,
+  StudioRunDetailResponseSchema: () => StudioRunDetailResponseSchema,
+  StudioRunSchema: () => StudioRunSchema,
+  StudioRunStatusSchema: () => StudioRunStatusSchema,
+  StudioRunsResponseSchema: () => StudioRunsResponseSchema,
+  StudioSessionDetailResponseSchema: () => StudioSessionDetailResponseSchema,
+  StudioSessionSchema: () => StudioSessionSchema,
+  StudioSessionsResponseSchema: () => StudioSessionsResponseSchema,
+  StudioTimeRangeContextSchema: () => StudioTimeRangeContextSchema,
+  StudioTimeRangeQuerySchema: () => StudioTimeRangeQuerySchema,
+  StudioTimeRangeSchema: () => StudioTimeRangeSchema,
+  StudioWorkflowHealthSchema: () => StudioWorkflowHealthSchema,
+  StudioWorkflowInternalEdgeSchema: () => StudioWorkflowInternalEdgeSchema,
+  StudioWorkflowNodeSchema: () => StudioWorkflowNodeSchema,
+  StudioWorkflowSchema: () => StudioWorkflowSchema,
+  StudioWorkflowTransitionSchema: () => StudioWorkflowTransitionSchema,
+  StudioWorkflowsResponseSchema: () => StudioWorkflowsResponseSchema,
   TELEMETRY_EVENT_TYPES: () => TELEMETRY_EVENT_TYPES,
+  TelemetryEventBatchResponseSchema: () => TelemetryEventBatchResponseSchema,
   TelemetryEventBatchSchema: () => TelemetryEventBatchSchema,
   TelemetryEventSchema: () => TelemetryEventSchema,
   TelemetryEventTypeSchema: () => TelemetryEventTypeSchema,
+  TelemetryPricingHintSchema: () => TelemetryPricingHintSchema,
+  TelemetryPricingLineItemSchema: () => TelemetryPricingLineItemSchema,
+  TelemetryPricingSourceSchema: () => TelemetryPricingSourceSchema,
+  TelemetryPricingUnitSchema: () => TelemetryPricingUnitSchema,
+  TelemetryPricingUsageTypeSchema: () => TelemetryPricingUsageTypeSchema,
   TelemetryServiceSchema: () => TelemetryServiceSchema,
+  TelemetryUnitPriceSchema: () => TelemetryUnitPriceSchema,
+  TelemetryUsageItemSchema: () => TelemetryUsageItemSchema,
   WorkflowTopologyEdgeSchema: () => WorkflowTopologyEdgeSchema,
-  WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema
+  WorkflowTopologyNodeSchema: () => WorkflowTopologyNodeSchema,
+  WorkflowTopologyTransitionSchema: () => WorkflowTopologyTransitionSchema,
+  resolveStudioInterruptStatus: () => resolveStudioInterruptStatus,
+  resolveStudioTimeRange: () => resolveStudioTimeRange
 });
 module.exports = __toCommonJS(index_exports);
 var import_zod = require("zod");
@@ -66,6 +110,12 @@ var WorkflowTopologyEdgeSchema = import_zod.z.object({
   targetNodeId: import_zod.z.string().min(1),
   condition: import_zod.z.string().optional()
 }).strict();
+var WorkflowTopologyTransitionSchema = import_zod.z.object({
+  sourceNodeId: import_zod.z.string().min(1).optional(),
+  targetWorkflowId: import_zod.z.string().min(1),
+  condition: import_zod.z.string().optional(),
+  intent: import_zod.z.string().optional()
+}).strict();
 var EnsureWorkflowTopologyRequestSchema = import_zod.z.object({
   schemaVersion: import_zod.z.literal(1),
   environment: import_zod.z.string().min(1),
@@ -77,7 +127,8 @@ var EnsureWorkflowTopologyRequestSchema = import_zod.z.object({
     tags: import_zod.z.array(import_zod.z.string()).optional(),
     topologyHash: import_zod.z.string().regex(/^[a-f0-9]{64}$/),
     nodes: import_zod.z.array(WorkflowTopologyNodeSchema),
-    edges: import_zod.z.array(WorkflowTopologyEdgeSchema)
+    edges: import_zod.z.array(WorkflowTopologyEdgeSchema),
+    transitions: import_zod.z.array(WorkflowTopologyTransitionSchema).optional()
   }).strict()
 }).strict();
 var EnsureWorkflowTopologyResponseSchema = import_zod.z.object({ workflowRevisionId: import_zod.z.string().min(1), created: import_zod.z.boolean() }).strict();
@@ -109,16 +160,536 @@ var TelemetryEventSchema = import_zod.z.object({
   payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
 }).strict();
 var TelemetryEventBatchSchema = import_zod.z.object({ events: import_zod.z.array(TelemetryEventSchema).min(1) }).strict();
+var TelemetryEventBatchResponseSchema = import_zod.z.object({
+  accepted: import_zod.z.number().int().nonnegative(),
+  inserted: import_zod.z.number().int().nonnegative(),
+  duplicates: import_zod.z.number().int().nonnegative()
+}).strict();
+var TelemetryPricingSourceSchema = import_zod.z.enum([
+  "sdk",
+  "provider",
+  "custom",
+  "project-rate-card",
+  "default-rate-card"
+]);
+var TelemetryPricingUnitSchema = import_zod.z.enum([
+  "token",
+  "character",
+  "request",
+  "image",
+  "audio_second",
+  "audio_minute",
+  "video_second",
+  "video_minute",
+  "second",
+  "minute",
+  "custom"
+]);
+var TelemetryPricingUsageTypeSchema = import_zod.z.enum([
+  "input",
+  "output",
+  "reasoning",
+  "cache_read",
+  "cache_write",
+  "embedding",
+  "image_input",
+  "image_output",
+  "audio_input",
+  "audio_output",
+  "video_input",
+  "video_output",
+  "request",
+  "custom"
+]);
+var TelemetryUsageItemSchema = import_zod.z.object({
+  usageType: TelemetryPricingUsageTypeSchema,
+  quantity: import_zod.z.number().nonnegative(),
+  unit: TelemetryPricingUnitSchema,
+  label: import_zod.z.string().optional()
+}).strict();
+var TelemetryUnitPriceSchema = import_zod.z.object({
+  usageType: TelemetryPricingUsageTypeSchema,
+  unit: TelemetryPricingUnitSchema,
+  unitQuantity: import_zod.z.number().positive().default(1),
+  priceMicros: import_zod.z.number().int().nonnegative(),
+  label: import_zod.z.string().optional()
+}).strict();
+var TelemetryPricingLineItemSchema = import_zod.z.object({
+  usageType: TelemetryPricingUsageTypeSchema,
+  quantity: import_zod.z.number().nonnegative(),
+  unit: TelemetryPricingUnitSchema,
+  unitQuantity: import_zod.z.number().positive().default(1),
+  unitPriceMicros: import_zod.z.number().int().nonnegative().optional(),
+  totalCostMicros: import_zod.z.number().int().nonnegative().optional(),
+  label: import_zod.z.string().optional()
+}).strict().refine(
+  (value) => value.totalCostMicros !== void 0 || value.unitPriceMicros !== void 0,
+  "line item requires totalCostMicros or unitPriceMicros"
+);
+var TelemetryPricingHintSchema = import_zod.z.object({
+  source: TelemetryPricingSourceSchema.extract(["sdk", "provider", "custom"]),
+  currency: import_zod.z.string().min(3).max(12).default("USD"),
+  actualCostMicros: import_zod.z.number().int().nonnegative().optional(),
+  lineItems: import_zod.z.array(TelemetryPricingLineItemSchema).optional(),
+  unitPrices: import_zod.z.array(TelemetryUnitPriceSchema).optional(),
+  usageItems: import_zod.z.array(TelemetryUsageItemSchema).optional(),
+  pricingRef: import_zod.z.string().min(1).optional(),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+}).strict();
+var StudioRunStatusSchema = import_zod.z.enum([
+  "running",
+  "completed",
+  "interrupted",
+  "incomplete",
+  "failed",
+  "cancelled"
+]);
+var STUDIO_TIME_RANGES = [
+  "Last hour",
+  "24 hours",
+  "7 days",
+  "30 days",
+  "All time",
+  "Custom range"
+];
+var StudioTimeRangeSchema = import_zod.z.enum(STUDIO_TIME_RANGES);
+var StudioTimeRangeQuerySchema = import_zod.z.object({
+  range: StudioTimeRangeSchema.optional(),
+  startedAfter: import_zod.z.string().optional(),
+  startedBefore: import_zod.z.string().optional()
+}).strict();
+var StudioTimeRangeContextSchema = import_zod.z.object({
+  range: StudioTimeRangeSchema,
+  startedAfter: import_zod.z.string().datetime({ offset: true }).nullable(),
+  startedBefore: import_zod.z.string().datetime({ offset: true }).nullable()
+}).strict();
+var STUDIO_TIME_RANGE_MILLISECONDS = {
+  "Last hour": 60 * 60 * 1e3,
+  "24 hours": 24 * 60 * 60 * 1e3,
+  "7 days": 7 * 24 * 60 * 60 * 1e3,
+  "30 days": 30 * 24 * 60 * 60 * 1e3
+};
+var parseIsoBoundary = (value, label) => {
+  if (!value) {
+    return { ok: false, error: `${label} is required for a custom range.` };
+  }
+  if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(value)) {
+    return {
+      ok: false,
+      error: `${label} must include an explicit UTC offset.`
+    };
+  }
+  const date = new Date(value);
+  return Number.isFinite(date.getTime()) ? { ok: true, date } : { ok: false, error: `${label} must be a valid ISO date and time.` };
+};
+var resolveStudioTimeRange = (input, now = /* @__PURE__ */ new Date()) => {
+  const parsedRange = StudioTimeRangeSchema.safeParse(
+    input.range || "24 hours"
+  );
+  if (!parsedRange.success) {
+    return {
+      ok: false,
+      error: `Unknown time range "${input.range}".`
+    };
+  }
+  if (!Number.isFinite(now.getTime())) {
+    return { ok: false, error: "The time range reference date is invalid." };
+  }
+  const range = parsedRange.data;
+  if (range === "All time") {
+    return {
+      ok: true,
+      value: { range, startedAfter: null, startedBefore: null }
+    };
+  }
+  if (range === "Custom range") {
+    const after = parseIsoBoundary(input.startedAfter, "Start time");
+    if ("error" in after) return { ok: false, error: after.error };
+    const before = parseIsoBoundary(input.startedBefore, "End time");
+    if ("error" in before) return { ok: false, error: before.error };
+    if (after.date.getTime() >= before.date.getTime()) {
+      return {
+        ok: false,
+        error: "Start time must be before end time."
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        range,
+        startedAfter: after.date.toISOString(),
+        startedBefore: before.date.toISOString()
+      }
+    };
+  }
+  const duration = STUDIO_TIME_RANGE_MILLISECONDS[range];
+  if (!duration) {
+    return { ok: false, error: `Unknown time range "${range}".` };
+  }
+  return {
+    ok: true,
+    value: {
+      range,
+      startedAfter: new Date(now.getTime() - duration).toISOString(),
+      startedBefore: now.toISOString()
+    }
+  };
+};
+var StudioInterruptStatusSchema = import_zod.z.enum([
+  "pending",
+  "resolved",
+  "expired",
+  "failed",
+  "cancelled"
+]);
+var resolveStudioInterruptStatus = (input, now = Date.now()) => {
+  if (input.status !== "pending" || !input.expiresAt) return input.status;
+  const expiresAt = Date.parse(input.expiresAt);
+  const nowMs = typeof now === "number" ? now : now.getTime();
+  return Number.isFinite(expiresAt) && Number.isFinite(nowMs) && expiresAt <= nowMs ? "expired" : input.status;
+};
+var StudioInterruptTypeSchema = import_zod.z.enum([
+  "choice",
+  "multi-choice",
+  "text",
+  "unknown"
+]);
+var StudioInterruptInteractionModeSchema = import_zod.z.enum([
+  "static-options",
+  "dynamic-picker",
+  "freeform",
+  "unknown"
+]);
+var StudioInterruptOptionSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  label: import_zod.z.string().min(1),
+  description: import_zod.z.string().nullable()
+}).strict();
+var StudioResumeOutcomeSchema = import_zod.z.enum([
+  "resumed",
+  "resume failed",
+  "expired before resume",
+  "cancelled"
+]);
+var StudioWorkflowHealthSchema = import_zod.z.enum([
+  "unknown",
+  "healthy",
+  "degraded",
+  "failing",
+  "idle"
+]);
+var StudioPricingStatusSchema = import_zod.z.enum([
+  "priced",
+  "unpriced",
+  "unknown"
+]);
+var StudioPricingSourceSchema = TelemetryPricingSourceSchema.nullable();
+var StudioChangeResourceSchema = import_zod.z.enum([
+  "runs",
+  "sessions",
+  "interrupts"
+]);
+var StudioChangeSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(1),
+  changeId: import_zod.z.string().min(1),
+  emittedAt: import_zod.z.string().datetime({ offset: true }),
+  organizationId: import_zod.z.string().min(1),
+  projectId: import_zod.z.string().min(1),
+  resources: import_zod.z.array(StudioChangeResourceSchema).min(1)
+}).strict();
+var StudioMetricSchema = import_zod.z.object({
+  runCount: import_zod.z.number().int().nonnegative(),
+  successRate: import_zod.z.number().min(0).max(100).nullable(),
+  errorRate: import_zod.z.number().min(0).max(100).nullable(),
+  retryCount: import_zod.z.number().int().nonnegative().nullable(),
+  interruptRate: import_zod.z.number().min(0).max(100).nullable(),
+  p50DurationMs: import_zod.z.number().nonnegative().nullable(),
+  p95DurationMs: import_zod.z.number().nonnegative().nullable(),
+  averageTokens: import_zod.z.number().nonnegative().nullable(),
+  averageCost: import_zod.z.number().nonnegative().nullable(),
+  currency: import_zod.z.string().nullable()
+}).strict();
+var StudioRunSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  status: StudioRunStatusSchema,
+  startedAt: import_zod.z.string().datetime({ offset: true }),
+  endedAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  workflowId: import_zod.z.string().min(1),
+  workflowIds: import_zod.z.array(import_zod.z.string().min(1)),
+  workflowRefs: import_zod.z.array(
+    import_zod.z.object({
+      workflowId: import_zod.z.string().min(1),
+      workflowRevisionId: import_zod.z.string().nullable(),
+      declaredVersion: import_zod.z.string().nullable()
+    }).strict()
+  ),
+  workflowRevisionId: import_zod.z.string().nullable(),
+  declaredVersion: import_zod.z.string().nullable(),
+  transitionIds: import_zod.z.array(import_zod.z.string().min(1)),
+  path: import_zod.z.array(import_zod.z.string()),
+  sessionId: import_zod.z.string().nullable(),
+  provider: import_zod.z.string().nullable(),
+  model: import_zod.z.string().nullable(),
+  models: import_zod.z.array(import_zod.z.string()),
+  durationMs: import_zod.z.number().nonnegative().nullable(),
+  tokens: import_zod.z.number().int().nonnegative().nullable(),
+  cost: import_zod.z.number().nonnegative().nullable(),
+  pricingStatus: StudioPricingStatusSchema,
+  pricingSource: StudioPricingSourceSchema,
+  currency: import_zod.z.string().nullable(),
+  result: import_zod.z.string().nullable(),
+  environment: import_zod.z.string().min(1),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  hasTool: import_zod.z.boolean(),
+  hasRetry: import_zod.z.boolean(),
+  interruptNodeId: import_zod.z.string().nullable(),
+  interruptId: import_zod.z.string().nullable().optional(),
+  interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
+  interruptExpiresAt: import_zod.z.string().datetime({ offset: true }).nullable().optional()
+}).strict();
+var StudioSessionSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  status: StudioRunStatusSchema,
+  lastActivityAt: import_zod.z.string().datetime({ offset: true }),
+  workflowIds: import_zod.z.array(import_zod.z.string()),
+  workflowCount: import_zod.z.number().int().nonnegative(),
+  activeWorkflowId: import_zod.z.string().nullable(),
+  activeVersion: import_zod.z.string().nullable(),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  runs: import_zod.z.number().int().nonnegative(),
+  succeeded: import_zod.z.number().int().nonnegative(),
+  failed: import_zod.z.number().int().nonnegative(),
+  interrupted: import_zod.z.number().int().nonnegative(),
+  checkpoints: import_zod.z.number().int().nonnegative(),
+  hasFork: import_zod.z.boolean(),
+  durationMs: import_zod.z.number().nonnegative().nullable(),
+  tokens: import_zod.z.number().int().nonnegative().nullable(),
+  cost: import_zod.z.number().nonnegative().nullable(),
+  pricingStatus: StudioPricingStatusSchema,
+  pricingSource: StudioPricingSourceSchema,
+  currency: import_zod.z.string().nullable(),
+  latestResult: import_zod.z.string().nullable(),
+  latestError: import_zod.z.string().nullable(),
+  pendingInterruptId: import_zod.z.string().nullable(),
+  interruptStatus: StudioInterruptStatusSchema.nullable().optional(),
+  interruptExpiresAt: import_zod.z.string().datetime({ offset: true }).nullable().optional(),
+  providers: import_zod.z.array(import_zod.z.string()),
+  models: import_zod.z.array(import_zod.z.string()),
+  tags: import_zod.z.array(import_zod.z.string()),
+  environment: import_zod.z.string().min(1)
+}).strict();
+var StudioInterruptSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  status: StudioInterruptStatusSchema,
+  type: StudioInterruptTypeSchema,
+  interactionMode: StudioInterruptInteractionModeSchema,
+  schemaId: import_zod.z.string().nullable(),
+  schemaVersion: import_zod.z.string().nullable(),
+  createdAt: import_zod.z.string().datetime({ offset: true }),
+  resolvedAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  expiresAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  question: import_zod.z.string().nullable(),
+  contentCaptured: import_zod.z.boolean(),
+  optionCount: import_zod.z.number().int().nonnegative().nullable(),
+  options: import_zod.z.array(StudioInterruptOptionSchema).nullable(),
+  workflowId: import_zod.z.string().min(1),
+  nodeId: import_zod.z.string().nullable(),
+  sessionId: import_zod.z.string().nullable(),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  response: import_zod.z.string().nullable(),
+  responseCaptured: import_zod.z.boolean(),
+  resumeOutcome: StudioResumeOutcomeSchema.nullable(),
+  resumeError: import_zod.z.string().nullable(),
+  runId: import_zod.z.string().min(1),
+  resumeToken: import_zod.z.string().nullable(),
+  resolvedBy: import_zod.z.string().nullable(),
+  environment: import_zod.z.string().min(1)
+}).strict();
+var StudioDetailEventSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  type: TelemetryEventTypeSchema,
+  occurredAt: import_zod.z.string().datetime({ offset: true }),
+  receivedAt: import_zod.z.string().datetime({ offset: true }),
+  environment: import_zod.z.string().min(1),
+  serviceName: import_zod.z.string().min(1),
+  deploymentRef: import_zod.z.string().nullable(),
+  traceId: import_zod.z.string().nullable(),
+  spanId: import_zod.z.string().nullable(),
+  parentSpanId: import_zod.z.string().nullable(),
+  runId: import_zod.z.string().min(1),
+  sessionId: import_zod.z.string().nullable(),
+  workflowId: import_zod.z.string().min(1),
+  workflowRevisionId: import_zod.z.string().nullable(),
+  nodeId: import_zod.z.string().nullable(),
+  userId: import_zod.z.string().nullable(),
+  tenantId: import_zod.z.string().nullable(),
+  tags: import_zod.z.array(import_zod.z.string()),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).nullable(),
+  payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
+}).strict();
+var StudioWorkflowNodeSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  label: import_zod.z.string(),
+  type: import_zod.z.string().nullable(),
+  state: import_zod.z.enum(["healthy", "warning", "failed", "interrupted", "retried"]).nullable(),
+  provider: import_zod.z.string().nullable(),
+  model: import_zod.z.string().nullable(),
+  metrics: StudioMetricSchema
+}).strict();
+var StudioWorkflowInternalEdgeSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  source: import_zod.z.string().min(1),
+  target: import_zod.z.string().min(1),
+  condition: import_zod.z.string().nullable()
+}).strict();
+var StudioWorkflowTransitionSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  sourceWorkflowId: import_zod.z.string().min(1),
+  sourceNodeId: import_zod.z.string().nullable(),
+  targetWorkflowId: import_zod.z.string().min(1),
+  condition: import_zod.z.string().nullable(),
+  volume: import_zod.z.number().int().nonnegative(),
+  successRate: import_zod.z.number().min(0).max(100).nullable(),
+  medianDurationMs: import_zod.z.number().nonnegative().nullable(),
+  errorRate: import_zod.z.number().min(0).max(100).nullable()
+}).strict();
+var StudioWorkflowSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  name: import_zod.z.string().min(1),
+  description: import_zod.z.string().nullable(),
+  versions: import_zod.z.array(import_zod.z.string()),
+  activeVersion: import_zod.z.string().nullable(),
+  activeRevisionId: import_zod.z.string().nullable(),
+  health: StudioWorkflowHealthSchema,
+  tags: import_zod.z.array(import_zod.z.string()),
+  lastActivityAt: import_zod.z.string().datetime({ offset: true }).nullable(),
+  metrics: StudioMetricSchema,
+  nodes: import_zod.z.array(StudioWorkflowNodeSchema),
+  internalEdges: import_zod.z.array(StudioWorkflowInternalEdgeSchema)
+}).strict();
+var StudioRunsResponseSchema = import_zod.z.object({
+  runs: import_zod.z.array(StudioRunSchema),
+  totalCount: import_zod.z.number().int().nonnegative()
+}).strict();
+var StudioSessionsResponseSchema = import_zod.z.object({
+  sessions: import_zod.z.array(StudioSessionSchema),
+  totalCount: import_zod.z.number().int().nonnegative()
+}).strict();
+var StudioInterruptsResponseSchema = import_zod.z.object({
+  interrupts: import_zod.z.array(StudioInterruptSchema),
+  totalCount: import_zod.z.number().int().nonnegative()
+}).strict();
+var StudioRunDetailResponseSchema = import_zod.z.object({
+  run: StudioRunSchema,
+  events: import_zod.z.array(StudioDetailEventSchema),
+  session: StudioSessionSchema.nullable(),
+  interrupts: import_zod.z.array(StudioInterruptSchema),
+  updatedAt: import_zod.z.string().datetime({ offset: true })
+}).strict();
+var StudioSessionDetailResponseSchema = import_zod.z.object({
+  session: StudioSessionSchema,
+  runs: import_zod.z.array(StudioRunSchema),
+  events: import_zod.z.array(StudioDetailEventSchema),
+  interrupts: import_zod.z.array(StudioInterruptSchema),
+  updatedAt: import_zod.z.string().datetime({ offset: true })
+}).strict();
+var StudioInterruptDetailResponseSchema = import_zod.z.object({
+  interrupt: StudioInterruptSchema,
+  events: import_zod.z.array(StudioDetailEventSchema),
+  run: StudioRunSchema.nullable(),
+  session: StudioSessionSchema.nullable(),
+  updatedAt: import_zod.z.string().datetime({ offset: true })
+}).strict();
+var StudioWorkflowsResponseSchema = import_zod.z.object({
+  workflows: import_zod.z.array(StudioWorkflowSchema),
+  transitions: import_zod.z.array(StudioWorkflowTransitionSchema),
+  cohort: StudioTimeRangeContextSchema.extend({
+    workflowId: import_zod.z.string().nullable(),
+    version: import_zod.z.string().nullable()
+  }).strict()
+}).strict();
+var StudioCatalogsResponseSchema = import_zod.z.object({
+  environments: import_zod.z.array(import_zod.z.string()),
+  providers: import_zod.z.array(import_zod.z.string()),
+  models: import_zod.z.array(import_zod.z.string()),
+  workflows: import_zod.z.array(import_zod.z.string()),
+  tags: import_zod.z.array(import_zod.z.string())
+}).strict();
+var StudioContextResponseSchema = import_zod.z.object({
+  organization: import_zod.z.object({
+    name: import_zod.z.string().min(1)
+  }).strict(),
+  project: import_zod.z.object({
+    name: import_zod.z.string().min(1)
+  }).strict(),
+  environments: import_zod.z.array(import_zod.z.string()),
+  apiKey: import_zod.z.object({
+    mode: import_zod.z.enum(["test", "live"]),
+    scopes: import_zod.z.array(import_zod.z.string())
+  }).strict(),
+  api: import_zod.z.object({
+    status: import_zod.z.literal("ok"),
+    service: import_zod.z.literal("kortyx-api"),
+    version: import_zod.z.string().min(1)
+  }).strict()
+}).strict();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EnsureWorkflowTopologyRequestSchema,
   EnsureWorkflowTopologyResponseSchema,
+  STUDIO_TIME_RANGES,
+  StudioCatalogsResponseSchema,
+  StudioChangeResourceSchema,
+  StudioChangeSchema,
+  StudioContextResponseSchema,
+  StudioDetailEventSchema,
+  StudioInterruptDetailResponseSchema,
+  StudioInterruptInteractionModeSchema,
+  StudioInterruptOptionSchema,
+  StudioInterruptSchema,
+  StudioInterruptStatusSchema,
+  StudioInterruptTypeSchema,
+  StudioInterruptsResponseSchema,
+  StudioMetricSchema,
+  StudioPricingSourceSchema,
+  StudioPricingStatusSchema,
+  StudioResumeOutcomeSchema,
+  StudioRunDetailResponseSchema,
+  StudioRunSchema,
+  StudioRunStatusSchema,
+  StudioRunsResponseSchema,
+  StudioSessionDetailResponseSchema,
+  StudioSessionSchema,
+  StudioSessionsResponseSchema,
+  StudioTimeRangeContextSchema,
+  StudioTimeRangeQuerySchema,
+  StudioTimeRangeSchema,
+  StudioWorkflowHealthSchema,
+  StudioWorkflowInternalEdgeSchema,
+  StudioWorkflowNodeSchema,
+  StudioWorkflowSchema,
+  StudioWorkflowTransitionSchema,
+  StudioWorkflowsResponseSchema,
   TELEMETRY_EVENT_TYPES,
+  TelemetryEventBatchResponseSchema,
   TelemetryEventBatchSchema,
   TelemetryEventSchema,
   TelemetryEventTypeSchema,
+  TelemetryPricingHintSchema,
+  TelemetryPricingLineItemSchema,
+  TelemetryPricingSourceSchema,
+  TelemetryPricingUnitSchema,
+  TelemetryPricingUsageTypeSchema,
   TelemetryServiceSchema,
+  TelemetryUnitPriceSchema,
+  TelemetryUsageItemSchema,
   WorkflowTopologyEdgeSchema,
-  WorkflowTopologyNodeSchema
+  WorkflowTopologyNodeSchema,
+  WorkflowTopologyTransitionSchema,
+  resolveStudioInterruptStatus,
+  resolveStudioTimeRange
 });
 //# sourceMappingURL=index.js.map