import { type RequestContextInput } from '@modern-js/runtime-extensions/request-context';
import * as Effect from 'effect/Effect';
import { HttpClient } from 'effect/http';
import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from 'effect/http-api';
import * as Layer from 'effect/Layer';
import { Rpc, RpcClient, RpcClientError, RpcGroup, RpcSchema, RpcSerialization } from 'effect/rpc';
import { type EffectCrossProjectClientOptions } from './cross-project.js';
export * as Effect from 'effect/Effect';
export * as HttpClientError from 'effect/http/HttpClientError';
export * as Layer from 'effect/Layer';
export * as Schema from 'effect/Schema';
export type { EffectCrossProjectClientOptions } from './cross-project.js';
export { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, };
export type EffectHttpApiClientOptions = {
    crossProject?: EffectCrossProjectClientOptions;
    baseUrl?: URL | string;
    /** Headers for every request. A header the request already sets wins; undefined values are skipped. */
    headers?: Readonly<Record<string, string | undefined>>;
    /**
     * Locale, trace and operation context for every request. An
     * `operationContext` is sent as `x-operation-id` plus the
     * `x-modernjs-bff-operation-context` detail the Effect BFF server reads.
     */
    requestContext?: RequestContextInput;
    transformClient?: (client: HttpClient.HttpClient) => HttpClient.HttpClient;
    transformResponse?: ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>) | undefined;
};
type Nullish = null | undefined;
type NonNullish<T> = Exclude<T, Nullish>;
type PreserveNullish<T, Next> = Extract<T, Nullish> extends never ? Next : Next | Extract<T, Nullish>;
type EffectViewObjectSelection<T> = NonNullish<T> extends Record<string, unknown> ? EffectViewSelection<NonNullish<T>> : never;
type EffectViewSelectionValue<T> = NonNullish<T> extends readonly (infer Item)[] ? true | EffectViewObjectSelection<Item> : NonNullish<T> extends Record<string, unknown> ? true | EffectViewSelection<NonNullish<T>> : true;
type EffectMaskedValue<T, Selection> = Selection extends true ? T : NonNullish<T> extends readonly (infer Item)[] ? PreserveNullish<T, Array<EffectMaskedValue<Item, Selection>>> : NonNullish<T> extends Record<string, unknown> ? PreserveNullish<T, EffectViewData<NonNullish<T>, Selection>> : T;
export type EffectViewSelection<T> = {
    [K in keyof T]?: EffectViewSelectionValue<T[K]>;
};
export type EffectViewData<T, Selection> = Selection extends true ? T : Selection extends Record<string, unknown> ? {
    [K in keyof Selection & keyof T]: EffectMaskedValue<T[K], Selection[K]>;
} : T;
export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc';
declare const EffectRpcClientError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "EffectRpcClientError";
} & Readonly<A>;
export declare class EffectRpcClientError extends EffectRpcClientError_base<{
    readonly cause: unknown;
}> {
}
type EffectRpcMiddlewareLayerOption<Rpcs extends Rpc.Any> = [
    Rpc.MiddlewareClient<Rpcs>
] extends [never] ? {
    middlewareLayer?: Layer.Layer<Rpc.MiddlewareClient<Rpcs>, never, never>;
} : {
    middlewareLayer: Layer.Layer<Rpc.MiddlewareClient<Rpcs>, unknown, never>;
};
export type EffectRpcClientOptions<Rpcs extends Rpc.Any, Flatten extends boolean = false> = EffectRpcMiddlewareLayerOption<Rpcs> & {
    url: string;
    flatten?: Flatten;
    serialization?: EffectRpcSerialization;
};
export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean = false> = (Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs, RpcClientError.RpcClientError> : RpcClient.RpcClient<Rpcs, RpcClientError.RpcClientError>) & {
    dispose: () => Promise<void>;
};
export declare function view<T>(): <const Selection extends EffectViewSelection<T>>(selection: Selection) => Selection;
export declare function mask<T, const Selection extends EffectViewSelection<T>>(value: T, selection: Selection): EffectViewData<T, Selection>;
export declare function runEffectView<T, const Selection extends EffectViewSelection<T>>(request: PromiseLike<T>, selection: Selection): Promise<EffectViewData<T, Selection>>;
export declare function makeEffectHttpApiClient<ApiId extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<ApiId, Groups>, options?: EffectHttpApiClientOptions): Effect.Effect<HttpApiClient.Client<Groups, never, never>, never, HttpApiGroup.MiddlewareClient<Groups>>;
export declare function makeEffectRpcClient<Rpcs extends Rpc.Any, const Flatten extends boolean = false>(group: RpcGroup.RpcGroup<Rpcs>, options: EffectRpcClientOptions<Rpcs, Flatten>): Effect.Effect<EffectRpcClientHandle<Rpcs, Flatten>, EffectRpcClientError, never>;
export declare const runEffectRequest: <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions | undefined) => Promise<A>;