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

package/dist/DatabaseReader.d.ts

@@ -1,73 +1,4332 @@
-import { Name, WithName } from "./Table.js";
-import { AnyWithProps, IncludeSystemTables, Tables } from "./DatabaseSchema.js";
-import { DocumentDecodeError } from "./Document.js";
-import { TableInfo } from "./TableInfo.js";
-import { DataModel, FromSchema, TableInfoWithName, ToConvex } from "./DataModel.js";
-import { OrderedQuery as OrderedQuery$1 } from "./OrderedQuery.js";
-import { GetByIdFailure, GetByIndexFailure } from "./QueryInitializer.js";
-import { Context, Layer } from "effect";
-import * as convex_server0 from "convex/server";
-import { GenericDatabaseReader } from "convex/server";
-import * as convex_values0 from "convex/values";
-import * as _confect_core_Types0 from "@confect/core/Types";
-import * as effect_Effect0 from "effect/Effect";
-
-//#region src/DatabaseReader.d.ts
-declare namespace DatabaseReader_d_exports {
-  export { DatabaseReader, layer, make };
-}
-declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<ToConvex<FromSchema<DatabaseSchema_>>>) => {
-  table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
-    readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
+import type { GenericDatabaseReader } from "convex/server";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DataModel from "./DataModel";
+import * as QueryInitializer from "./QueryInitializer";
+import * as Table from "./Table";
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => {
+    table: <const TableName extends Table.Name<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>>(tableName: TableName) => {
+        readonly get: {
+            (id: import("convex/values").GenericId<TableName>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIdFailure, never>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: import("@confect/core/Types").IndexFieldTypesForEq<DataModel.ToConvex<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>>, TableName, (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"][IndexName]>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIndexFailure, never>;
+        };
+        readonly index: {
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, indexRange?: ((q: import("convex/server").IndexRangeBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>, 0>) => import("convex/server").IndexRange) | undefined, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+        };
+        readonly search: <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["searchIndexes"]>(indexName: IndexName, searchFilter: (q: import("convex/server").SearchFilterBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedSearchIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>>) => import("convex/server").SearchFilter) => import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
     };
-    readonly index: {
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, indexRange?: ((q: convex_server0.IndexRangeBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-    };
-    readonly search: <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["searchIndexes"]>(indexName: IndexName, searchFilter: (q: convex_server0.SearchFilterBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-  };
 };
-declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
-  table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
-    readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
-    };
-    readonly index: {
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, indexRange?: ((q: convex_server0.IndexRangeBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
+export declare const DatabaseReader: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>() => Context.Tag<{
+    table: <const TableName extends "_scheduled_functions" | "_storage" | Table.Name<DatabaseSchema.Tables<DatabaseSchema_>>>(tableName: TableName) => {
+        readonly get: {
+            (id: import("convex/values").GenericId<TableName>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIdFailure, never>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: import("@confect/core/Types").IndexFieldTypesForEq<DataModel.ToConvex<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>>, TableName, (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"][IndexName]>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIndexFailure, never>;
+        };
+        readonly index: {
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, indexRange?: ((q: import("convex/server").IndexRangeBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>, 0>) => import("convex/server").IndexRange) | undefined, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+        };
+        readonly search: <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["searchIndexes"]>(indexName: IndexName, searchFilter: (q: import("convex/server").SearchFilterBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedSearchIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>>) => import("convex/server").SearchFilter) => import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
     };
-    readonly search: <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["searchIndexes"]>(indexName: IndexName, searchFilter: (q: convex_server0.SearchFilterBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-  };
 }, {
-  table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
-    readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
+    table: <const TableName extends "_scheduled_functions" | "_storage" | Table.Name<DatabaseSchema.Tables<DatabaseSchema_>>>(tableName: TableName) => {
+        readonly get: {
+            (id: import("convex/values").GenericId<TableName>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIdFailure, never>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: import("@confect/core/Types").IndexFieldTypesForEq<DataModel.ToConvex<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>>, TableName, (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"][IndexName]>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIndexFailure, never>;
+        };
+        readonly index: {
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, indexRange?: ((q: import("convex/server").IndexRangeBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>, 0>) => import("convex/server").IndexRange) | undefined, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+        };
+        readonly search: <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["searchIndexes"]>(indexName: IndexName, searchFilter: (q: import("convex/server").SearchFilterBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedSearchIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>>) => import("convex/server").SearchFilter) => import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
     };
-    readonly index: {
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, indexRange?: ((q: convex_server0.IndexRangeBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-    };
-    readonly search: <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["searchIndexes"]>(indexName: IndexName, searchFilter: (q: convex_server0.SearchFilterBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-  };
 }>;
-type DatabaseReader<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof DatabaseReader<DatabaseSchema_>>["Identifier"];
-declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
-  table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
-    readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
-    };
-    readonly index: {
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, indexRange?: ((q: convex_server0.IndexRangeBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-      <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
+export type DatabaseReader<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = ReturnType<typeof DatabaseReader<DatabaseSchema_>>["Identifier"];
+export declare const layer: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
+    table: <const TableName extends "_scheduled_functions" | "_storage" | Table.Name<DatabaseSchema.Tables<DatabaseSchema_>>>(tableName: TableName) => {
+        readonly get: {
+            (id: import("convex/values").GenericId<TableName>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIdFailure, never>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: import("@confect/core/Types").IndexFieldTypesForEq<DataModel.ToConvex<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>>, TableName, (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"][IndexName]>): import("effect/Effect").Effect<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["document"], import("./Document").DocumentDecodeError | QueryInitializer.GetByIndexFailure, never>;
+        };
+        readonly index: {
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, indexRange?: ((q: import("convex/server").IndexRangeBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>, 0>) => import("convex/server").IndexRange) | undefined, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+            <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["indexes"]>(indexName: IndexName, order?: "asc" | "desc"): import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+                name: typeof import("effect/Schema").String;
+                args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+                scheduledTime: typeof import("effect/Schema").Number;
+                completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                    exact: true;
+                }>;
+                state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["pending"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["inProgress"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["success"]>;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/Schema").Literal<["failed"]>;
+                    error: typeof import("effect/Schema").String;
+                }>, import("effect/Schema").Struct<{
+                    kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+                sha256: typeof import("effect/Schema").String;
+                size: typeof import("effect/Schema").Number;
+                contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
+        };
+        readonly search: <IndexName extends keyof (import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["searchIndexes"]>(indexName: IndexName, searchFilter: (q: import("convex/server").SearchFilterBuilder<(import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>)["convexDocument"], import("convex/server").NamedSearchIndex<DataModel.TableInfoWithName<DataModel.DataModel<Table.SystemTables | DatabaseSchema.Tables<DatabaseSchema_>>, TableName>, IndexName>>) => import("convex/server").SearchFilter) => import("./OrderedQuery").OrderedQuery<import("./TableInfo").TableInfo<Table.WithName<Table.Table<"_scheduled_functions", import("effect/Schema").Struct<{
+            name: typeof import("effect/Schema").String;
+            args: import("effect/Schema").Array$<typeof import("effect/Schema").Any>;
+            scheduledTime: typeof import("effect/Schema").Number;
+            completedTime: import("effect/Schema").optionalWith<typeof import("effect/Schema").Number, {
+                exact: true;
+            }>;
+            state: import("effect/Schema").Union<[import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["pending"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["inProgress"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["success"]>;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/Schema").Literal<["failed"]>;
+                error: typeof import("effect/Schema").String;
+            }>, import("effect/Schema").Struct<{
+                kind: import("effect/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<Table.WithName<Table.Table<"_storage", import("effect/Schema").Struct<{
+            sha256: typeof import("effect/Schema").String;
+            size: typeof import("effect/Schema").Number;
+            contentType: import("effect/Schema").optionalWith<typeof import("effect/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<Table.WithName<DatabaseSchema.Tables<DatabaseSchema_>, TableName>>, TableName>;
     };
-    readonly search: <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["searchIndexes"]>(indexName: IndexName, searchFilter: (q: convex_server0.SearchFilterBuilder<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>, TableName>;
-  };
 }, never, never>;
-//#endregion
-export { DatabaseReader, DatabaseReader_d_exports, layer, make };
 //# sourceMappingURL=DatabaseReader.d.ts.map