effect-app 4.0.0-beta.30 → 4.0.0-beta.301

package/dist/rpc/Invalidation.d.ts

@@ -0,0 +1,3140 @@
+import * as Ref from "effect/Ref";
+import { Rpc } from "effect/unstable/rpc";
+import { type ClientForOptions } from "../client/clientFor.js";
+import * as Context from "../Context.js";
+import * as DataDependencies from "../DataDependencies.js";
+import * as Effect from "../Effect.js";
+import * as S from "../Schema.js";
+/**
+ * Shorthand for a handler-derived invalidation key.
+ * Accepts an RPC handler object so `add(GetMe)` is equivalent to
+ * `add(makeQueryKey(GetMe))`.
+ */
+export type InvalidationKeyInput = InvalidationKey | {
+    readonly id: string;
+    readonly options?: ClientForOptions;
+};
+/**
+ * A single segment within an `InvalidationKey` array.
+ * Accepts any JSON-compatible value: string, number, boolean, null,
+ * arrays and objects recursively — matching TanStack Query's `queryKey` element type.
+ */
+export declare const InvalidationKeySegment: S.Codec<S.Json, S.Json, never, never>;
+export type InvalidationKeySegment = S.Schema.Type<typeof InvalidationKeySegment>;
+/** Schema for a single invalidation key – an array of segments compatible with TanStack Query `queryKey`. */
+export declare const InvalidationKey: S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+    withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+};
+export type InvalidationKey = S.Schema.Type<typeof InvalidationKey>;
+/** Schema for the full set of invalidation keys – an array of `InvalidationKey`. */
+export declare const InvalidationKeys: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+    withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+}> & {
+    withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+    }>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+    }>, never>;
+};
+export type InvalidationKeys = S.Schema.Type<typeof InvalidationKeys>;
+/** Metadata included in every command response for server-driven cache invalidation. */
+export declare const CommandMetaData: S.Struct<{
+    readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+    }> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }>, never>;
+    };
+    readonly dataDependencies: S.Struct<{
+        readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>>, S.$Array<S.Struct<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }>>, never, never> & {
+            withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never>, never>;
+        };
+        readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>>, S.$Array<S.Struct<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }>>, never, never> & {
+            withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never>, never>;
+        };
+    }>;
+}>;
+export type CommandMetaData = S.Schema.Type<typeof CommandMetaData>;
+export declare const emptyDataDependencies: DataDependencies.DataDependencySet;
+export declare const makeMetaData: (invalidateQueries: InvalidationKeys, dataDependencies?: DataDependencies.DataDependencySet) => CommandMetaData;
+export declare const QueryResponseWithMetaData: <S extends S.Top>(success: S) => S.Struct<{
+    readonly payload: S;
+    readonly metadata: S.Struct<{
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>;
+/**
+ * Wraps a command's success schema so that the wire format carries both the `payload`
+ * (the handler's actual return value) and `metadata` (server-driven cache invalidation keys).
+ * Transparent to users: the server handler returns the plain payload and the client receives
+ * the plain payload — wrapping/unwrapping is handled internally by the routing layer.
+ */
+export declare const CommandResponseWithMetaData: <S extends S.Top>(success: S) => S.Struct<{
+    readonly payload: S;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>;
+/**
+ * Wraps a command's failure schema so that the wire format carries both the `error`
+ * (the handler's actual failure value) and `metadata` (server-driven cache invalidation keys
+ * accumulated thus far before the failure occurred).
+ * Transparent to users: the server handler fails with the plain error and the client receives
+ * the plain error — wrapping/unwrapping is handled internally by the routing layer.
+ */
+export declare const CommandFailureWithMetaData: <E extends S.Top>(error: E) => S.Struct<{
+    readonly _tag: S.Literal<"CommandFailureWithMetaData">;
+    readonly error: E;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>;
+/**
+ * Stream chunk schema for stream responses with metadata.
+ * Each item is either a data value, an intermediate "metadata" signal carrying cache
+ * invalidation keys accumulated since the previous drain, or a final "done" signal.
+ * Transparent to users: stream handlers return plain values and clients receive plain values —
+ * wrapping/unwrapping is handled internally by the routing layer.
+ *
+ * The "done" chunk is always the last item in the stream and carries any remaining invalidation
+ * keys. An optional "metadata" chunk may appear after any "value" chunk and carries keys
+ * accumulated since the last drain (V3: mid-stream invalidation).
+ */
+export declare const StreamResponseChunk: <S extends S.Top>(success: S) => S.Union<readonly [S.Struct<{
+    readonly _tag: S.Literal<"value">;
+    readonly value: S;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"metadata">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"done">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>]>;
+export type StreamResponseChunk<A> = {
+    readonly _tag: "value";
+    readonly value: A;
+} | {
+    readonly _tag: "metadata";
+    readonly metadata: CommandMetaData;
+} | {
+    readonly _tag: "done";
+    readonly metadata: CommandMetaData;
+};
+/**
+ * Stream chunk schema for stream failures with metadata.
+ * Used to signal a stream failure while still carrying cache invalidation keys
+ * accumulated thus far.
+ */
+export declare const StreamFailureChunk: <E extends S.Top>(error: E) => S.Struct<{
+    readonly _tag: S.Literal<"error">;
+    readonly error: E;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>;
+export type StreamFailureChunk<E> = {
+    readonly _tag: "error";
+    readonly error: E;
+    readonly metadata: CommandMetaData;
+};
+/**
+ * Context annotation for declaring static cache invalidation keys on a low-level `Rpc` definition.
+ * These keys are always included in the command response metadata, regardless of the handler logic.
+ *
+ * Prefer using `makeQueryKey` over raw string arrays to stay in sync with the actual query
+ * definitions without manual string maintenance:
+ *
+ * ```ts
+ * import { makeQueryKey } from "effect-app/client"
+ * import { Invalidation } from "effect-app/rpc"
+ * import * as UserRsc from "../User/index.js"  // separate module to avoid circular deps
+ *
+ * class UpdateProfile extends Rpc.make("UpdateProfile", { ... })
+ *   .annotate(Invalidation.Invalidates, [makeQueryKey(UserRsc.GetMe), makeQueryKey(UserRsc.GetProfile)]) {}
+ * ```
+ *
+ * **Circular dependency note:** if mutations and queries live in the same file you may hit a
+ * circular reference at evaluation time. The idiomatic fix is to move mutations into their own
+ * module (e.g. `User/mutations.ts`) that directly imports the relevant query classes rather than
+ * re-exporting them through a barrel.
+ *
+ * For the higher-level `Command`/`Query` builders from `makeRpcClient`, use the
+ * `invalidatesQueries` callback argument instead (it receives the same query keys at runtime).
+ */
+export declare const Invalidates: Context.Reference<readonly (readonly S.Json[])[]>;
+export type Invalidates = typeof Invalidates;
+/** The shape of the per-request service that accumulates invalidation keys. */
+export interface InvalidationSetService {
+    readonly add: (input: InvalidationKeyInput | ReadonlyArray<InvalidationKeyInput>) => Effect.Effect<void>;
+    readonly get: Effect.Effect<ReadonlyArray<InvalidationKey>>;
+    /**
+     * V3: Reads all currently accumulated keys and resets the bucket to empty.
+     * Used by the stream routing layer to emit intermediate "metadata" chunks
+     * without re-sending keys that have already been forwarded to the client.
+     */
+    readonly drain: Effect.Effect<ReadonlyArray<InvalidationKey>>;
+}
+/**
+ * Request-scoped service for accumulating invalidation keys dynamically inside a handler.
+ * Provided by `InvalidationMiddlewareLive` for every RPC call; has a no-op default so it is
+ * safe to use even when the HTTP middleware is absent (tests, workers, etc.).
+ *
+ * Use `InvalidationSet.add(key)` as a shorthand to skip `.use(_ => _.add(key))`. The
+ * underlying service is still available via `.use` / `.useSync` for advanced cases.
+ *
+ * `add` accepts an RPC handler directly (e.g. `UserRsc.GetMe`) — its query key is derived via
+ * `makeQueryKey` so keys stay in sync with the actual query definitions. Raw `InvalidationKey`
+ * arrays and arrays of either form are also accepted.
+ *
+ * ```ts
+ * import * as Effect from "effect/Effect"
+ * import { Invalidation } from "effect-app/rpc"
+ * import * as CartRsc from "../Cart/queries.js"
+ * import * as UserRsc from "../User/queries.js"
+ *
+ * const handler = Effect.fnUntraced(function*(req: UpdateCartRequest) {
+ *   const cart = yield* CartRepo.save(req.cart)
+ *
+ *   // single handler
+ *   yield* Invalidation.InvalidationSet.add(UserRsc.GetMe)
+ *
+ *   // batch
+ *   if (cart.isCheckedOut) {
+ *     yield* Invalidation.InvalidationSet.add([CartRsc.GetCartStats, UserRsc.GetMe])
+ *   }
+ *
+ *   return cart
+ * })
+ * ```
+ *
+ * You can combine static (`Invalidates` annotation) and dynamic (`InvalidationSet.use`) keys:
+ * the annotation pre-populates the set before the handler runs; dynamic additions accumulate
+ * throughout the handler. All keys are included in the command response metadata.
+ */
+declare const InvalidationSetRef: Context.Reference<InvalidationSetService>;
+export declare const InvalidationSet: Context.Reference<InvalidationSetService> & {
+    /**
+     * Shortcut for `InvalidationSet.use(_ => _.add(input))`. Accepts a single
+     * `InvalidationKeyInput` or an array of them.
+     */
+    add: (input: InvalidationKeyInput | ReadonlyArray<InvalidationKeyInput>) => Effect.Effect<void, never, never>;
+};
+export type InvalidationSet = typeof InvalidationSetRef;
+/** Creates a fresh `InvalidationSet` implementation backed by a `Ref`. */
+export declare const makeInvalidationSet: (ref: Ref.Ref<ReadonlyArray<InvalidationKey>>) => InvalidationSetService;
+/**
+ * `Rpc.Custom` definition for command RPCs that wrap the success/error schemas
+ * with `CommandResponseWithMetaData` / `CommandFailureWithMetaData`. The wrap
+ * lets server forward accumulated invalidation keys on both success and
+ * handler-thrown failure paths. Middleware-thrown errors bypass the wrap
+ * (the handler never ran, so no metadata) and flow raw at the Cause level —
+ * the client decodes them via the `rpc.middlewares[*].error` failure-union
+ * channel of `Rpc.exitSchema`.
+ */
+export interface CommandRpc extends Rpc.Custom {
+    readonly out: Rpc.Custom.Out<ReturnType<typeof CommandResponseWithMetaData<this["success"] & S.Top>>, ReturnType<typeof CommandFailureWithMetaData<this["error"] & S.Top>>>;
+}
+/**
+ * Custom Rpc constructor for command RPCs.
+ * Wraps the success schema with `CommandResponseWithMetaData` and the error
+ * schema with `CommandFailureWithMetaData`.
+ */
+export declare const makeCommandRpc: <const Tag extends string, Payload extends S.Top | import("effect/Schema").Struct.Fields = import("effect/Schema").Void, Success extends S.Top = import("effect/Schema").Void, Error extends S.Top = S.Never, const Stream extends boolean = false, Out extends Rpc.Custom.OutDefault = Rpc.Custom.Out<S.Struct<{
+    readonly payload: S.Top & Success;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"CommandFailureWithMetaData">;
+    readonly error: S.Top & Error;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>>>(tag: Tag, options?: {
+    readonly payload?: Payload;
+    readonly success?: Success;
+    readonly error?: Error;
+    readonly defect?: Rpc.DefectSchema;
+    readonly stream?: Stream;
+    readonly primaryKey?: [Payload] extends [import("effect/Schema").Struct.Fields] ? (payload: Payload extends import("effect/Schema").Struct.Fields ? import("effect/Schema").Struct.View<Payload, "Type", import("effect/Schema").Struct.TypeOptionalKeys<Payload>, import("effect/Schema").Struct.TypeMutableKeys<Payload>> extends infer T ? { [K in keyof T]: T[K]; } : never : Payload["Type"]) => string : never;
+} | undefined) => Rpc.Rpc<Tag, Payload extends import("effect/Schema").Struct.Fields ? import("effect/Schema").Struct<Payload> : Payload, Stream extends true ? import("effect/unstable/rpc/RpcSchema").Stream<Out["success"], Out["error"]> : Out["success"], Stream extends true ? S.Never : Out["error"], never, never>;
+/**
+ * `Rpc.Custom` definition for stream RPCs that wrap the success/error schemas
+ * with `StreamResponseChunk` / `StreamFailureChunk`.
+ */
+export interface StreamRpc extends Rpc.Custom {
+    readonly out: Rpc.Custom.Out<ReturnType<typeof StreamResponseChunk<this["success"] & S.Top>>, ReturnType<typeof StreamFailureChunk<this["error"] & S.Top>>>;
+}
+/**
+ * Custom Rpc constructor for stream RPCs.
+ * Wraps the success schema with `StreamResponseChunk` and
+ * the error schema with `StreamFailureChunk`.
+ */
+export declare const makeStreamRpc: <const Tag extends string, Payload extends S.Top | import("effect/Schema").Struct.Fields = import("effect/Schema").Void, Success extends S.Top = import("effect/Schema").Void, Error extends S.Top = S.Never, const Stream extends boolean = false, Out extends Rpc.Custom.OutDefault = Rpc.Custom.Out<S.Union<readonly [S.Struct<{
+    readonly _tag: S.Literal<"value">;
+    readonly value: S.Top & Success;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"metadata">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"done">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>]>, S.Struct<{
+    readonly _tag: S.Literal<"error">;
+    readonly error: S.Top & Error;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+        readonly dataDependencies: S.Struct<{
+            readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+            readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }, "Type">>>, S.$Array<S.Struct<{
+                readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        Default: A;
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    Default: "repo";
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                readonly name: S.String;
+            }>>, never, never> & {
+                withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }, "Type">>>, S.$Array<S.Struct<{
+                    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                            Default: A;
+                            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                        };
+                        Default: "repo";
+                        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                    };
+                    readonly name: S.String;
+                }>>, never, never>, never>;
+            };
+        }>;
+    }>;
+}>>>(tag: Tag, options?: {
+    readonly payload?: Payload;
+    readonly success?: Success;
+    readonly error?: Error;
+    readonly defect?: Rpc.DefectSchema;
+    readonly stream?: Stream;
+    readonly primaryKey?: [Payload] extends [import("effect/Schema").Struct.Fields] ? (payload: Payload extends import("effect/Schema").Struct.Fields ? import("effect/Schema").Struct.View<Payload, "Type", import("effect/Schema").Struct.TypeOptionalKeys<Payload>, import("effect/Schema").Struct.TypeMutableKeys<Payload>> extends infer T ? { [K in keyof T]: T[K]; } : never : Payload["Type"]) => string : never;
+} | undefined) => Rpc.Rpc<Tag, Payload extends import("effect/Schema").Struct.Fields ? import("effect/Schema").Struct<Payload> : Payload, Stream extends true ? import("effect/unstable/rpc/RpcSchema").Stream<Out["success"], Out["error"]> : Out["success"], Stream extends true ? S.Never : Out["error"], never, never>;
+export {};
+//# sourceMappingURL=Invalidation.d.ts.map