@opencode/ai 2.0.31 → 2.1.0

package/dist/transcription.d.ts

@@ -319,29 +319,6 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
 }>]> & {
     readonly discriminants: readonly ["generation-queued", "generation-progress", "text-delta", "segment", "finish"];
     readonly cases: {
-        "generation-queued": Schema.Struct<{
-            readonly type: Schema.tag<"generation-queued">;
-            readonly id: Schema.String;
-            readonly position: Schema.optional<Schema.Number>;
-        }>;
-        "generation-progress": Schema.Struct<{
-            readonly type: Schema.tag<"generation-progress">;
-            readonly id: Schema.String;
-            readonly progress: Schema.optional<Schema.Number>;
-        }>;
-        "text-delta": Schema.Struct<{
-            readonly type: Schema.tag<"text-delta">;
-            readonly delta: Schema.String;
-        }>;
-        segment: Schema.Struct<{
-            readonly type: Schema.tag<"segment">;
-            readonly segment: Schema.Struct<{
-                readonly text: Schema.String;
-                readonly startSeconds: Schema.Number;
-                readonly endSeconds: Schema.Number;
-                readonly speaker: Schema.optional<Schema.String>;
-            }>;
-        }>;
         finish: Schema.Struct<{
             readonly text: Schema.String;
             readonly segments: Schema.optional<Schema.$Array<Schema.Struct<{
@@ -386,14 +363,37 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
             readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
             readonly type: Schema.tag<"finish">;
         }>;
+        "generation-progress": Schema.Struct<{
+            readonly type: Schema.tag<"generation-progress">;
+            readonly id: Schema.String;
+            readonly progress: Schema.optional<Schema.Number>;
+        }>;
+        "generation-queued": Schema.Struct<{
+            readonly type: Schema.tag<"generation-queued">;
+            readonly id: Schema.String;
+            readonly position: Schema.optional<Schema.Number>;
+        }>;
+        segment: Schema.Struct<{
+            readonly type: Schema.tag<"segment">;
+            readonly segment: Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        "text-delta": Schema.Struct<{
+            readonly type: Schema.tag<"text-delta">;
+            readonly delta: Schema.String;
+        }>;
     };
     readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: {
-        readonly id: string;
         readonly type: "generation-queued";
+        readonly id: string;
         readonly position?: number | undefined;
     } | {
-        readonly id: string;
         readonly type: "generation-progress";
+        readonly id: string;
         readonly progress?: number | undefined;
     } | {
         readonly type: "text-delta";
@@ -407,14 +407,22 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
             readonly speaker?: string | undefined;
         };
     } | {
-        readonly type: "finish";
         readonly text: string;
+        readonly segments?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        }[] | undefined;
+        readonly words?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+            readonly confidence?: number | undefined;
+        }[] | undefined;
+        readonly language?: string | undefined;
         readonly durationSeconds?: number | undefined;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
         readonly usage?: {
             readonly type: "tokens";
             readonly input?: number | undefined;
@@ -437,7 +445,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
             readonly seconds: number;
         } | undefined;
         readonly notices?: readonly {
-            readonly type: "other" | "moderated" | "filtered";
+            readonly type: "filtered" | "moderated" | "other";
             readonly message: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -445,29 +453,21 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 };
             } | undefined;
         }[] | undefined;
-        readonly language?: string | undefined;
-        readonly segments?: readonly {
-            readonly text: string;
-            readonly startSeconds: number;
-            readonly endSeconds: number;
-            readonly speaker?: string | undefined;
-        }[] | undefined;
-        readonly words?: readonly {
-            readonly text: string;
-            readonly startSeconds: number;
-            readonly endSeconds: number;
-            readonly speaker?: string | undefined;
-            readonly confidence?: number | undefined;
-        }[] | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly type: "finish";
     }) => value is Extract<{
-        readonly id: string;
         readonly type: "generation-queued";
+        readonly id: string;
         readonly position?: number | undefined;
     }, {
         readonly type: Keys;
     }> | Extract<{
-        readonly id: string;
         readonly type: "generation-progress";
+        readonly id: string;
         readonly progress?: number | undefined;
     }, {
         readonly type: Keys;
@@ -487,14 +487,22 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
     }, {
         readonly type: Keys;
     }> | Extract<{
-        readonly type: "finish";
         readonly text: string;
+        readonly segments?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        }[] | undefined;
+        readonly words?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+            readonly confidence?: number | undefined;
+        }[] | undefined;
+        readonly language?: string | undefined;
         readonly durationSeconds?: number | undefined;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
         readonly usage?: {
             readonly type: "tokens";
             readonly input?: number | undefined;
@@ -517,7 +525,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
             readonly seconds: number;
         } | undefined;
         readonly notices?: readonly {
-            readonly type: "other" | "moderated" | "filtered";
+            readonly type: "filtered" | "moderated" | "other";
             readonly message: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -525,87 +533,18 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 };
             } | undefined;
         }[] | undefined;
-        readonly language?: string | undefined;
-        readonly segments?: readonly {
-            readonly text: string;
-            readonly startSeconds: number;
-            readonly endSeconds: number;
-            readonly speaker?: string | undefined;
-        }[] | undefined;
-        readonly words?: readonly {
-            readonly text: string;
-            readonly startSeconds: number;
-            readonly endSeconds: number;
-            readonly speaker?: string | undefined;
-            readonly confidence?: number | undefined;
-        }[] | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly type: "finish";
     }, {
         readonly type: Keys;
     }>;
     readonly guards: {
-        "generation-queued": (u: unknown) => u is {
-            readonly id: string;
-            readonly type: "generation-queued";
-            readonly position?: number | undefined;
-        };
-        "generation-progress": (u: unknown) => u is {
-            readonly id: string;
-            readonly type: "generation-progress";
-            readonly progress?: number | undefined;
-        };
-        "text-delta": (u: unknown) => u is {
-            readonly type: "text-delta";
-            readonly delta: string;
-        };
-        segment: (u: unknown) => u is {
-            readonly type: "segment";
-            readonly segment: {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-            };
-        };
         finish: (u: unknown) => u is {
-            readonly type: "finish";
             readonly text: string;
-            readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
-            readonly usage?: {
-                readonly type: "tokens";
-                readonly input?: number | undefined;
-                readonly output?: number | undefined;
-                readonly total?: number | undefined;
-                readonly details?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-            } | {
-                readonly type: "seconds";
-                readonly seconds: number;
-            } | {
-                readonly type: "characters";
-                readonly characters: number;
-            } | {
-                readonly type: "credits";
-                readonly credits: number;
-            } | {
-                readonly type: "compute";
-                readonly seconds: number;
-            } | undefined;
-            readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
-                readonly message: string;
-                readonly providerMetadata?: {
-                    readonly [x: string]: {
-                        readonly [x: string]: unknown;
-                    };
-                } | undefined;
-            }[] | undefined;
-            readonly language?: string | undefined;
             readonly segments?: readonly {
                 readonly text: string;
                 readonly startSeconds: number;
@@ -619,115 +558,8 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly speaker?: string | undefined;
                 readonly confidence?: number | undefined;
             }[] | undefined;
-        };
-    };
-    readonly match: {
-        <Cases extends {
-            "generation-queued": (value: {
-                readonly id: string;
-                readonly type: "generation-queued";
-                readonly position?: number | undefined;
-            }) => any;
-            "generation-progress": (value: {
-                readonly id: string;
-                readonly type: "generation-progress";
-                readonly progress?: number | undefined;
-            }) => any;
-            "text-delta": (value: {
-                readonly type: "text-delta";
-                readonly delta: string;
-            }) => any;
-            segment: (value: {
-                readonly type: "segment";
-                readonly segment: {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                };
-            }) => any;
-            finish: (value: {
-                readonly type: "finish";
-                readonly text: string;
-                readonly durationSeconds?: number | undefined;
-                readonly providerMetadata?: {
-                    readonly [x: string]: {
-                        readonly [x: string]: unknown;
-                    };
-                } | undefined;
-                readonly usage?: {
-                    readonly type: "tokens";
-                    readonly input?: number | undefined;
-                    readonly output?: number | undefined;
-                    readonly total?: number | undefined;
-                    readonly details?: {
-                        readonly [x: string]: unknown;
-                    } | undefined;
-                } | {
-                    readonly type: "seconds";
-                    readonly seconds: number;
-                } | {
-                    readonly type: "characters";
-                    readonly characters: number;
-                } | {
-                    readonly type: "credits";
-                    readonly credits: number;
-                } | {
-                    readonly type: "compute";
-                    readonly seconds: number;
-                } | undefined;
-                readonly notices?: readonly {
-                    readonly type: "other" | "moderated" | "filtered";
-                    readonly message: string;
-                    readonly providerMetadata?: {
-                        readonly [x: string]: {
-                            readonly [x: string]: unknown;
-                        };
-                    } | undefined;
-                }[] | undefined;
-                readonly language?: string | undefined;
-                readonly segments?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                }[] | undefined;
-                readonly words?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                    readonly confidence?: number | undefined;
-                }[] | undefined;
-            }) => any;
-        }>(value: {
-            readonly id: string;
-            readonly type: "generation-queued";
-            readonly position?: number | undefined;
-        } | {
-            readonly id: string;
-            readonly type: "generation-progress";
-            readonly progress?: number | undefined;
-        } | {
-            readonly type: "text-delta";
-            readonly delta: string;
-        } | {
-            readonly type: "segment";
-            readonly segment: {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-            };
-        } | {
-            readonly type: "finish";
-            readonly text: string;
+            readonly language?: string | undefined;
             readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
             readonly usage?: {
                 readonly type: "tokens";
                 readonly input?: number | undefined;
@@ -750,7 +582,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly seconds: number;
             } | undefined;
             readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
+                readonly type: "filtered" | "moderated" | "other";
                 readonly message: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -758,106 +590,107 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     };
                 } | undefined;
             }[] | undefined;
-            readonly language?: string | undefined;
-            readonly segments?: readonly {
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
+        };
+        "generation-progress": (u: unknown) => u is {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        };
+        "generation-queued": (u: unknown) => u is {
+            readonly type: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        };
+        segment: (u: unknown) => u is {
+            readonly type: "segment";
+            readonly segment: {
                 readonly text: string;
                 readonly startSeconds: number;
                 readonly endSeconds: number;
                 readonly speaker?: string | undefined;
-            }[] | undefined;
-            readonly words?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-                readonly confidence?: number | undefined;
-            }[] | undefined;
-        }, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
-        <Cases extends {
-            "generation-queued": (value: {
-                readonly id: string;
-                readonly type: "generation-queued";
-                readonly position?: number | undefined;
-            }) => any;
-            "generation-progress": (value: {
-                readonly id: string;
-                readonly type: "generation-progress";
-                readonly progress?: number | undefined;
-            }) => any;
-            "text-delta": (value: {
-                readonly type: "text-delta";
-                readonly delta: string;
-            }) => any;
-            segment: (value: {
-                readonly type: "segment";
-                readonly segment: {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                };
-            }) => any;
-            finish: (value: {
-                readonly type: "finish";
-                readonly text: string;
-                readonly durationSeconds?: number | undefined;
-                readonly providerMetadata?: {
-                    readonly [x: string]: {
-                        readonly [x: string]: unknown;
-                    };
-                } | undefined;
-                readonly usage?: {
-                    readonly type: "tokens";
-                    readonly input?: number | undefined;
-                    readonly output?: number | undefined;
-                    readonly total?: number | undefined;
-                    readonly details?: {
-                        readonly [x: string]: unknown;
-                    } | undefined;
-                } | {
-                    readonly type: "seconds";
-                    readonly seconds: number;
-                } | {
-                    readonly type: "characters";
-                    readonly characters: number;
-                } | {
-                    readonly type: "credits";
-                    readonly credits: number;
-                } | {
-                    readonly type: "compute";
-                    readonly seconds: number;
-                } | undefined;
-                readonly notices?: readonly {
-                    readonly type: "other" | "moderated" | "filtered";
-                    readonly message: string;
-                    readonly providerMetadata?: {
-                        readonly [x: string]: {
-                            readonly [x: string]: unknown;
-                        };
-                    } | undefined;
-                }[] | undefined;
-                readonly language?: string | undefined;
-                readonly segments?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                }[] | undefined;
-                readonly words?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                    readonly confidence?: number | undefined;
-                }[] | undefined;
-            }) => any;
-        }>(cases: Cases): (value: {
-            readonly id: string;
+            };
+        };
+        "text-delta": (u: unknown) => u is {
+            readonly type: "text-delta";
+            readonly delta: string;
+        };
+    };
+    readonly match: {
+        <Cases extends { [M in Schema.Struct<{
+            readonly type: Schema.tag<"generation-queued">;
+            readonly id: Schema.String;
+            readonly position: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"generation-progress">;
+            readonly id: Schema.String;
+            readonly progress: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"text-delta">;
+            readonly delta: Schema.String;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"segment">;
+            readonly segment: Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>;
+        }> | Schema.Struct<{
+            readonly text: Schema.String;
+            readonly segments: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>>>;
+            readonly words: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+                readonly confidence: Schema.optional<Schema.Number>;
+            }>>>;
+            readonly language: Schema.optional<Schema.String>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly usage: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tokens">;
+                readonly input: Schema.optional<Schema.Number>;
+                readonly output: Schema.optional<Schema.Number>;
+                readonly total: Schema.optional<Schema.Number>;
+                readonly details: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"seconds">;
+                readonly seconds: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"characters">;
+                readonly characters: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"credits">;
+                readonly credits: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"compute">;
+                readonly seconds: Schema.Number;
+            }>]>>;
+            readonly notices: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly type: Schema.Literals<readonly ["moderated", "filtered", "other"]>;
+                readonly message: Schema.String;
+                readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            }>>>;
+            readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            readonly type: Schema.tag<"finish">;
+        }> as M["Type"]["type"]]: (value: M["Type"]) => any; }>(value: {
             readonly type: "generation-queued";
+            readonly id: string;
             readonly position?: number | undefined;
         } | {
-            readonly id: string;
             readonly type: "generation-progress";
+            readonly id: string;
             readonly progress?: number | undefined;
         } | {
             readonly type: "text-delta";
@@ -871,14 +704,22 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly speaker?: string | undefined;
             };
         } | {
-            readonly type: "finish";
             readonly text: string;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
             readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
             readonly usage?: {
                 readonly type: "tokens";
                 readonly input?: number | undefined;
@@ -901,7 +742,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly seconds: number;
             } | undefined;
             readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
+                readonly type: "filtered" | "moderated" | "other";
                 readonly message: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -909,119 +750,87 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     };
                 } | undefined;
             }[] | undefined;
-            readonly language?: string | undefined;
-            readonly segments?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-            }[] | undefined;
-            readonly words?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-                readonly confidence?: number | undefined;
-            }[] | undefined;
-        }) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
-    };
-    readonly matchOrElse: {
-        <Cases extends {
-            "generation-queued"?: ((value: {
-                readonly id: string;
-                readonly type: "generation-queued";
-                readonly position?: number | undefined;
-            }) => any) | undefined;
-            "generation-progress"?: ((value: {
-                readonly id: string;
-                readonly type: "generation-progress";
-                readonly progress?: number | undefined;
-            }) => any) | undefined;
-            "text-delta"?: ((value: {
-                readonly type: "text-delta";
-                readonly delta: string;
-            }) => any) | undefined;
-            segment?: ((value: {
-                readonly type: "segment";
-                readonly segment: {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
                 };
-            }) => any) | undefined;
-            finish?: ((value: {
-                readonly type: "finish";
-                readonly text: string;
-                readonly durationSeconds?: number | undefined;
-                readonly providerMetadata?: {
-                    readonly [x: string]: {
-                        readonly [x: string]: unknown;
-                    };
-                } | undefined;
-                readonly usage?: {
-                    readonly type: "tokens";
-                    readonly input?: number | undefined;
-                    readonly output?: number | undefined;
-                    readonly total?: number | undefined;
-                    readonly details?: {
-                        readonly [x: string]: unknown;
-                    } | undefined;
-                } | {
-                    readonly type: "seconds";
-                    readonly seconds: number;
-                } | {
-                    readonly type: "characters";
-                    readonly characters: number;
-                } | {
-                    readonly type: "credits";
-                    readonly credits: number;
-                } | {
-                    readonly type: "compute";
-                    readonly seconds: number;
-                } | undefined;
-                readonly notices?: readonly {
-                    readonly type: "other" | "moderated" | "filtered";
-                    readonly message: string;
-                    readonly providerMetadata?: {
-                        readonly [x: string]: {
-                            readonly [x: string]: unknown;
-                        };
-                    } | undefined;
-                }[] | undefined;
-                readonly language?: string | undefined;
-                readonly segments?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                }[] | undefined;
-                readonly words?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                    readonly confidence?: number | undefined;
-                }[] | undefined;
-            }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "text-delta" | "segment">]: never; }, OrElse extends (value: Exclude<{
-            readonly id: string;
+            } | undefined;
+            readonly type: "finish";
+        }, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        <Cases extends { [M in Schema.Struct<{
+            readonly type: Schema.tag<"generation-queued">;
+            readonly id: Schema.String;
+            readonly position: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"generation-progress">;
+            readonly id: Schema.String;
+            readonly progress: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"text-delta">;
+            readonly delta: Schema.String;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"segment">;
+            readonly segment: Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>;
+        }> | Schema.Struct<{
+            readonly text: Schema.String;
+            readonly segments: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>>>;
+            readonly words: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+                readonly confidence: Schema.optional<Schema.Number>;
+            }>>>;
+            readonly language: Schema.optional<Schema.String>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly usage: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tokens">;
+                readonly input: Schema.optional<Schema.Number>;
+                readonly output: Schema.optional<Schema.Number>;
+                readonly total: Schema.optional<Schema.Number>;
+                readonly details: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"seconds">;
+                readonly seconds: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"characters">;
+                readonly characters: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"credits">;
+                readonly credits: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"compute">;
+                readonly seconds: Schema.Number;
+            }>]>>;
+            readonly notices: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly type: Schema.Literals<readonly ["moderated", "filtered", "other"]>;
+                readonly message: Schema.String;
+                readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            }>>>;
+            readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            readonly type: Schema.tag<"finish">;
+        }> as M["Type"]["type"]]: (value: M["Type"]) => any; }>(cases: Cases): (value: {
             readonly type: "generation-queued";
-            readonly position?: number | undefined;
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
             readonly id: string;
+            readonly position?: number | undefined;
+        } | {
             readonly type: "generation-progress";
+            readonly id: string;
             readonly progress?: number | undefined;
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
+        } | {
             readonly type: "text-delta";
             readonly delta: string;
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
+        } | {
             readonly type: "segment";
             readonly segment: {
                 readonly text: string;
@@ -1029,17 +838,23 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly endSeconds: number;
                 readonly speaker?: string | undefined;
             };
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
-            readonly type: "finish";
+        } | {
             readonly text: string;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
             readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
             readonly usage?: {
                 readonly type: "tokens";
                 readonly input?: number | undefined;
@@ -1062,7 +877,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly seconds: number;
             } | undefined;
             readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
+                readonly type: "filtered" | "moderated" | "other";
                 readonly message: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1070,7 +885,98 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     };
                 } | undefined;
             }[] | undefined;
-            readonly language?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
+        }) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+    };
+    readonly matchOrElse: {
+        <Cases extends { [M in Schema.Struct<{
+            readonly type: Schema.tag<"generation-queued">;
+            readonly id: Schema.String;
+            readonly position: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"generation-progress">;
+            readonly id: Schema.String;
+            readonly progress: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"text-delta">;
+            readonly delta: Schema.String;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"segment">;
+            readonly segment: Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>;
+        }> | Schema.Struct<{
+            readonly text: Schema.String;
+            readonly segments: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>>>;
+            readonly words: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+                readonly confidence: Schema.optional<Schema.Number>;
+            }>>>;
+            readonly language: Schema.optional<Schema.String>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly usage: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tokens">;
+                readonly input: Schema.optional<Schema.Number>;
+                readonly output: Schema.optional<Schema.Number>;
+                readonly total: Schema.optional<Schema.Number>;
+                readonly details: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"seconds">;
+                readonly seconds: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"characters">;
+                readonly characters: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"credits">;
+                readonly credits: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"compute">;
+                readonly seconds: Schema.Number;
+            }>]>>;
+            readonly notices: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly type: Schema.Literals<readonly ["moderated", "filtered", "other"]>;
+                readonly message: Schema.String;
+                readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            }>>>;
+            readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            readonly type: Schema.tag<"finish">;
+        }> as M["Type"]["type"]]+?: (value: M["Type"]) => any; } & { [K in Exclude<keyof Cases, "finish" | "generation-progress" | "generation-queued" | "segment" | "text-delta">]: never; }, OrElse extends (value: Exclude<{
+            readonly type: "generation-queued";
+            readonly id: string;
+            readonly position?: number | undefined;
+        } | {
+            readonly type: "generation-progress";
+            readonly id: string;
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "text-delta";
+            readonly delta: string;
+        } | {
+            readonly type: "segment";
+            readonly segment: {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            };
+        } | {
+            readonly text: string;
             readonly segments?: readonly {
                 readonly text: string;
                 readonly startSeconds: number;
@@ -1084,15 +990,51 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly speaker?: string | undefined;
                 readonly confidence?: number | undefined;
             }[] | undefined;
-        }, {
-            readonly type: keyof Cases;
-        }>) => any>(value: {
-            readonly id: string;
+            readonly language?: string | undefined;
+            readonly durationSeconds?: number | undefined;
+            readonly usage?: {
+                readonly type: "tokens";
+                readonly input?: number | undefined;
+                readonly output?: number | undefined;
+                readonly total?: number | undefined;
+                readonly details?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "seconds";
+                readonly seconds: number;
+            } | {
+                readonly type: "characters";
+                readonly characters: number;
+            } | {
+                readonly type: "credits";
+                readonly credits: number;
+            } | {
+                readonly type: "compute";
+                readonly seconds: number;
+            } | undefined;
+            readonly notices?: readonly {
+                readonly type: "filtered" | "moderated" | "other";
+                readonly message: string;
+                readonly providerMetadata?: {
+                    readonly [x: string]: {
+                        readonly [x: string]: unknown;
+                    };
+                } | undefined;
+            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
+        }, { readonly [K in "type"]: keyof Cases; }>) => any>(value: {
             readonly type: "generation-queued";
+            readonly id: string;
             readonly position?: number | undefined;
         } | {
-            readonly id: string;
             readonly type: "generation-progress";
+            readonly id: string;
             readonly progress?: number | undefined;
         } | {
             readonly type: "text-delta";
@@ -1106,14 +1048,22 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly speaker?: string | undefined;
             };
         } | {
-            readonly type: "finish";
             readonly text: string;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
             readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
             readonly usage?: {
                 readonly type: "tokens";
                 readonly input?: number | undefined;
@@ -1136,7 +1086,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly seconds: number;
             } | undefined;
             readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
+                readonly type: "filtered" | "moderated" | "other";
                 readonly message: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1144,117 +1094,87 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     };
                 } | undefined;
             }[] | undefined;
-            readonly language?: string | undefined;
-            readonly segments?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-            }[] | undefined;
-            readonly words?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-                readonly confidence?: number | undefined;
-            }[] | undefined;
-        }, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
-        <Cases extends {
-            "generation-queued"?: ((value: {
-                readonly id: string;
-                readonly type: "generation-queued";
-                readonly position?: number | undefined;
-            }) => any) | undefined;
-            "generation-progress"?: ((value: {
-                readonly id: string;
-                readonly type: "generation-progress";
-                readonly progress?: number | undefined;
-            }) => any) | undefined;
-            "text-delta"?: ((value: {
-                readonly type: "text-delta";
-                readonly delta: string;
-            }) => any) | undefined;
-            segment?: ((value: {
-                readonly type: "segment";
-                readonly segment: {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
                 };
-            }) => any) | undefined;
-            finish?: ((value: {
-                readonly type: "finish";
-                readonly text: string;
-                readonly durationSeconds?: number | undefined;
-                readonly providerMetadata?: {
-                    readonly [x: string]: {
-                        readonly [x: string]: unknown;
-                    };
-                } | undefined;
-                readonly usage?: {
-                    readonly type: "tokens";
-                    readonly input?: number | undefined;
-                    readonly output?: number | undefined;
-                    readonly total?: number | undefined;
-                    readonly details?: {
-                        readonly [x: string]: unknown;
-                    } | undefined;
-                } | {
-                    readonly type: "seconds";
-                    readonly seconds: number;
-                } | {
-                    readonly type: "characters";
-                    readonly characters: number;
-                } | {
-                    readonly type: "credits";
-                    readonly credits: number;
-                } | {
-                    readonly type: "compute";
-                    readonly seconds: number;
-                } | undefined;
-                readonly notices?: readonly {
-                    readonly type: "other" | "moderated" | "filtered";
-                    readonly message: string;
-                    readonly providerMetadata?: {
-                        readonly [x: string]: {
-                            readonly [x: string]: unknown;
-                        };
-                    } | undefined;
-                }[] | undefined;
-                readonly language?: string | undefined;
-                readonly segments?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                }[] | undefined;
-                readonly words?: readonly {
-                    readonly text: string;
-                    readonly startSeconds: number;
-                    readonly endSeconds: number;
-                    readonly speaker?: string | undefined;
-                    readonly confidence?: number | undefined;
-                }[] | undefined;
-            }) => any) | undefined;
-        } & { [K in Exclude<keyof Cases, "finish" | "generation-queued" | "generation-progress" | "text-delta" | "segment">]: never; }, OrElse extends (value: Exclude<{
-            readonly id: string;
+            } | undefined;
+            readonly type: "finish";
+        }, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K in keyof Cases]-?: NonNullable<Cases[K]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+        <Cases extends { [M in Schema.Struct<{
+            readonly type: Schema.tag<"generation-queued">;
+            readonly id: Schema.String;
+            readonly position: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"generation-progress">;
+            readonly id: Schema.String;
+            readonly progress: Schema.optional<Schema.Number>;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"text-delta">;
+            readonly delta: Schema.String;
+        }> | Schema.Struct<{
+            readonly type: Schema.tag<"segment">;
+            readonly segment: Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>;
+        }> | Schema.Struct<{
+            readonly text: Schema.String;
+            readonly segments: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+            }>>>;
+            readonly words: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.String;
+                readonly startSeconds: Schema.Number;
+                readonly endSeconds: Schema.Number;
+                readonly speaker: Schema.optional<Schema.String>;
+                readonly confidence: Schema.optional<Schema.Number>;
+            }>>>;
+            readonly language: Schema.optional<Schema.String>;
+            readonly durationSeconds: Schema.optional<Schema.Number>;
+            readonly usage: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tokens">;
+                readonly input: Schema.optional<Schema.Number>;
+                readonly output: Schema.optional<Schema.Number>;
+                readonly total: Schema.optional<Schema.Number>;
+                readonly details: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"seconds">;
+                readonly seconds: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"characters">;
+                readonly characters: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"credits">;
+                readonly credits: Schema.Number;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"compute">;
+                readonly seconds: Schema.Number;
+            }>]>>;
+            readonly notices: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly type: Schema.Literals<readonly ["moderated", "filtered", "other"]>;
+                readonly message: Schema.String;
+                readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            }>>>;
+            readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+            readonly type: Schema.tag<"finish">;
+        }> as M["Type"]["type"]]+?: (value: M["Type"]) => any; } & { [K in Exclude<keyof Cases, "finish" | "generation-progress" | "generation-queued" | "segment" | "text-delta">]: never; }, OrElse extends (value: Exclude<{
             readonly type: "generation-queued";
-            readonly position?: number | undefined;
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
             readonly id: string;
+            readonly position?: number | undefined;
+        } | {
             readonly type: "generation-progress";
+            readonly id: string;
             readonly progress?: number | undefined;
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
+        } | {
             readonly type: "text-delta";
             readonly delta: string;
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
+        } | {
             readonly type: "segment";
             readonly segment: {
                 readonly text: string;
@@ -1262,17 +1182,23 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly endSeconds: number;
                 readonly speaker?: string | undefined;
             };
-        }, {
-            readonly type: keyof Cases;
-        }> | Exclude<{
-            readonly type: "finish";
+        } | {
             readonly text: string;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
             readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
             readonly usage?: {
                 readonly type: "tokens";
                 readonly input?: number | undefined;
@@ -1295,7 +1221,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly seconds: number;
             } | undefined;
             readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
+                readonly type: "filtered" | "moderated" | "other";
                 readonly message: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1303,29 +1229,19 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     };
                 } | undefined;
             }[] | undefined;
-            readonly language?: string | undefined;
-            readonly segments?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-            }[] | undefined;
-            readonly words?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-                readonly confidence?: number | undefined;
-            }[] | undefined;
-        }, {
-            readonly type: keyof Cases;
-        }>) => any>(cases: Cases, orElse: OrElse): (value: {
-            readonly id: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
+        }, { readonly [K in "type"]: keyof Cases; }>) => any>(cases: Cases, orElse: OrElse): (value: {
             readonly type: "generation-queued";
+            readonly id: string;
             readonly position?: number | undefined;
         } | {
-            readonly id: string;
             readonly type: "generation-progress";
+            readonly id: string;
             readonly progress?: number | undefined;
         } | {
             readonly type: "text-delta";
@@ -1339,14 +1255,22 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly speaker?: string | undefined;
             };
         } | {
-            readonly type: "finish";
             readonly text: string;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
             readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
             readonly usage?: {
                 readonly type: "tokens";
                 readonly input?: number | undefined;
@@ -1369,7 +1293,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly seconds: number;
             } | undefined;
             readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
+                readonly type: "filtered" | "moderated" | "other";
                 readonly message: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1377,32 +1301,24 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     };
                 } | undefined;
             }[] | undefined;
-            readonly language?: string | undefined;
-            readonly segments?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-            }[] | undefined;
-            readonly words?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-                readonly confidence?: number | undefined;
-            }[] | undefined;
-        }) => import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
+        }) => import("effect/Unify").Unify<{ [K in keyof Cases]-?: NonNullable<Cases[K]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
     };
 } & {
     is: {
         generationQueued: (u: unknown) => u is {
-            readonly id: string;
             readonly type: "generation-queued";
+            readonly id: string;
             readonly position?: number | undefined;
         };
         generationProgress: (u: unknown) => u is {
-            readonly id: string;
             readonly type: "generation-progress";
+            readonly id: string;
             readonly progress?: number | undefined;
         };
         textDelta: (u: unknown) => u is {
@@ -1419,14 +1335,22 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
             };
         };
         finish: (u: unknown) => u is {
-            readonly type: "finish";
             readonly text: string;
+            readonly segments?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+            }[] | undefined;
+            readonly words?: readonly {
+                readonly text: string;
+                readonly startSeconds: number;
+                readonly endSeconds: number;
+                readonly speaker?: string | undefined;
+                readonly confidence?: number | undefined;
+            }[] | undefined;
+            readonly language?: string | undefined;
             readonly durationSeconds?: number | undefined;
-            readonly providerMetadata?: {
-                readonly [x: string]: {
-                    readonly [x: string]: unknown;
-                };
-            } | undefined;
             readonly usage?: {
                 readonly type: "tokens";
                 readonly input?: number | undefined;
@@ -1449,7 +1373,7 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                 readonly seconds: number;
             } | undefined;
             readonly notices?: readonly {
-                readonly type: "other" | "moderated" | "filtered";
+                readonly type: "filtered" | "moderated" | "other";
                 readonly message: string;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -1457,20 +1381,12 @@ export declare const TranscriptionEvent: Schema.Union<readonly [Schema.Struct<{
                     };
                 } | undefined;
             }[] | undefined;
-            readonly language?: string | undefined;
-            readonly segments?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-            }[] | undefined;
-            readonly words?: readonly {
-                readonly text: string;
-                readonly startSeconds: number;
-                readonly endSeconds: number;
-                readonly speaker?: string | undefined;
-                readonly confidence?: number | undefined;
-            }[] | undefined;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+            readonly type: "finish";
         };
     };
 };
@@ -1487,6 +1403,6 @@ export declare const Transcription: {
     readonly generate: typeof generate;
     readonly stream: typeof stream;
     readonly start: typeof start;
-    readonly resume: (model: TranscriptionModel, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+    readonly resume: typeof resume;
 };
 export {};