import type { FunctionType, FunctionVisibility, RegisteredAction, RegisteredMutation, RegisteredQuery } from "convex/server";
import type { Schema } from "effect";
import * as FunctionProvenance from "./FunctionProvenance";
import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
export declare const TypeId = "@confect/core/FunctionSpec";
export type TypeId = typeof TypeId;
export declare const isFunctionSpec: (u: unknown) => u is AnyWithProps;
export interface FunctionSpec<RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility_ extends FunctionVisibility, Name_ extends string, FunctionProvenance_ extends FunctionProvenance.FunctionProvenance> {
    readonly [TypeId]: TypeId;
    readonly runtimeAndFunctionType: RuntimeAndFunctionType_;
    readonly functionVisibility: FunctionVisibility_;
    readonly name: Name_;
    readonly functionProvenance: FunctionProvenance_;
}
export interface Any {
    readonly [TypeId]: TypeId;
}
export interface AnyWithProps extends FunctionSpec<RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility, string, FunctionProvenance.FunctionProvenance> {
}
export interface AnyConfect extends FunctionSpec<RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility, string, FunctionProvenance.AnyConfect> {
}
export interface AnyConvex extends FunctionSpec<RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility, string, FunctionProvenance.AnyConvex> {
}
export interface AnyWithPropsWithRuntime<Runtime extends RuntimeAndFunctionType.Runtime> extends FunctionSpec<RuntimeAndFunctionType.WithRuntime<Runtime>, FunctionVisibility, string, FunctionProvenance.FunctionProvenance> {
}
export interface AnyWithPropsWithFunctionType<RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType> extends FunctionSpec<RuntimeAndFunctionType_, FunctionVisibility, string, FunctionProvenance.FunctionProvenance> {
}
export interface AnyWithPropsWithFunctionProvenance<FunctionProvenance_ extends FunctionProvenance.FunctionProvenance> extends FunctionSpec<RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility, string, FunctionProvenance_> {
}
export type GetRuntimeAndFunctionType<FunctionSpec_ extends AnyWithProps> = FunctionSpec_["runtimeAndFunctionType"];
export type GetFunctionVisibility<FunctionSpec_ extends AnyWithProps> = FunctionSpec_["functionVisibility"];
export type Name<FunctionSpec_ extends AnyWithProps> = FunctionSpec_["name"];
export type Args<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Confect";
        args: infer ArgsSchema_ extends Schema.Schema.AnyNoContext;
    };
} ? ArgsSchema_["Type"] : FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Convex";
        _args: infer Args_;
    };
} ? Args_ : never;
export type Returns<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Confect";
        returns: infer ReturnsSchema_ extends Schema.Schema.AnyNoContext;
    };
} ? ReturnsSchema_["Type"] : FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Convex";
        _returns: infer Returns_;
    };
} ? Awaited<Returns_> : never;
export type EncodedArgs<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Confect";
        args: infer ArgsSchema_ extends Schema.Schema.AnyNoContext;
    };
} ? ArgsSchema_["Encoded"] : FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Convex";
        _args: infer Args_;
    };
} ? Args_ : never;
export type EncodedReturns<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Confect";
        returns: infer ReturnsSchema_ extends Schema.Schema.AnyNoContext;
    };
} ? ReturnsSchema_["Encoded"] : FunctionSpec_ extends {
    functionProvenance: {
        _tag: "Convex";
        _returns: infer Returns_;
    };
} ? Returns_ : never;
export type Error<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
    functionProvenance: FunctionProvenance.Confect<any, any, infer ErrorSchema_ extends Schema.Schema.AnyNoContext>;
} ? ErrorSchema_["Type"] : never;
export type EncodedError<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
    functionProvenance: FunctionProvenance.Confect<any, any, infer ErrorSchema_ extends Schema.Schema.AnyNoContext>;
} ? ErrorSchema_["Encoded"] : never;
export type WithName<FunctionSpec_ extends AnyWithProps, Name_ extends string> = Extract<FunctionSpec_, {
    readonly name: Name_;
}>;
export type WithRuntimeAndFunctionType<FunctionSpec_ extends AnyWithProps, RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType> = Extract<FunctionSpec_, {
    readonly runtimeAndFunctionType: RuntimeAndFunctionType_;
}>;
export type WithFunctionType<FunctionSpec_ extends AnyWithProps, FunctionType_ extends FunctionType> = Extract<FunctionSpec_, {
    readonly runtimeAndFunctionType: {
        readonly functionType: FunctionType_;
    };
}>;
export type WithFunctionProvenance<FunctionSpec_ extends AnyWithProps, FunctionProvenance_ extends FunctionProvenance.FunctionProvenance> = Extract<FunctionSpec_, {
    readonly functionProvenance: FunctionProvenance_;
}>;
export type WithoutName<FunctionSpec_ extends AnyWithProps, Name_ extends Name<FunctionSpec_>> = Exclude<FunctionSpec_, {
    readonly name: Name_;
}>;
export declare const publicQuery: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "query";
}, "public", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
export declare const internalQuery: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "query";
}, "internal", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
export declare const publicMutation: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "mutation";
}, "public", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
export declare const internalMutation: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "mutation";
}, "internal", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
export declare const publicAction: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "action";
}, "public", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
export declare const internalAction: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "action";
}, "internal", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
export declare const publicNodeAction: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Node";
    readonly functionType: "action";
}, "public", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
export declare const internalNodeAction: <const Name_ extends string, Args_ extends Schema.Schema.AnyNoContext, Returns_ extends Schema.Schema.AnyNoContext, Error_ extends Schema.Schema.AnyNoContext = never>({ name, args, returns, error, }: {
    name: Name_;
    args: () => Args_;
    returns: () => Returns_;
    error?: () => Error_;
}) => FunctionSpec<{
    readonly runtime: "Node";
    readonly functionType: "action";
}, "internal", Name_, FunctionProvenance.Confect<Args_, Returns_, Error_>>;
type ExtractArgs<F> = F extends RegisteredQuery<any, infer A, any> ? A : F extends RegisteredMutation<any, infer A, any> ? A : F extends RegisteredAction<any, infer A, any> ? A : never;
type ExtractReturns<F> = F extends RegisteredQuery<any, any, infer R> ? R : F extends RegisteredMutation<any, any, infer R> ? R : F extends RegisteredAction<any, any, infer R> ? R : never;
export declare const convexPublicQuery: <F extends RegisteredQuery<"public", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "query";
}, "public", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export declare const convexInternalQuery: <F extends RegisteredQuery<"internal", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "query";
}, "internal", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export declare const convexPublicMutation: <F extends RegisteredMutation<"public", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "mutation";
}, "public", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export declare const convexInternalMutation: <F extends RegisteredMutation<"internal", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "mutation";
}, "internal", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export declare const convexPublicAction: <F extends RegisteredAction<"public", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "action";
}, "public", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export declare const convexInternalAction: <F extends RegisteredAction<"internal", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Convex";
    readonly functionType: "action";
}, "internal", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export declare const convexPublicNodeAction: <F extends RegisteredAction<"public", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Node";
    readonly functionType: "action";
}, "public", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export declare const convexInternalNodeAction: <F extends RegisteredAction<"internal", any, any>>() => <const Name_ extends string>(name: Name_) => FunctionSpec<{
    readonly runtime: "Node";
    readonly functionType: "action";
}, "internal", Name_, FunctionProvenance.Convex<ExtractArgs<F>, ExtractReturns<F>>>;
export {};
//# sourceMappingURL=FunctionSpec.d.ts.map