nuxt-media-library 0.0.44

package/dist/runtime/components/MLProcessing/PipelineStepItem.vue

@@ -0,0 +1,309 @@
+<script setup>
+import { computed, toRef } from "vue";
+import { useElapsedTimer } from "../../composables/useElapsedTimer";
+const props = defineProps({
+  task: { type: Object, required: true },
+  expanded: { type: Boolean, required: true },
+  sseEvent: { type: [Object, null], required: false },
+  blocker: { type: [Object, null], required: false }
+});
+const emit = defineEmits(["toggle", "configure", "retry"]);
+const effectiveStatus = computed(() => {
+  const sse = props.sseEvent?.status?.toLowerCase();
+  if (sse && sse !== "reaped") return sse;
+  return (props.task.status ?? "").toLowerCase();
+});
+const isDone = computed(() => effectiveStatus.value === "succeeded");
+const isRunning = computed(() => effectiveStatus.value === "running");
+const isFailed = computed(() => effectiveStatus.value === "failed");
+const isPendingInput = computed(() => effectiveStatus.value === "pending_input");
+const isWaiting = computed(() => effectiveStatus.value === "waiting");
+const isCanceled = computed(() => effectiveStatus.value === "canceled");
+const isRetry = computed(() => effectiveStatus.value === "retry");
+const isSkipped = computed(
+  () => props.task.metadata_payload?.skipped === true
+);
+function parseUtc(iso) {
+  if (!iso.endsWith("Z") && !iso.includes("+") && !/\d{2}:\d{2}$/.test(iso.slice(-6))) {
+    return (/* @__PURE__ */ new Date(iso + "Z")).getTime();
+  }
+  return new Date(iso).getTime();
+}
+const startedAtRef = toRef(() => props.task.started_at);
+const { elapsed, formatDuration } = useElapsedTimer(startedAtRef, isRunning);
+const durationText = computed(() => {
+  if (isRunning.value) return elapsed.value;
+  if (props.task.started_at && props.task.finished_at) {
+    const ms = parseUtc(props.task.finished_at) - parseUtc(props.task.started_at);
+    return formatDuration(ms);
+  }
+  return "";
+});
+function humanize(name) {
+  return name.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+const displayName = computed(() => humanize(props.task.task_type));
+const statusLabel = computed(() => {
+  if (isSkipped.value) return "SKIPPED";
+  if (isDone.value) return "DONE";
+  if (isRunning.value) return "RUNNING";
+  if (isFailed.value) return "FAILED";
+  if (isPendingInput.value) return "NEEDS INPUT";
+  if (isWaiting.value) return "WAITING";
+  if (isRetry.value) return "RETRY";
+  if (isCanceled.value) return "CANCELED";
+  return "QUEUED";
+});
+const statusIcon = computed(() => {
+  if (isSkipped.value) return "i-lucide-skip-forward";
+  if (isDone.value) return "i-lucide-circle-check";
+  if (isRunning.value) return "i-lucide-loader";
+  if (isFailed.value) return "i-lucide-circle-x";
+  if (isPendingInput.value) return "i-lucide-pencil-line";
+  if (isWaiting.value) return "i-lucide-clock";
+  if (isCanceled.value) return "i-lucide-ban";
+  if (isRetry.value) return "i-lucide-refresh-cw";
+  return "i-lucide-circle-dot";
+});
+const titleClasses = computed(() => {
+  if (isRunning.value) return "font-bold text-primary";
+  if (isDone.value) return "font-semibold text-default";
+  if (isFailed.value) return "font-semibold text-error";
+  if (isPendingInput.value) return "font-semibold text-amber-600";
+  if (isCanceled.value || isSkipped.value) return "text-muted line-through";
+  return "text-muted";
+});
+const iconClasses = computed(() => {
+  if (isDone.value) return "text-green-500";
+  if (isRunning.value) return "text-primary";
+  if (isFailed.value) return "text-red-500";
+  if (isPendingInput.value) return "text-amber-500";
+  if (isRetry.value) return "text-amber-500";
+  if (isCanceled.value || isSkipped.value) return "text-muted";
+  return "text-muted";
+});
+const badgeColor = computed(() => {
+  if (isFailed.value) return "error";
+  if (isRunning.value) return "warning";
+  if (isDone.value || isSkipped.value) return "success";
+  if (isPendingInput.value) return "warning";
+  if (isRetry.value) return "warning";
+  return "neutral";
+});
+const badgeVariant = computed(() => isRunning.value ? "solid" : "subtle");
+const rowDescription = computed(() => {
+  if (reapedHint.value?.terminal) return "Worker timed out \u2014 retries exhausted";
+  if (reapedHint.value?.requeued) return "Worker timed out \u2014 re-queued";
+  if (isSkipped.value && props.task.metadata_payload?.reason) {
+    return props.task.metadata_payload.reason;
+  }
+  if (isWaiting.value && props.blocker) {
+    const blockerStatus = (props.blocker.status ?? "").toLowerCase();
+    const blockerName = humanize(props.blocker.task_type);
+    if (blockerStatus === "pending_input") return `Waiting on ${blockerName} (needs configuration)`;
+    if (blockerStatus === "running") return `Waiting on ${blockerName}`;
+    if (blockerStatus === "failed") return `Blocked by failure in ${blockerName}`;
+    return `Waiting on ${blockerName}`;
+  }
+  return "";
+});
+const maxRetries = computed(() => props.task.max_retries ?? props.task.maxRetries ?? null);
+const attemptsBadge = computed(() => {
+  const attempts = props.task.attempts ?? 0;
+  const max = maxRetries.value;
+  if (!attempts) return "";
+  if (typeof max === "number" && max > 0) return `${attempts}/${max}`;
+  return `${attempts}`;
+});
+const showAttemptsBadge = computed(
+  () => !!attemptsBadge.value && (isFailed.value || isRetry.value || isRunning.value && (props.task.attempts ?? 0) > 1)
+);
+const failureKind = computed(() => props.task.failure_kind ?? props.task.failureKind ?? null);
+const failurePill = computed(() => {
+  if (!isFailed.value || !failureKind.value) return null;
+  switch (failureKind.value) {
+    case "validation":
+      return { label: "Invalid config", color: "error", icon: "i-lucide-alert-triangle" };
+    case "timeout":
+      return { label: "Timed out", color: "warning", icon: "i-lucide-timer-off" };
+    case "crash":
+      return { label: "Crashed", color: "error", icon: "i-lucide-circle-x" };
+    case "worker_lost":
+      return { label: "Worker died", color: "neutral", icon: "i-lucide-plug-zap" };
+    default:
+      return null;
+  }
+});
+const isValidationFailure = computed(
+  () => isFailed.value && failureKind.value === "validation"
+);
+const isRetryable = computed(
+  () => isFailed.value && failureKind.value !== "validation" && failureKind.value !== "worker_lost"
+);
+const reapedHint = computed(() => {
+  if (props.sseEvent?.status?.toLowerCase() !== "reaped") return null;
+  const meta = props.sseEvent.metadata ?? {};
+  return { requeued: meta.requeued === true, terminal: meta.terminal === true };
+});
+const blobChain = computed(() => {
+  const inId = props.task.input_blob_id ?? props.task.inputBlobId ?? null;
+  const outId = props.task.output_blob_id ?? props.task.outputBlobId ?? null;
+  if (!inId && !outId) return null;
+  const short = (id) => id ? id.slice(0, 8) : "\u2014";
+  return { in: short(inId), out: short(outId), inFull: inId, outFull: outId };
+});
+const hasExpandableContent = computed(
+  () => !!(props.task.last_error || props.task.metadata_payload && Object.keys(props.task.metadata_payload).length || blobChain.value)
+);
+const metadataEntries = computed(() => {
+  if (!props.task.metadata_payload) return [];
+  return Object.entries(props.task.metadata_payload).filter(
+    ([key]) => key !== "skipped" && key !== "reason"
+  );
+});
+const formatTime = (iso) => {
+  const ms = parseUtc(iso);
+  const date = new Date(ms);
+  return date.toLocaleTimeString(void 0, { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+};
+const formatMetaKey = (key) => key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+</script>
+
+<template>
+  <MLProcessingStepLayout
+    :title="displayName"
+    :description="rowDescription"
+    :title-class="titleClasses"
+    :icon="statusIcon"
+    :icon-class="iconClasses"
+    :spinning="isRunning"
+    class="group"
+    :class="{ 'cursor-pointer': hasExpandableContent }"
+    @click="hasExpandableContent && emit('toggle')"
+  >
+      <template #header-actions>
+        <span v-if="durationText" class="text-xs text-muted font-mono">{{ durationText }}</span>
+        <UBadge
+          v-if="failurePill"
+          :color="failurePill.color"
+          variant="subtle"
+          size="xs"
+          :icon="failurePill.icon"
+          :label="failurePill.label"
+        />
+        <UBadge
+          v-if="showAttemptsBadge"
+          color="warning"
+          variant="subtle"
+          size="xs"
+          icon="i-lucide-refresh-cw"
+          :label="attemptsBadge"
+          :title="`Attempt ${task.attempts}${maxRetries ? ' of ' + maxRetries : ''}`"
+        />
+        <UBadge
+          v-if="!isDone && !failurePill"
+          :color="badgeColor"
+          :variant="badgeVariant"
+          :label="statusLabel"
+          size="xs"
+        />
+        <UButton
+          v-if="isPendingInput || isValidationFailure"
+          size="xs"
+          variant="soft"
+          color="warning"
+          icon="i-lucide-settings"
+          label="Configure"
+          @click.stop="emit('configure', task.id)"
+        />
+        <UButton
+          v-if="isRetryable"
+          size="xs"
+          variant="ghost"
+          color="warning"
+          icon="i-lucide-refresh-cw"
+          :title="`Retry this step${maxRetries ? ` (${task.attempts ?? 0}/${maxRetries} attempts used)` : ''}`"
+          @click.stop="emit('retry', task.id)"
+        />
+        <UIcon
+          v-if="hasExpandableContent"
+          name="i-lucide-chevron-down"
+          class="size-4 text-muted transition-transform duration-200"
+          :class="{ 'rotate-180': expanded }"
+        />
+      </template>
+
+      <!-- Expanded Content -->
+      <Transition
+        enter-active-class="transition-all duration-200 ease-out"
+        leave-active-class="transition-all duration-150 ease-in"
+        enter-from-class="opacity-0 max-h-0"
+        enter-to-class="opacity-100 max-h-96"
+        leave-from-class="opacity-100 max-h-96"
+        leave-to-class="opacity-0 max-h-0"
+      >
+        <div v-if="expanded" class="overflow-hidden">
+          <div class="mt-3 space-y-2 text-xs">
+            <!-- Error -->
+            <div
+              v-if="task.last_error"
+              class="bg-error/5 border border-error/20 rounded-md p-3 text-error"
+            >
+              <div class="font-medium mb-1">Error</div>
+              <pre class="whitespace-pre-wrap font-mono text-[11px] leading-relaxed">{{ task.last_error }}</pre>
+              <div v-if="task.attempts > 1" class="text-muted mt-1.5">
+                Attempt {{ task.attempts }}
+              </div>
+            </div>
+
+            <!-- Metadata -->
+            <div
+              v-if="metadataEntries.length"
+              class="bg-muted/30 border border-default rounded-md p-3"
+            >
+              <div
+                v-for="([key, value]) in metadataEntries"
+                :key="key"
+                class="flex items-start gap-2 py-0.5"
+              >
+                <span class="text-muted shrink-0">{{ formatMetaKey(key) }}:</span>
+                <span
+                  v-if="typeof value === 'boolean'"
+                  class="font-medium"
+                  :class="value ? 'text-green-500' : 'text-red-500'"
+                >
+                  {{ value ? "Yes" : "No" }}
+                </span>
+                <span v-else-if="typeof value === 'number'" class="font-mono">{{ value }}</span>
+                <span v-else-if="Array.isArray(value)">{{ value.join(", ") }}</span>
+                <pre
+                  v-else-if="typeof value === 'object' && value !== null"
+                  class="text-[11px] font-mono whitespace-pre-wrap"
+                >{{ JSON.stringify(value, null, 2) }}</pre>
+                <span v-else>{{ value }}</span>
+              </div>
+            </div>
+
+            <!-- Blob chain (debug) -->
+            <div
+              v-if="blobChain"
+              class="flex items-center gap-2 text-muted font-mono text-[11px]"
+            >
+              <span class="text-muted/70">in:</span>
+              <span :title="blobChain.inFull ?? ''">{{ blobChain.in }}</span>
+              <UIcon name="i-lucide-arrow-right" class="size-3" />
+              <span class="text-muted/70">out:</span>
+              <span :title="blobChain.outFull ?? ''">{{ blobChain.out }}</span>
+            </div>
+
+            <!-- Timing -->
+            <div class="flex flex-wrap gap-4 text-muted">
+              <span v-if="task.queued_at">Queued: {{ formatTime(task.queued_at) }}</span>
+              <span v-if="task.started_at">Started: {{ formatTime(task.started_at) }}</span>
+              <span v-if="task.finished_at">Finished: {{ formatTime(task.finished_at) }}</span>
+            </div>
+          </div>
+        </div>
+      </Transition>
+  </MLProcessingStepLayout>
+</template>

package/dist/runtime/components/MLProcessing/PipelineStepItem.vue.d.ts

@@ -0,0 +1,20 @@
+import type { ProcessingTask } from "../../types/asset.js";
+import type { ProcessingEvent } from "../../composables/useMLProcessingStatus.js";
+type __VLS_Props = {
+    task: ProcessingTask;
+    expanded: boolean;
+    sseEvent?: ProcessingEvent | null;
+    /** Upstream task currently blocking this row (only meaningful for `waiting` rows). */
+    blocker?: ProcessingTask | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    toggle: () => any;
+    retry: (taskId: string) => any;
+    configure: (taskId: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: (() => any) | undefined;
+    onRetry?: ((taskId: string) => any) | undefined;
+    onConfigure?: ((taskId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/MLProcessing/ProgressBar.d.vue.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    percent: number;
+    color?: 'primary' | 'success' | 'error';
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    color: "primary" | "success" | "error";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/MLProcessing/ProgressBar.vue

@@ -0,0 +1,27 @@
+<script setup>
+import { computed } from "vue";
+const props = defineProps({
+  percent: { type: Number, required: true },
+  color: { type: String, required: false, default: "primary" }
+});
+const barClass = computed(() => {
+  switch (props.color) {
+    case "success":
+      return "bg-green-500";
+    case "error":
+      return "bg-red-500";
+    default:
+      return "bg-primary";
+  }
+});
+</script>
+
+<template>
+  <div class="h-0.5 border-x border-default overflow-hidden">
+    <div
+      class="h-full transition-all duration-500 ease-out"
+      :class="barClass"
+      :style="{ width: `${percent}%` }"
+    />
+  </div>
+</template>

package/dist/runtime/components/MLProcessing/ProgressBar.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    percent: number;
+    color?: 'primary' | 'success' | 'error';
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    color: "primary" | "success" | "error";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/MLProcessing/StepLayout.d.vue.ts

@@ -0,0 +1,31 @@
+type __VLS_Props = {
+    title: string;
+    description?: string;
+    titleClass?: string;
+    icon?: string;
+    iconClass?: string;
+    spinning?: boolean;
+    showBody?: boolean;
+};
+declare var __VLS_6: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
+    'header-actions'?: (props: typeof __VLS_6) => any;
+} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    description: string;
+    icon: string;
+    titleClass: string;
+    iconClass: string;
+    spinning: boolean;
+    showBody: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/MLProcessing/StepLayout.vue

@@ -0,0 +1,36 @@
+<script setup>
+defineProps({
+  title: { type: String, required: true },
+  description: { type: String, required: false, default: "" },
+  titleClass: { type: String, required: false, default: "" },
+  icon: { type: String, required: false, default: "i-lucide-circle-dot" },
+  iconClass: { type: String, required: false, default: "text-muted" },
+  spinning: { type: Boolean, required: false, default: false },
+  showBody: { type: Boolean, required: false, default: true }
+});
+</script>
+
+<template>
+  <div class="">
+    <!-- Header -->
+    <div class="flex items-center justify-between bg-default p-2 border border-default ">
+      <div class="flex items-center gap-2 min-w-0">
+        <UIcon
+          :name="icon"
+          class="size-4 shrink-0"
+          :class="[iconClass, { 'animate-spin': spinning }]"
+        />
+        <div class="">
+          <span class="text-sm truncate" :class="titleClass">{{ title }}</span>
+          <span class="text-sm truncate" v-if="description" :class="description">{{ description }}</span>
+        </div>
+      </div>
+      <div class="flex items-center gap-2 shrink-0">
+        <slot name="header-actions"/>
+      </div>
+    </div>
+
+    <!-- Body -->
+    <slot v-if="showBody && $slots.default"/>
+  </div>
+</template>

package/dist/runtime/components/MLProcessing/StepLayout.vue.d.ts

@@ -0,0 +1,31 @@
+type __VLS_Props = {
+    title: string;
+    description?: string;
+    titleClass?: string;
+    icon?: string;
+    iconClass?: string;
+    spinning?: boolean;
+    showBody?: boolean;
+};
+declare var __VLS_6: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
+    'header-actions'?: (props: typeof __VLS_6) => any;
+} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    description: string;
+    icon: string;
+    titleClass: string;
+    iconClass: string;
+    spinning: boolean;
+    showBody: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/MLProcessing/Stepper.d.vue.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    assetId: string;
+    assetKind?: string;
+    downloadUrl?: string | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    failed: () => any;
+    complete: () => any;
+    stepComplete: (stepName: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFailed?: (() => any) | undefined;
+    onComplete?: (() => any) | undefined;
+    onStepComplete?: ((stepName: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/MLProcessing/Stepper.vue

@@ -0,0 +1,87 @@
+<script setup>
+import { watch } from "vue";
+import { useMLProcessingStepper } from "../../composables/useMLProcessingStepper";
+const props = defineProps({
+  assetId: { type: String, required: true },
+  assetKind: { type: String, required: false },
+  downloadUrl: { type: [String, null], required: false }
+});
+const emit = defineEmits(["complete", "failed", "stepComplete"]);
+const {
+  steps,
+  loading,
+  currentStepIndex,
+  allComplete,
+  hasAnyFailed,
+  progressPercent,
+  updateStepOptions,
+  runStep,
+  retryStep,
+  runRemaining
+} = useMLProcessingStepper(() => props.assetId);
+watch(allComplete, (done) => {
+  if (done) emit("complete");
+});
+watch(hasAnyFailed, (failed) => {
+  if (failed) emit("failed");
+});
+const hasPendingSteps = () => steps.value.some((s) => s.status !== "succeeded" && s.status !== "skipped");
+</script>
+
+<template>
+  <div class="space-y-0">
+    <MLProcessingTopBar title="Manual Processing">
+      <template #subtitle>
+        Step {{ Math.min(currentStepIndex + 1, steps.length) }} of {{ steps.length }}
+        <template v-if="allComplete"> · All steps complete</template>
+      </template>
+      <template #actions>
+        <UButton
+          v-if="hasPendingSteps() && !allComplete"
+          variant="outline"
+          color="neutral"
+          size="xs"
+          icon="i-lucide-fast-forward"
+          label="Run Remaining"
+          @click="runRemaining"
+        />
+      </template>
+    </MLProcessingTopBar>
+
+    <MLProcessingProgressBar
+      :percent="progressPercent"
+      :color="hasAnyFailed ? 'error' : allComplete ? 'success' : 'primary'"
+    />
+
+    <!-- Steps -->
+    <div class="border border-t-0 border-default rounded-b-lg">
+      <!-- Loading -->
+      <div v-if="loading && !steps.length" class="space-y-3 p-4">
+        <USkeleton v-for="i in 4" :key="i" class="h-12 w-full" />
+      </div>
+
+      <!-- Step List -->
+      <template v-else-if="steps.length">
+        <MLProcessingStepperItem
+          v-for="step in steps"
+          :key="step.name"
+          :step="step"
+          :download-url="step.name === 'video_thumbnail' ? downloadUrl : void 0"
+          @update:options="updateStepOptions(step.name, $event)"
+          @run="runStep(step.name)"
+          @retry="retryStep(step.name)"
+        />
+      </template>
+
+      <!-- Empty -->
+      <UEmpty
+        v-else
+        icon="i-lucide-list-checks"
+        title="No pipeline available"
+        description="No processing steps found for this asset type."
+        size="sm"
+        class="py-8"
+      />
+    </div>
+  </div>
+</template>

package/dist/runtime/components/MLProcessing/Stepper.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    assetId: string;
+    assetKind?: string;
+    downloadUrl?: string | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    failed: () => any;
+    complete: () => any;
+    stepComplete: (stepName: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onFailed?: (() => any) | undefined;
+    onComplete?: (() => any) | undefined;
+    onStepComplete?: ((stepName: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/MLProcessing/StepperItem.d.vue.ts

@@ -0,0 +1,16 @@
+import type { StepState } from "../../composables/useMLProcessingStepper.js";
+type __VLS_Props = {
+    step: StepState;
+    downloadUrl?: string | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
+    "update:options": (value: Record<string, any>) => any;
+    run: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
+    "onUpdate:options"?: ((value: Record<string, any>) => any) | undefined;
+    onRun?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;