import { type DefaultFunctionArgs, type FunctionVisibility, type GenericMutationCtx, type GenericQueryCtx } from "convex/server";
import type { Value } from "convex/values";
import * as Data from "effect/Data";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Auth from "./Auth";
import * as DatabaseReader from "./DatabaseReader";
import type * as DatabaseSchema from "./DatabaseSchema";
import * as DatabaseWriter from "./DatabaseWriter";
import type * as DataModel from "./DataModel";
import * as ExecutionMetadata from "./ExecutionMetadata";
import * as RequestMetadata from "./RequestMetadata";
import * as TransactionMetadata from "./TransactionMetadata";
import * as MutationCtx from "./MutationCtx";
import * as MutationRunner from "./MutationRunner";
import * as MutationTransactionContext from "./MutationTransactionContext";
import * as QueryCtx from "./QueryCtx";
import * as QueryRunner from "./QueryRunner";
import * as QueryTransactionContext from "./QueryTransactionContext";
import * as RegisteredFunction from "./RegisteredFunction";
import type * as FunctionRegistryItem from "./FunctionRegistryItem";
import type * as ResolvedMiddleware from "./ResolvedMiddleware";
import * as Scheduler from "./Scheduler";
import * as Storage from "./Storage";
import type { StorageReader } from "./StorageReader";
import { StorageWriter } from "./StorageWriter";
export type Definition = Data.TaggedEnum<{
    PublicQuery: ReturnType<typeof queryFunction>;
    InternalQuery: ReturnType<typeof queryFunction>;
    PublicMutation: ReturnType<typeof mutationFunction>;
    InternalMutation: ReturnType<typeof mutationFunction>;
    PublicAction: ReturnType<typeof convexActionFunction>;
    InternalAction: ReturnType<typeof convexActionFunction>;
    Registered: {
        readonly handler: RegisteredFunction.Any;
    };
}>;
export declare const Definition: {
    readonly $is: <Tag extends "InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered">(tag: Tag) => (u: unknown) => u is Extract<{
        readonly _tag: "InternalAction";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "InternalMutation";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "InternalQuery";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "PublicAction";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "PublicMutation";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "PublicQuery";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, {
        readonly _tag: Tag;
    }> | Extract<{
        readonly _tag: "Registered";
        readonly handler: RegisteredFunction.Any;
    }, {
        readonly _tag: Tag;
    }>;
    readonly $match: {
        <Cases extends { readonly [Tag in "InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]: (args: Extract<{
            readonly _tag: "InternalAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "Registered";
            readonly handler: RegisteredFunction.Any;
        }, {
            readonly _tag: Tag;
        }>) => any; }>(cases: Cases): (value: {
            readonly _tag: "InternalAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "Registered";
            readonly handler: RegisteredFunction.Any;
        }) => import("effect/Unify").Unify<ReturnType<Cases["InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]>>;
        <Cases extends { readonly [Tag in "InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]: (args: Extract<{
            readonly _tag: "InternalAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "Registered";
            readonly handler: RegisteredFunction.Any;
        }, {
            readonly _tag: Tag;
        }>) => any; }>(value: {
            readonly _tag: "InternalAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "InternalQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicAction";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicMutation";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "PublicQuery";
            readonly args: import("convex/values").PropertyValidators;
            readonly returns: import("convex/values").Validator<any, any, any>;
            readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
        } | {
            readonly _tag: "Registered";
            readonly handler: RegisteredFunction.Any;
        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["InternalAction" | "InternalMutation" | "InternalQuery" | "PublicAction" | "PublicMutation" | "PublicQuery" | "Registered"]>>;
    };
    readonly InternalAction: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "InternalAction";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, "_tag">;
    readonly InternalMutation: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "InternalMutation";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, "_tag">;
    readonly InternalQuery: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "InternalQuery";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, "_tag">;
    readonly PublicAction: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "PublicAction";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, "_tag">;
    readonly PublicMutation: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "PublicMutation";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, "_tag">;
    readonly PublicQuery: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "PublicQuery";
        readonly args: import("convex/values").PropertyValidators;
        readonly returns: import("convex/values").Validator<any, any, any>;
        readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
    }, "_tag">;
    readonly Registered: Data.TaggedEnum.ConstructorFrom<{
        readonly _tag: "Registered";
        readonly handler: RegisteredFunction.Any;
    }, "_tag">;
};
export declare const prepare: (databaseSchema: DatabaseSchema.AnyWithProps, item: FunctionRegistryItem.ConfectFunctionRegistryItem, resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>) => {
    readonly _tag: "InternalAction";
    readonly args: import("convex/values").PropertyValidators;
    readonly returns: import("convex/values").Validator<any, any, any>;
    readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
} | {
    readonly _tag: "InternalMutation";
    readonly args: import("convex/values").PropertyValidators;
    readonly returns: import("convex/values").Validator<any, any, any>;
    readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
} | {
    readonly _tag: "InternalQuery";
    readonly args: import("convex/values").PropertyValidators;
    readonly returns: import("convex/values").Validator<any, any, any>;
    readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
} | {
    readonly _tag: "PublicAction";
    readonly args: import("convex/values").PropertyValidators;
    readonly returns: import("convex/values").Validator<any, any, any>;
    readonly handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
} | {
    readonly _tag: "PublicMutation";
    readonly args: import("convex/values").PropertyValidators;
    readonly returns: import("convex/values").Validator<any, any, any>;
    readonly handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
} | {
    readonly _tag: "PublicQuery";
    readonly args: import("convex/values").PropertyValidators;
    readonly returns: import("convex/values").Validator<any, any, any>;
    readonly handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: DefaultFunctionArgs) => Promise<unknown>;
};
export declare const make: (databaseSchema: DatabaseSchema.AnyWithProps, item: FunctionRegistryItem.ConfectFunctionRegistryItem, resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>) => RegisteredFunction.Any;
export declare const register: (self: Definition) => RegisteredFunction.Any;
declare const queryFunction: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E>({ databaseSchema, name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, }: {
    databaseSchema: DatabaseSchema_;
    name: string;
    functionVisibility: FunctionVisibility;
    args: Schema.Codec<Args, ConvexArgs>;
    returns: Schema.Codec<Returns, ConvexReturns>;
    error: Schema.Codec<Error, Value> | undefined;
    handler: (a: Args) => Effect.Effect<Returns, E, DatabaseReader.DatabaseReader<DatabaseSchema_> | Auth.Auth | ExecutionMetadata.ExecutionMetadata | TransactionMetadata.TransactionMetadata | Storage.Storage | StorageReader | QueryRunner.QueryRunner | QueryTransactionContext.QueryTransactionContext | QueryCtx.QueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>>;
    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
}) => {
    args: import("convex/values").PropertyValidators;
    returns: import("convex/values").Validator<any, any, any>;
    handler: (ctx: GenericQueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
};
export declare const mutationLayer: <Schema extends DatabaseSchema.AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>) => Layer.Layer<Auth.Auth | DatabaseReader.DatabaseReaderService<Schema, {}> | DatabaseWriter.DatabaseWriterService<Schema, {}> | ExecutionMetadata.ExecutionMetadata | GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>> | MutationTransactionContext.MutationTransactionContext | QueryTransactionContext.QueryTransactionContext | RequestMetadata.RequestMetadata | Storage.Storage | StorageReader | StorageWriter | TransactionMetadata.TransactionMetadata | {
    runMutation: {
        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, ...args: [...import("@confect/core/Ref").OptionalArgs<Mutation>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError>;
        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, args: import("@confect/core/Ref").Args<Mutation>, options: MutationRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError, MutationTransactionContext.MutationTransactionContext>;
    };
} | {
    runQuery: {
        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, ...args: [...import("@confect/core/Ref").OptionalArgs<Query>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError>;
        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: (QueryTransactionContext.Options & {
            readonly useStaleSnapshot?: never;
        }) | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, QueryTransactionContext.QueryTransactionContext>;
        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options & {
            readonly useStaleSnapshot: boolean;
        }): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, MutationTransactionContext.MutationTransactionContext>;
        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, QueryTransactionContext.QueryTransactionContext | MutationTransactionContext.MutationTransactionContext>;
    };
} | {
    cancel: (id: import("convex/values").GenericId<"_scheduled_functions">) => Effect.Effect<void, never, never>;
    runAfter: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(delay: Duration.Duration, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
    runAt: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(dateTime: import("effect/DateTime").DateTime, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
}, never, never>;
export type MutationServices<Schema extends DatabaseSchema.AnyWithProps> = DatabaseReader.DatabaseReader<Schema> | DatabaseWriter.DatabaseWriter<Schema> | Auth.Auth | ExecutionMetadata.ExecutionMetadata | RequestMetadata.RequestMetadata | TransactionMetadata.TransactionMetadata | Scheduler.Scheduler | Storage.Storage | StorageReader | StorageWriter | QueryRunner.QueryRunner | MutationRunner.MutationRunner | QueryTransactionContext.QueryTransactionContext | MutationTransactionContext.MutationTransactionContext | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;
declare const mutationFunction: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E>({ databaseSchema, name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, }: {
    databaseSchema: DatabaseSchema_;
    name: string;
    functionVisibility: FunctionVisibility;
    args: Schema.Codec<Args, ConvexArgs>;
    returns: Schema.Codec<Returns, ConvexReturns>;
    error: Schema.Codec<Error, Value> | undefined;
    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;
    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
}) => {
    args: import("convex/values").PropertyValidators;
    returns: import("convex/values").Validator<any, any, any>;
    handler: (ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
};
declare const convexActionFunction: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E>(schema: DatabaseSchema_, { name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, }: {
    name: string;
    functionVisibility: FunctionVisibility;
    args: Schema.Codec<Args, ConvexArgs>;
    returns: Schema.Codec<Returns, ConvexReturns>;
    error: Schema.Codec<any, any> | undefined;
    handler: (a: Args) => Effect.Effect<Returns, E, RegisteredFunction.ActionServices<DatabaseSchema_>>;
    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
}) => {
    args: import("convex/values").PropertyValidators;
    returns: import("convex/values").Validator<any, any, any>;
    handler: (ctx: import("convex/server").GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema.AnyWithProps>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
};
export {};
//# sourceMappingURL=RegisteredConvexFunction.d.ts.map