@confect/server 9.0.0-next.0 → 9.0.0-next.10

package/dist/RegisteredConvexFunction.d.ts

@@ -1,64 +1,1111 @@
-import { Name, WithName } from "./Table.js";
-import { AnyWithProps, IncludeSystemTables, Tables } from "./DatabaseSchema.js";
-import { AnyWithPropsWithRuntime } from "./Api.js";
-import { Auth as Auth$1 } from "./Auth.js";
-import { DocumentDecodeError, DocumentEncodeError, WithoutSystemFields as WithoutSystemFields$1 } from "./Document.js";
-import { TableInfo } from "./TableInfo.js";
-import { DataModel, DocumentByName, FromSchema, TableInfoWithName, TableNames, ToConvex } from "./DataModel.js";
-import { OrderedQuery as OrderedQuery$1 } from "./OrderedQuery.js";
-import { GetByIdFailure, GetByIndexFailure } from "./QueryInitializer.js";
-import { DatabaseReader } from "./DatabaseReader.js";
-import { DatabaseWriter } from "./DatabaseWriter.js";
-import { MutationCtx } from "./MutationCtx.js";
-import { MutationRunner } from "./MutationRunner.js";
-import { QueryRunner } from "./QueryRunner.js";
-import { Scheduler as Scheduler$1 } from "./Scheduler.js";
-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 } 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_Duration0 from "effect/Duration";
-import * as effect_DateTime0 from "effect/DateTime";
-import * as effect_ParseResult0 from "effect/ParseResult";
-
-//#region src/RegisteredConvexFunction.d.ts
-declare namespace RegisteredConvexFunction_d_exports {
-  export { MutationServices, make, mutationLayer };
-}
-declare const make: <Api_ extends AnyWithPropsWithRuntime<"Convex">>(api: Api_, {
-  functionSpec,
-  handler
-}: AnyWithProps$1) => Any;
-declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<Auth$1 | {
-  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 | (<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>) | (<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>) | GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
-  table: <const TableName extends Name<IncludeSystemTables<Tables<Schema>>>>(tableName: TableName) => {
-    readonly get: {
-      (id: convex_values0.GenericId<TableName>): Effect.Effect<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<Schema>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["indexes"][IndexName]>): Effect.Effect<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
+import { type GenericMutationCtx } from "convex/server";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Auth from "./Auth";
+import * as DatabaseReader from "./DatabaseReader";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import * as DatabaseWriter from "./DatabaseWriter";
+import type * as DataModel from "./DataModel";
+import * as MutationCtx from "./MutationCtx";
+import * as MutationRunner from "./MutationRunner";
+import * as QueryRunner from "./QueryRunner";
+import * as RegisteredFunction from "./RegisteredFunction";
+import type * as RegistryItem from "./RegistryItem";
+import * as Scheduler from "./Scheduler";
+import { StorageReader } from "./StorageReader";
+import { StorageWriter } from "./StorageWriter";
+export declare const make: (databaseSchema: DatabaseSchema.AnyWithProps, { functionSpec, handler }: RegistryItem.AnyWithProps) => RegisteredFunction.Any;
+export declare const mutationLayer: <Schema extends DatabaseSchema.AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>) => Layer.Layer<Auth.Auth | (<Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, ...args: import("@confect/core/Ref").OptionalArgs<Mutation>) => Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | import("effect/ParseResult").ParseError>) | (<Query extends import("@confect/core/Ref").AnyQuery>(query: Query, ...args: import("@confect/core/Ref").OptionalArgs<Query>) => Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | import("effect/ParseResult").ParseError>) | {
+    runAfter: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(delay: import("effect/Duration").Duration, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
+    runAt: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(dateTime: import("effect/DateTime").DateTime, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
+} | StorageReader | StorageWriter | GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>> | {
+    table: <const TableName extends "_scheduled_functions" | "_storage" | import("./Table").Name<DatabaseSchema.Tables<Schema>>>(tableName: TableName) => {
+        readonly get: {
+            (id: import("convex/values").GenericId<TableName>): Effect.Effect<(import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["document"], import("./Document").DocumentDecodeError | import("./QueryInitializer").GetByIdFailure, never>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: import("@confect/core/Types").IndexFieldTypesForEq<DataModel.ToConvex<DataModel.DataModel<import("./Table").SystemTables | DatabaseSchema.Tables<Schema>>>, TableName, (import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["indexes"][IndexName]>): Effect.Effect<(import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["document"], import("./Document").DocumentDecodeError | import("./QueryInitializer").GetByIndexFailure, never>;
+        };
+        readonly index: {
+            <IndexName extends keyof (import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["indexes"]>(indexName: IndexName, indexRange?: ((q: import("convex/server").IndexRangeBuilder<(import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["convexDocument"], import("convex/server").NamedIndex<DataModel.TableInfoWithName<DataModel.DataModel<import("./Table").SystemTables | DatabaseSchema.Tables<Schema>>, TableName>, IndexName>, 0>) => import("convex/server").IndexRange) | undefined, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>, TableName>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+                name: typeof Schema.String;
+                args: Schema.Array$<typeof Schema.Any>;
+                scheduledTime: typeof Schema.Number;
+                completedTime: Schema.optionalWith<typeof Schema.Number, {
+                    exact: true;
+                }>;
+                state: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["pending"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["inProgress"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["success"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["failed"]>;
+                    error: typeof Schema.String;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["canceled"]>;
+                }>]>;
+            }>, import("convex/values").VObject<{
+                name: string;
+                args: any[];
+                scheduledTime: number;
+                state: {
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                };
+                completedTime?: number;
+            }, {
+                name: import("convex/values").VString<string, "required">;
+                args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+                scheduledTime: import("convex/values").VFloat64<number, "required">;
+                state: import("convex/values").VUnion<{
+                    kind: "pending";
+                } | {
+                    kind: "inProgress";
+                } | {
+                    kind: "success";
+                } | {
+                    kind: "failed";
+                    error: string;
+                } | {
+                    kind: "canceled";
+                }, [import("convex/values").VObject<{
+                    kind: "pending";
+                }, {
+                    kind: import("convex/values").VLiteral<"pending", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "inProgress";
+                }, {
+                    kind: import("convex/values").VLiteral<"inProgress", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "success";
+                }, {
+                    kind: import("convex/values").VLiteral<"success", "required">;
+                }, "required", "kind">, import("convex/values").VObject<{
+                    kind: "failed";
+                    error: string;
+                }, {
+                    kind: import("convex/values").VLiteral<"failed", "required">;
+                    error: import("convex/values").VString<string, "required">;
+                }, "required", "kind" | "error">, import("convex/values").VObject<{
+                    kind: "canceled";
+                }, {
+                    kind: import("convex/values").VLiteral<"canceled", "required">;
+                }, "required", "kind">], "required", "kind" | "error">;
+                completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+                sha256: typeof Schema.String;
+                size: typeof Schema.Number;
+                contentType: Schema.optionalWith<typeof Schema.String, {
+                    exact: true;
+                }>;
+            }>, import("convex/values").VObject<{
+                sha256: string;
+                size: number;
+                contentType?: string;
+            }, {
+                sha256: import("convex/values").VString<string, "required">;
+                size: import("convex/values").VFloat64<number, "required">;
+                contentType: import("convex/values").VString<string | undefined, "optional">;
+            }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>, TableName>;
+        };
+        readonly search: <IndexName extends keyof (import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+            name: typeof Schema.String;
+            args: Schema.Array$<typeof Schema.Any>;
+            scheduledTime: typeof Schema.Number;
+            completedTime: Schema.optionalWith<typeof Schema.Number, {
+                exact: true;
+            }>;
+            state: Schema.Union<[Schema.Struct<{
+                kind: Schema.Literal<["pending"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["inProgress"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["success"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["failed"]>;
+                error: typeof Schema.String;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["canceled"]>;
+            }>]>;
+        }>, import("convex/values").VObject<{
+            name: string;
+            args: any[];
+            scheduledTime: number;
+            state: {
+                kind: "pending";
+            } | {
+                kind: "inProgress";
+            } | {
+                kind: "success";
+            } | {
+                kind: "failed";
+                error: string;
+            } | {
+                kind: "canceled";
+            };
+            completedTime?: number;
+        }, {
+            name: import("convex/values").VString<string, "required">;
+            args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+            scheduledTime: import("convex/values").VFloat64<number, "required">;
+            state: import("convex/values").VUnion<{
+                kind: "pending";
+            } | {
+                kind: "inProgress";
+            } | {
+                kind: "success";
+            } | {
+                kind: "failed";
+                error: string;
+            } | {
+                kind: "canceled";
+            }, [import("convex/values").VObject<{
+                kind: "pending";
+            }, {
+                kind: import("convex/values").VLiteral<"pending", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "inProgress";
+            }, {
+                kind: import("convex/values").VLiteral<"inProgress", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "success";
+            }, {
+                kind: import("convex/values").VLiteral<"success", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "failed";
+                error: string;
+            }, {
+                kind: import("convex/values").VLiteral<"failed", "required">;
+                error: import("convex/values").VString<string, "required">;
+            }, "required", "kind" | "error">, import("convex/values").VObject<{
+                kind: "canceled";
+            }, {
+                kind: import("convex/values").VLiteral<"canceled", "required">;
+            }, "required", "kind">], "required", "kind" | "error">;
+            completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+            sha256: typeof Schema.String;
+            size: typeof Schema.Number;
+            contentType: Schema.optionalWith<typeof Schema.String, {
+                exact: true;
+            }>;
+        }>, import("convex/values").VObject<{
+            sha256: string;
+            size: number;
+            contentType?: string;
+        }, {
+            sha256: import("convex/values").VString<string, "required">;
+            size: import("convex/values").VFloat64<number, "required">;
+            contentType: import("convex/values").VString<string | undefined, "optional">;
+        }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["searchIndexes"]>(indexName: IndexName, searchFilter: (q: import("convex/server").SearchFilterBuilder<(import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+            name: typeof Schema.String;
+            args: Schema.Array$<typeof Schema.Any>;
+            scheduledTime: typeof Schema.Number;
+            completedTime: Schema.optionalWith<typeof Schema.Number, {
+                exact: true;
+            }>;
+            state: Schema.Union<[Schema.Struct<{
+                kind: Schema.Literal<["pending"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["inProgress"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["success"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["failed"]>;
+                error: typeof Schema.String;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["canceled"]>;
+            }>]>;
+        }>, import("convex/values").VObject<{
+            name: string;
+            args: any[];
+            scheduledTime: number;
+            state: {
+                kind: "pending";
+            } | {
+                kind: "inProgress";
+            } | {
+                kind: "success";
+            } | {
+                kind: "failed";
+                error: string;
+            } | {
+                kind: "canceled";
+            };
+            completedTime?: number;
+        }, {
+            name: import("convex/values").VString<string, "required">;
+            args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+            scheduledTime: import("convex/values").VFloat64<number, "required">;
+            state: import("convex/values").VUnion<{
+                kind: "pending";
+            } | {
+                kind: "inProgress";
+            } | {
+                kind: "success";
+            } | {
+                kind: "failed";
+                error: string;
+            } | {
+                kind: "canceled";
+            }, [import("convex/values").VObject<{
+                kind: "pending";
+            }, {
+                kind: import("convex/values").VLiteral<"pending", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "inProgress";
+            }, {
+                kind: import("convex/values").VLiteral<"inProgress", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "success";
+            }, {
+                kind: import("convex/values").VLiteral<"success", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "failed";
+                error: string;
+            }, {
+                kind: import("convex/values").VLiteral<"failed", "required">;
+                error: import("convex/values").VString<string, "required">;
+            }, "required", "kind" | "error">, import("convex/values").VObject<{
+                kind: "canceled";
+            }, {
+                kind: import("convex/values").VLiteral<"canceled", "required">;
+            }, "required", "kind">], "required", "kind" | "error">;
+            completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+            sha256: typeof Schema.String;
+            size: typeof Schema.Number;
+            contentType: Schema.optionalWith<typeof Schema.String, {
+                exact: true;
+            }>;
+        }>, import("convex/values").VObject<{
+            sha256: string;
+            size: number;
+            contentType?: string;
+        }, {
+            sha256: import("convex/values").VString<string, "required">;
+            size: import("convex/values").VFloat64<number, "required">;
+            contentType: import("convex/values").VString<string | undefined, "optional">;
+        }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>)["convexDocument"], import("convex/server").NamedSearchIndex<DataModel.TableInfoWithName<DataModel.DataModel<import("./Table").SystemTables | DatabaseSchema.Tables<Schema>>, TableName>, IndexName>>) => import("convex/server").SearchFilter) => import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_scheduled_functions", Schema.Struct<{
+            name: typeof Schema.String;
+            args: Schema.Array$<typeof Schema.Any>;
+            scheduledTime: typeof Schema.Number;
+            completedTime: Schema.optionalWith<typeof Schema.Number, {
+                exact: true;
+            }>;
+            state: Schema.Union<[Schema.Struct<{
+                kind: Schema.Literal<["pending"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["inProgress"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["success"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["failed"]>;
+                error: typeof Schema.String;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["canceled"]>;
+            }>]>;
+        }>, import("convex/values").VObject<{
+            name: string;
+            args: any[];
+            scheduledTime: number;
+            state: {
+                kind: "pending";
+            } | {
+                kind: "inProgress";
+            } | {
+                kind: "success";
+            } | {
+                kind: "failed";
+                error: string;
+            } | {
+                kind: "canceled";
+            };
+            completedTime?: number;
+        }, {
+            name: import("convex/values").VString<string, "required">;
+            args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+            scheduledTime: import("convex/values").VFloat64<number, "required">;
+            state: import("convex/values").VUnion<{
+                kind: "pending";
+            } | {
+                kind: "inProgress";
+            } | {
+                kind: "success";
+            } | {
+                kind: "failed";
+                error: string;
+            } | {
+                kind: "canceled";
+            }, [import("convex/values").VObject<{
+                kind: "pending";
+            }, {
+                kind: import("convex/values").VLiteral<"pending", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "inProgress";
+            }, {
+                kind: import("convex/values").VLiteral<"inProgress", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "success";
+            }, {
+                kind: import("convex/values").VLiteral<"success", "required">;
+            }, "required", "kind">, import("convex/values").VObject<{
+                kind: "failed";
+                error: string;
+            }, {
+                kind: import("convex/values").VLiteral<"failed", "required">;
+                error: import("convex/values").VString<string, "required">;
+            }, "required", "kind" | "error">, import("convex/values").VObject<{
+                kind: "canceled";
+            }, {
+                kind: import("convex/values").VLiteral<"canceled", "required">;
+            }, "required", "kind">], "required", "kind" | "error">;
+            completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<import("./Table").Table<"_storage", Schema.Struct<{
+            sha256: typeof Schema.String;
+            size: typeof Schema.Number;
+            contentType: Schema.optionalWith<typeof Schema.String, {
+                exact: true;
+            }>;
+        }>, import("convex/values").VObject<{
+            sha256: string;
+            size: number;
+            contentType?: string;
+        }, {
+            sha256: import("convex/values").VString<string, "required">;
+            size: import("convex/values").VFloat64<number, "required">;
+            contentType: import("convex/values").VString<string | undefined, "optional">;
+        }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>> | import("./TableInfo").TableInfo<import("./Table").WithName<DatabaseSchema.Tables<Schema>, TableName>>, TableName>;
     };
-    readonly index: {
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["indexes"]>(indexName: IndexName, indexRange?: ((q: convex_server0.IndexRangeBuilder<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<Schema>>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>, TableName>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>, TableName>;
-    };
-    readonly search: <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["searchIndexes"]>(indexName: IndexName, searchFilter: (q: convex_server0.SearchFilterBuilder<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<Schema>>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>, TableName>;
-  };
 } | {
-  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 | GetByIdFailure | 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>;
-  };
+    table: <const TableName extends DataModel.TableNames<DataModel.FromSchema<Schema>>>(tableName: TableName) => {
+        insert: (document: import("./Document").WithoutSystemFields<DataModel.DocumentByName<DataModel.FromSchema<Schema>, TableName>>) => Effect.Effect<import("convex/values").GenericId<TableName>, import("./Document").DocumentEncodeError, never>;
+        patch: (id: import("convex/values").GenericId<TableName>, patchedValues: Partial<import("convex/server").Expand<import("convex/server").BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<Schema>, TableName>, "_creationTime" | "_id">>>) => Effect.Effect<void, import("./Document").DocumentDecodeError | import("./Document").DocumentEncodeError | import("./QueryInitializer").GetByIdFailure, never>;
+        replace: (id: import("convex/values").GenericId<TableName>, value: import("convex/server").Expand<import("convex/server").BetterOmit<DataModel.DocumentByName<DataModel.FromSchema<Schema>, TableName>, "_creationTime" | "_id">>) => Effect.Effect<void, import("./Document").DocumentEncodeError, never>;
+        delete: (id: import("convex/values").GenericId<TableName>) => Effect.Effect<void, never, never>;
+    };
 }, 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 };
+export type MutationServices<Schema extends DatabaseSchema.AnyWithProps> = DatabaseReader.DatabaseReader<Schema> | DatabaseWriter.DatabaseWriter<Schema> | Auth.Auth | Scheduler.Scheduler | StorageReader | StorageWriter | QueryRunner.QueryRunner | MutationRunner.MutationRunner | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;
 //# sourceMappingURL=RegisteredConvexFunction.d.ts.map