.opencode/node_modules/effect/dist/unstable/httpapi/HttpApiBuilder.d.ts

import * as Effect from "../../Effect.ts";
import type { FileSystem } from "../../FileSystem.ts";
import * as Layer from "../../Layer.ts";
import type { Path } from "../../Path.ts";
import { type Pipeable } from "../../Pipeable.ts";
import * as Redacted from "../../Redacted.ts";
import * as Scope from "../../Scope.ts";
import type { Covariant, NoInfer } from "../../Types.ts";
import type { Cookie } from "../http/Cookies.ts";
import type * as Etag from "../http/Etag.ts";
import type { HttpPlatform } from "../http/HttpPlatform.ts";
import * as HttpRouter from "../http/HttpRouter.ts";
import * as Request from "../http/HttpServerRequest.ts";
import { HttpServerRequest } from "../http/HttpServerRequest.ts";
import type { HttpServerResponse } from "../http/HttpServerResponse.ts";
import type * as HttpApi from "./HttpApi.ts";
import * as HttpApiEndpoint from "./HttpApiEndpoint.ts";
import type * as HttpApiGroup from "./HttpApiGroup.ts";
import type * as HttpApiSecurity from "./HttpApiSecurity.ts";
/**
 * Registers an `HttpApi` with a `HttpRouter`.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const layer: <Id extends string, Groups extends HttpApiGroup.Any>(api: HttpApi.HttpApi<Id, Groups>, options?: {
    readonly openapiPath?: `/${string}` | undefined;
}) => Layer.Layer<never, never, Etag.Generator | HttpRouter.HttpRouter | FileSystem | HttpPlatform | Path | HttpApiGroup.ToService<Id, Groups>>;
/**
 * Create a `Layer` that implements all endpoints in an `HttpApi` group.
 *
 * **Details**
 *
 * The `build` function receives an unimplemented `Handlers` instance that can
 * be used to add handlers to the group. Implement endpoints with
 * `handlers.handle`.
 *
 * @category handlers
 * @since 4.0.0
 */
export declare const group: <ApiId extends string, Groups extends HttpApiGroup.Any, const Name extends HttpApiGroup.Name<Groups>, Return>(api: HttpApi.HttpApi<ApiId, Groups>, groupName: Name, build: (handlers: Handlers.FromGroup<HttpApiGroup.WithName<Groups, Name>>) => Handlers.ValidateReturn<Return>) => Layer.Layer<HttpApiGroup.ApiGroup<ApiId, Name>, Handlers.Error<Return>, Exclude<Handlers.Context<Return>, Scope.Scope>>;
/**
 * Type identifier symbol used to brand `Handlers` values.
 *
 * @category type IDs
 * @since 4.0.0
 */
export declare const HandlersTypeId: unique symbol;
/**
 * Type of the `Handlers` type identifier symbol.
 *
 * @category type IDs
 * @since 4.0.0
 */
export type HandlersTypeId = typeof HandlersTypeId;
/**
 * Mutable handler collection for one `HttpApi` group.
 *
 * **Details**
 *
 * Each call to `handle` or `handleRaw` registers an endpoint implementation and
 * removes that endpoint from the type-level set of endpoints still requiring
 * handlers.
 *
 * @category handlers
 * @since 4.0.0
 */
export interface Handlers<R, Endpoints extends HttpApiEndpoint.Any = never> extends Pipeable {
    readonly [HandlersTypeId]: {
        _Endpoints: Covariant<Endpoints>;
    };
    readonly group: HttpApiGroup.AnyWithProps;
    readonly handlers: Map<string, Handlers.Item<R>>;
    /**
     * Add the implementation for an `HttpApiEndpoint` to a `Handlers` group.
     */
    handle<Name extends HttpApiEndpoint.Name<Endpoints>, R1>(name: Name, handler: HttpApiEndpoint.HandlerWithName<Endpoints, Name, HttpApiEndpoint.ErrorsWithName<Endpoints, Name>, R1>, options?: {
        readonly uninterruptible?: boolean | undefined;
    } | undefined): Handlers<R | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name> | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name> | (HttpApiEndpoint.ExcludeProvidedWithName<Endpoints, Name, R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>> extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never), HttpApiEndpoint.ExcludeName<Endpoints, Name>>;
    /**
     * Add the implementation for an `HttpApiEndpoint` to a `Handlers` group.
     * This version opts out of automatic payload decoding and provides the raw request.
     */
    handleRaw<Name extends HttpApiEndpoint.Name<Endpoints>, R1>(name: Name, handler: HttpApiEndpoint.HandlerRawWithName<Endpoints, Name, HttpApiEndpoint.ErrorsWithName<Endpoints, Name>, R1>, options?: {
        readonly uninterruptible?: boolean | undefined;
    } | undefined): Handlers<R | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name> | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name> | (HttpApiEndpoint.ExcludeProvidedWithName<Endpoints, Name, R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>> extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never), HttpApiEndpoint.ExcludeName<Endpoints, Name>>;
}
/**
 * Namespace containing helper types for `HttpApiBuilder` handler collections.
 *
 * @since 4.0.0
 */
export declare namespace Handlers {
    /**
     * A `Handlers` value with its context and endpoint types erased.
     *
     * @category handlers
     * @since 4.0.0
     */
    interface Any {
        readonly [HandlersTypeId]: any;
    }
    /**
     * Record stored for a registered endpoint handler.
     *
     * **Details**
     *
     * It keeps the endpoint metadata, handler function, whether raw request handling
     * is used, and whether the handler should run uninterruptibly.
     *
     * @category handlers
     * @since 4.0.0
     */
    type Item<R> = {
        readonly endpoint: HttpApiEndpoint.AnyWithProps;
        readonly handler: HttpApiEndpoint.Handler<any, any, R>;
        readonly isRaw: boolean;
        readonly uninterruptible: boolean;
    };
    /**
     * Creates a handler collection for a group where every endpoint in the group is
     * still awaiting an implementation.
     *
     * @category handlers
     * @since 4.0.0
     */
    type FromGroup<Group extends HttpApiGroup.Any> = Handlers<never, HttpApiGroup.Endpoints<Group>>;
    /**
     * Validates the return value of a group handler builder, preserving successful
     * handler collections and producing a descriptive type error when endpoints remain
     * unhandled.
     *
     * @category handlers
     * @since 4.0.0
     */
    type ValidateReturn<A> = A extends (Handlers<infer _R, infer _Endpoints> | Effect.Effect<Handlers<infer _R, infer _Endpoints>, infer _EX, infer _RX>) ? [_Endpoints] extends [never] ? A : `Endpoint not handled: ${HttpApiEndpoint.Name<_Endpoints>}` : `Must return the implemented handlers`;
    /**
     * Extracts the error channel from an effect that produces a `Handlers`
     * collection, returning `never` for non-effectful handler collections.
     *
     * @category handlers
     * @since 4.0.0
     */
    type Error<A> = A extends Effect.Effect<Handlers<infer _R, infer _Endpoints>, infer _EX, infer _RX> ? _EX : never;
    /**
     * Extracts the services required by a handler collection, including both handler
     * requirements and the environment required to construct the handlers.
     *
     * @category handlers
     * @since 4.0.0
     */
    type Context<A> = A extends Handlers<infer _R, infer _Endpoints> ? _R : A extends Effect.Effect<Handlers<infer _R, infer _Endpoints>, infer _EX, infer _RX> ? _R | _RX : never;
}
/**
 * Builds the server-side HTTP effect for a single endpoint in an API group using
 * the endpoint metadata, middleware, codecs, and supplied handler.
 *
 * @category handlers
 * @since 4.0.0
 */
export declare const endpoint: <ApiId extends string, Groups extends HttpApiGroup.Any, const GroupName extends HttpApiGroup.Name<Groups>, const EndpointName extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>>, R, Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>, Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<Group>, EndpointName>>(api: HttpApi.HttpApi<ApiId, Groups>, groupName: GroupName, endpointName: EndpointName, handler: NoInfer<HttpApiEndpoint.HandlerWithName<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>, EndpointName, never, R>>) => Effect.Effect<Effect.Effect<HttpServerResponse, never, HttpServerRequest | HttpRouter.RouteContext | Request.ParsedSearchParams | Exclude<R, HttpApiEndpoint.MiddlewareProvides<Endpoint>>>, never, HttpApiEndpoint.ServerServices<Endpoint> | HttpApiEndpoint.Middleware<Endpoint> | HttpApiEndpoint.MiddlewareServices<Endpoint> | Etag.Generator | FileSystem | HttpPlatform | Path>;
/**
 * Decodes credentials for an HTTP API security scheme from the current request,
 * supporting bearer, API key, and basic authentication inputs.
 *
 * @category security
 * @since 4.0.0
 */
export declare const securityDecode: <Security extends HttpApiSecurity.HttpApiSecurity>(self: Security) => Effect.Effect<HttpApiSecurity.HttpApiSecurity.Type<Security>, never, HttpServerRequest | Request.ParsedSearchParams>;
/**
 * Registers a pre-response handler that sets an API-key cookie on the outgoing
 * response, defaulting the cookie to `secure` and `httpOnly` unless overridden.
 *
 * @category security
 * @since 4.0.0
 */
export declare const securitySetCookie: (self: HttpApiSecurity.ApiKey, value: string | Redacted.Redacted, options?: Cookie["options"]) => Effect.Effect<void, never, HttpServerRequest>;
//# sourceMappingURL=HttpApiBuilder.d.ts.map