@confect/server 9.0.0-next.6 → 9.0.0-next.8

package/dist/RegisteredConvexFunction.d.ts

@@ -16,15 +16,17 @@ import { StorageReader as StorageReader$1 } from "./StorageReader.js";
 import { StorageWriter as StorageWriter$1 } from "./StorageWriter.js";
 import { Any } from "./RegisteredFunction.js";
 import { AnyWithProps as AnyWithProps$1 } from "./RegistryItem.js";
-import { Effect, Layer, Schema } from "effect";
 import * as _confect_core_Ref0 from "@confect/core/Ref";
 import * as convex_server0 from "convex/server";
 import { GenericMutationCtx } from "convex/server";
-import * as convex_values0 from "convex/values";
-import * as _confect_core_Types0 from "@confect/core/Types";
-import * as effect_ParseResult0 from "effect/ParseResult";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import "effect/Schema";
 import * as effect_Duration0 from "effect/Duration";
+import * as effect_ParseResult0 from "effect/ParseResult";
+import * as convex_values0 from "convex/values";
 import * as effect_DateTime0 from "effect/DateTime";
+import * as _confect_core_Types0 from "@confect/core/Types";
 
 //#region src/RegisteredConvexFunction.d.ts
 declare namespace RegisteredConvexFunction_d_exports {
@@ -34,8 +36,11 @@ declare const make: (databaseSchema: AnyWithProps, {
   functionSpec,
   handler
 }: AnyWithProps$1) => Any;
-declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<(<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>) | Auth$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
-  table: <const TableName extends Name<Tables<Schema>> | "_scheduled_functions" | "_storage">(tableName: TableName) => {
+declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<(<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | {
+  runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+} | GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
+  table: <const TableName extends "_storage" | "_scheduled_functions" | Name<Tables<Schema>>>(tableName: TableName) => {
     readonly get: {
       (id: convex_values0.GenericId<TableName>): Effect.Effect<(TableInfo<WithName<Tables<Schema>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", Schema.Struct<{
         name: typeof Schema.String;
@@ -67,8 +72,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -84,8 +89,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -101,18 +106,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -126,7 +131,7 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         sha256: convex_values0.VString<string, "required">;
         size: convex_values0.VFloat64<number, "required">;
         contentType: convex_values0.VString<string | undefined, "optional">;
-      }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"], DocumentDecodeError | GetByIdFailure, never>;
+      }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof (TableInfo<WithName<Tables<Schema>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", Schema.Struct<{
         name: typeof Schema.String;
         args: Schema.Array$<typeof Schema.Any>;
@@ -157,8 +162,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -174,8 +179,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -191,18 +196,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -246,8 +251,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -263,8 +268,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -280,18 +285,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -335,8 +340,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -352,8 +357,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -369,18 +374,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -427,8 +432,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -444,8 +449,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -461,18 +466,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -516,8 +521,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -533,8 +538,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -550,18 +555,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -605,8 +610,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -622,8 +627,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -639,18 +644,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -695,8 +700,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -712,8 +717,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -729,18 +734,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -784,8 +789,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         };
@@ -801,8 +806,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         } | {
           kind: "success";
         } | {
-          error: string;
           kind: "failed";
+          error: string;
         } | {
           kind: "canceled";
         }, [convex_values0.VObject<{
@@ -818,18 +823,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
         }, {
           kind: convex_values0.VLiteral<"success", "required">;
         }, "required", "kind">, convex_values0.VObject<{
-          error: string;
           kind: "failed";
+          error: string;
         }, {
-          error: convex_values0.VString<string, "required">;
           kind: convex_values0.VLiteral<"failed", "required">;
-        }, "required", "error" | "kind">, convex_values0.VObject<{
+          error: convex_values0.VString<string, "required">;
+        }, "required", "kind" | "error">, convex_values0.VObject<{
           kind: "canceled";
         }, {
           kind: convex_values0.VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "error" | "kind">;
+        }, "required", "kind">], "required", "kind" | "error">;
         completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+      }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
         sha256: typeof Schema.String;
         size: typeof Schema.Number;
         contentType: Schema.optionalWith<typeof Schema.String, {
@@ -875,8 +880,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       } | {
         kind: "success";
       } | {
-        error: string;
         kind: "failed";
+        error: string;
       } | {
         kind: "canceled";
       };
@@ -892,8 +897,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       } | {
         kind: "success";
       } | {
-        error: string;
         kind: "failed";
+        error: string;
       } | {
         kind: "canceled";
       }, [convex_values0.VObject<{
@@ -909,18 +914,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       }, {
         kind: convex_values0.VLiteral<"success", "required">;
       }, "required", "kind">, convex_values0.VObject<{
-        error: string;
         kind: "failed";
+        error: string;
       }, {
-        error: convex_values0.VString<string, "required">;
         kind: convex_values0.VLiteral<"failed", "required">;
-      }, "required", "error" | "kind">, convex_values0.VObject<{
+        error: convex_values0.VString<string, "required">;
+      }, "required", "kind" | "error">, convex_values0.VObject<{
         kind: "canceled";
       }, {
         kind: convex_values0.VLiteral<"canceled", "required">;
-      }, "required", "kind">], "required", "error" | "kind">;
+      }, "required", "kind">], "required", "kind" | "error">;
       completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-    }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+    }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
       sha256: typeof Schema.String;
       size: typeof Schema.Number;
       contentType: Schema.optionalWith<typeof Schema.String, {
@@ -964,8 +969,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       } | {
         kind: "success";
       } | {
-        error: string;
         kind: "failed";
+        error: string;
       } | {
         kind: "canceled";
       };
@@ -981,8 +986,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       } | {
         kind: "success";
       } | {
-        error: string;
         kind: "failed";
+        error: string;
       } | {
         kind: "canceled";
       }, [convex_values0.VObject<{
@@ -998,18 +1003,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       }, {
         kind: convex_values0.VLiteral<"success", "required">;
       }, "required", "kind">, convex_values0.VObject<{
-        error: string;
         kind: "failed";
+        error: string;
       }, {
-        error: convex_values0.VString<string, "required">;
         kind: convex_values0.VLiteral<"failed", "required">;
-      }, "required", "error" | "kind">, convex_values0.VObject<{
+        error: convex_values0.VString<string, "required">;
+      }, "required", "kind" | "error">, convex_values0.VObject<{
         kind: "canceled";
       }, {
         kind: convex_values0.VLiteral<"canceled", "required">;
-      }, "required", "kind">], "required", "error" | "kind">;
+      }, "required", "kind">], "required", "kind" | "error">;
       completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-    }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+    }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
       sha256: typeof Schema.String;
       size: typeof Schema.Number;
       contentType: Schema.optionalWith<typeof Schema.String, {
@@ -1053,8 +1058,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       } | {
         kind: "success";
       } | {
-        error: string;
         kind: "failed";
+        error: string;
       } | {
         kind: "canceled";
       };
@@ -1070,8 +1075,8 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       } | {
         kind: "success";
       } | {
-        error: string;
         kind: "failed";
+        error: string;
       } | {
         kind: "canceled";
       }, [convex_values0.VObject<{
@@ -1087,18 +1092,18 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
       }, {
         kind: convex_values0.VLiteral<"success", "required">;
       }, "required", "kind">, convex_values0.VObject<{
-        error: string;
         kind: "failed";
+        error: string;
       }, {
-        error: convex_values0.VString<string, "required">;
         kind: convex_values0.VLiteral<"failed", "required">;
-      }, "required", "error" | "kind">, convex_values0.VObject<{
+        error: convex_values0.VString<string, "required">;
+      }, "required", "kind" | "error">, convex_values0.VObject<{
         kind: "canceled";
       }, {
         kind: convex_values0.VLiteral<"canceled", "required">;
-      }, "required", "kind">], "required", "error" | "kind">;
+      }, "required", "kind">], "required", "kind" | "error">;
       completedTime: convex_values0.VFloat64<number | undefined, "optional">;
-    }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.error" | "state.kind">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
+    }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | TableInfo<WithName<Table<"_storage", Schema.Struct<{
       sha256: typeof Schema.String;
       size: typeof Schema.Number;
       contentType: Schema.optionalWith<typeof Schema.String, {
@@ -1117,14 +1122,11 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
 } | {
   table: <const TableName extends TableNames<FromSchema<Schema>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<Schema>, TableName>>) => Effect.Effect<convex_values0.GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: convex_values0.GenericId<TableName>, patchedValues: Partial<convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | DocumentEncodeError | GetByIdFailure, never>;
+    patch: (id: convex_values0.GenericId<TableName>, patchedValues: Partial<convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: convex_values0.GenericId<TableName>, value: convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: convex_values0.GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
-} | {
-  runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-  runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | StorageReader$1 | StorageWriter$1, never, never>;
+} | Auth$1 | StorageReader$1 | StorageWriter$1 | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>), never, never>;
 type MutationServices<Schema extends AnyWithProps> = DatabaseReader<Schema> | DatabaseWriter<Schema> | Auth$1 | Scheduler$1 | StorageReader$1 | StorageWriter$1 | QueryRunner | MutationRunner | MutationCtx<ToConvex<FromSchema<Schema>>>;
 //#endregion
 export { MutationServices, RegisteredConvexFunction_d_exports, make, mutationLayer };

package/dist/RegisteredConvexFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCa,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAkLU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,oBAAlD,kBAAA,CAAkD,WAAA,EAAA,QAAA,EAAA,QAAA,KAAA,IAAA,EAAA,kBAAA,CAAA,YAAA,CAAA,QAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,QAAA,GAAA,kBAAA,CAAA,KAAA,CAAA,QAAA,IAAA,mBAAA,CAAA,UAAA,KAAA,MAAA,mBAAA,kBAAA,CAAA,QAAA,EAAA,KAAA,EAAA,KAAA,KAAA,IAAA,EAAA,kBAAA,CAAA,YAAA,CAAA,KAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,KAAA,GAAA,kBAAA,CAAA,KAAA,CAAA,KAAA,IAAA,mBAAA,CAAA,UAAA,KAAA,kBAAA,CAAA,QAAA,CAAA,UAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoB/D,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}
+{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAkLU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,iBAAlD,kBAAA,CAAkD,QAAA,EAAA,KAAA,EAAA,KAAA,KAAA,IAAA,EAAA,kBAAA,CAAA,YAAA,CAAA,KAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,KAAA,GAAA,kBAAA,CAAA,KAAA,CAAA,KAAA,IAAA,mBAAA,CAAA,UAAA;0BAAA,kBAAA,CAAA,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoB/D,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}

package/dist/RegisteredConvexFunction.js

@@ -12,8 +12,13 @@ import { StorageWriter as StorageWriter$1 } from "./StorageWriter.js";
 import { MutationCtx } from "./MutationCtx.js";
 import { QueryCtx } from "./QueryCtx.js";
 import { actionFunctionBase, actionLayer, runHandlerPromise } from "./RegisteredFunction.js";
-import { Clock, Effect, Layer, Match, Schema, pipe } from "effect";
 import { actionGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, mutationGeneric, queryGeneric } from "convex/server";
+import * as Layer from "effect/Layer";
+import { pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Match from "effect/Match";
+import * as Clock from "effect/Clock";
 
 //#region src/RegisteredConvexFunction.ts
 var RegisteredConvexFunction_exports = /* @__PURE__ */ __exportAll({