import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
import { type DefaultFunctionArgs, type FunctionVisibility, type GenericActionCtx, type GenericDataModel, type RegisteredAction, type RegisteredMutation, type RegisteredQuery } from "convex/server";
import type { Value } from "convex/values";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import type * as EffectScheduler from "effect/Scheduler";
import * as ActionCtx from "./ActionCtx";
import * as ActionRunner from "./ActionRunner";
import * as Auth from "./Auth";
import type * as DatabaseSchema from "./DatabaseSchema";
import type * as DataModel from "./DataModel";
import * as ExecutionMetadata from "./ExecutionMetadata";
import * as RequestMetadata from "./RequestMetadata";
import * as MutationRunner from "./MutationRunner";
import * as QueryRunner from "./QueryRunner";
import type * as ResolvedMiddleware from "./ResolvedMiddleware";
import * as Scheduler from "./Scheduler";
import * as Storage from "./Storage";
import * as StorageActionWriter from "./StorageActionWriter";
import type * as StorageReader from "./StorageReader";
import * as StorageWriter from "./StorageWriter";
import * as VectorSearch from "./VectorSearch";
export type Any = RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
type ConfectRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends DefaultFunctionArgs ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : never : never;
export type ConvexRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends FunctionSpec.AnyWithProps ? FunctionSpec.GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<infer Args_ extends DefaultFunctionArgs, infer Returns_> ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : never : never : never;
export type RegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConvex> ? ConvexRegisteredFunction<FunctionSpec_> : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConfect> ? ConfectRegisteredFunction<FunctionSpec_> : never;
/**
 * Wrap a function's handler effect in its resolved middleware chain, per
 * invocation, after args decode. Iterated innermost-first so that the
 * first-attached (group-level, in attachment order) middleware ends up
 * outermost and runs first. Erased types: the public safety story lives at the
 * `MiddlewareSpec.MiddlewareImpl`/`MiddlewareImpl.make` signatures, and the
 * composed effect's error channel is re-accounted by
 * {@link combineErrorSchemas}.
 */
export declare const applyMiddleware: <A, E, R>(effect: Effect.Effect<A, E, R>, resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>, invocation: MiddlewareSpec.MiddlewareOptions["invocation"]) => Effect.Effect<A, any, R>;
/**
 * The error-schema allowlist for a function with middleware: the function's own
 * declared `error` schema unioned with every covering middleware's error
 * schema. `undefined` (⇒ every failure dies) only when neither declares
 * one—mirroring the ref-side union clients decode against.
 */
export declare const combineErrorSchemas: (error: Schema.Codec<any, any> | undefined, resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>) => Schema.Codec<any, any> | undefined;
/**
 * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of
 * failures that may be surfaced to the client as a `ConvexError`:
 *
 * - With a schema: typed errors are schema-encoded and wrapped in a
 *   `ConvexError`, then thrown so Convex surfaces the data to the client.
 *   `Effect.either` escapes the failure channel before `runPromise` so the
 *   thrown `ConvexError` retains its `Symbol.for("ConvexError")` identity
 *   instead of being wrapped in Effect's `FiberFailure`.
 * - Without a schema: every failure is converted to a defect via `Effect.orDie`,
 *   so nothing—not even a `ConvexError` the handler placed in its error
 *   channel—reaches the client as a `ConvexError`. The fiber dies and
 *   `runPromise` rejects with a generic failure.
 *
 * Either way, a `ConvexError` _defect_—thrown imperatively rather than placed
 * in the error channel, e.g. the pagination protocol's `InvalidCursor` signal
 * from `QueryStream.paginate`—is rethrown bare so it retains its identity and
 * Convex serializes its `data` to the client, matching how a thrown
 * `ConvexError` behaves in a plain Convex handler.
 *
 * A `scheduler` in `runOptions` must be passed here as a run option rather than
 * provided via `Effect.provideService` inside `effect`: the run option lands in
 * the fiber's root context, while a service provided within `effect` pops
 * before the `orDie`/`catch`/`result` wrappers this function adds. The fiber's
 * op counter survives context pops, so a cooperative yield can fire inside
 * those wrappers—only a root-context scheduler covers them.
 */
export declare const runHandlerPromise: (errorSchema: Schema.Codec<any, any> | undefined, runOptions?: {
    readonly scheduler?: EffectScheduler.Scheduler | undefined;
}) => <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
export declare const actionFunctionBase: <Schema extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E, R>({ name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, createLayer, }: {
    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, R>;
    resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
    createLayer: (ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>) => Layer.Layer<R>;
}) => {
    args: import("convex/values").PropertyValidators;
    returns: import("convex/values").Validator<any, any, any>;
    handler: (ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
};
export type ActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = Scheduler.Scheduler | Auth.Auth | ExecutionMetadata.ExecutionMetadata | RequestMetadata.RequestMetadata | Storage.Storage | StorageReader.StorageReader | StorageWriter.StorageWriter | StorageActionWriter.StorageActionWriter | QueryRunner.QueryRunner | MutationRunner.MutationRunner | ActionRunner.ActionRunner | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>> | ActionCtx.ActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>;
/**
 * The ctx-backed action services that don't depend on a Confect database
 * schema. {@link actionLayer} adds the schema-typed `VectorSearch` on top; the
 * HTTP API handler uses this base directly.
 */
export declare const baseActionLayer: <ConvexDataModel extends GenericDataModel>(ctx: GenericActionCtx<ConvexDataModel>) => Layer.Layer<Auth.Auth | ExecutionMetadata.ExecutionMetadata | GenericActionCtx<ConvexDataModel> | RequestMetadata.RequestMetadata | Storage.Storage | StorageActionWriter.StorageActionWriter | StorageReader.StorageReader | StorageWriter.StorageWriter | {
    runAction: <Action extends import("@confect/core/Ref").AnyAction>(action: Action, ...args: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | Schema.SchemaError>;
} | {
    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, import("./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: (import("./QueryTransactionContext").Options & {
            readonly useStaleSnapshot?: never;
        }) | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./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, import("./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, import("./QueryTransactionContext").QueryTransactionContext | import("./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: import("effect/Duration").Duration, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
    runAt: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(dateTime: import("effect/DateTime").DateTime, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
}, never, never>;
export declare const actionLayer: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => Layer.Layer<Auth.Auth | ExecutionMetadata.ExecutionMetadata | GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>> | RequestMetadata.RequestMetadata | Storage.Storage | StorageActionWriter.StorageActionWriter | StorageReader.StorageReader | StorageWriter.StorageWriter | VectorSearch.VectorSearchService<DataModel.FromSchema<DatabaseSchema_>> | {
    runAction: <Action extends import("@confect/core/Ref").AnyAction>(action: Action, ...args: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | Schema.SchemaError>;
} | {
    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, import("./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: (import("./QueryTransactionContext").Options & {
            readonly useStaleSnapshot?: never;
        }) | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./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, import("./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, import("./QueryTransactionContext").QueryTransactionContext | import("./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: import("effect/Duration").Duration, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
    runAt: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(dateTime: import("effect/DateTime").DateTime, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
}, never, never>;
export {};
//# sourceMappingURL=RegisteredFunction.d.ts.map