@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/http/extension.d.ts

@@ -0,0 +1,348 @@
+import { type ExecutionDefinition, type ExecutionExtension, type ExecutionExtensionDrainContext, type GenericLayer, type RuntimeCapabilityBinding, type SchemaInput, type SchemaOutput, type StandardSchemaV1, type SourceLocation, type Type } from '../core/index.js';
+import { type HttpPathSegment, type PathParamNames } from './path.js';
+export interface HttpServerDriver {
+    readonly runtime: string;
+}
+export declare const HTTP_SERVER: import("../core/extension.js").RuntimeCapability<HttpServerDriver>;
+export interface HttpExecutionRequestDefinition {
+    readonly params?: Readonly<Record<string, StandardSchemaV1>>;
+    readonly query?: StandardSchemaV1;
+    readonly headers?: StandardSchemaV1;
+    readonly body?: StandardSchemaV1;
+}
+export type HttpHeaderValue = string | readonly string[];
+export type HttpHeaders = Readonly<Record<string, HttpHeaderValue | undefined>>;
+export interface HttpErrorMatcher<TError extends {
+    readonly data: unknown;
+}> {
+    is(error: unknown): error is TError;
+}
+export interface HttpErrorMapping<TError extends {
+    readonly data: unknown;
+} = {
+    readonly data: unknown;
+}, TResult = unknown> {
+    readonly kind: 'http-error-mapping';
+    readonly definition: HttpErrorMatcher<TError>;
+    readonly map: (error: TError) => TResult | Promise<TResult>;
+}
+export interface HttpResponseHeadersWithDefaults<TSchema extends StandardSchemaV1 = StandardSchemaV1> {
+    readonly schema: TSchema;
+    readonly defaults: HttpHeaders;
+}
+export type HttpResponseHeadersDefinition = StandardSchemaV1 | HttpHeaders | HttpResponseHeadersWithDefaults;
+export interface HttpExecutionResponseDefinition {
+    readonly status: number;
+    readonly description?: string;
+    readonly body?: StandardSchemaV1;
+    readonly headers?: HttpResponseHeadersDefinition;
+    readonly error?: HttpErrorMapping<any, any>;
+    readonly stream?: 'server';
+}
+export type HttpValidationPart = 'body';
+export interface HttpValidationMiddleware<TPart extends HttpValidationPart = HttpValidationPart> {
+    readonly kind: 'http-validation';
+    readonly part: TPart;
+}
+export interface HttpExecutionRouteDefinition {
+    readonly method: string;
+    readonly path: string;
+    readonly summary?: string;
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    readonly deprecated?: boolean;
+    readonly request?: HttpExecutionRequestDefinition;
+    readonly responses: Readonly<Record<string, HttpExecutionResponseDefinition>>;
+    readonly middlewares?: readonly HttpRouteMiddleware[];
+    readonly interaction?: 'unary' | 'server-stream';
+}
+type AnyHttpMiddleware = GenericLayer<any, any, HttpExecutionResult>;
+type HttpRouteMiddleware = AnyHttpMiddleware | HttpValidationMiddleware;
+export interface HttpContractBranchDefinition {
+    readonly path?: string;
+    readonly responses?: Readonly<Record<string, HttpExecutionResponseDefinition>>;
+    readonly middlewares?: readonly AnyHttpMiddleware[];
+    readonly routes: HttpContractRouteTree;
+}
+export type HttpContractNodeDefinition = HttpExecutionRouteDefinition | HttpContractBranchDefinition;
+export type HttpContractRouteTree = Readonly<Record<string, HttpContractNodeDefinition>>;
+declare const httpMiddlewareShortCircuit: unique symbol;
+export type HttpMiddleware<TContribution extends object = object, TContext extends object = HttpMiddlewareContext, TShortCircuit extends HttpExecutionResult = never> = GenericLayer<TContext, TContribution, HttpExecutionResult> & {
+    readonly [httpMiddlewareShortCircuit]?: TShortCircuit;
+};
+export interface HttpMiddlewareContext {
+    readonly request: Request;
+    readonly input: {
+        readonly params: Readonly<Record<string, unknown>>;
+        readonly query: unknown;
+        readonly headers: unknown;
+        readonly body: unknown;
+    };
+    readonly signal: AbortSignal;
+}
+type MiddlewareContribution<TMiddleware> = TMiddleware extends GenericLayer<any, infer TContribution, any> ? TContribution : {};
+type UnionToIntersection<TUnion> = (TUnion extends unknown ? (value: TUnion) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type JoinHttpPath<TPrefix extends string, TPath extends string> = TPrefix extends '' ? TPath : TPrefix extends '/' ? TPath : TPath extends '/' ? TPrefix : `${TPrefix}${TPath}`;
+type BranchPath<TBranch extends HttpContractBranchDefinition> = TBranch extends {
+    readonly path: infer TPath extends string;
+} ? TPath : '';
+type BranchResponses<TBranch extends HttpContractBranchDefinition> = TBranch extends {
+    readonly responses: infer TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>;
+} ? TResponses : {};
+type BranchMiddlewares<TBranch extends HttpContractBranchDefinition> = TBranch extends {
+    readonly middlewares: infer TMiddlewares extends readonly AnyHttpMiddleware[];
+} ? TMiddlewares : readonly [];
+type ResolveHttpRoute<TRoute extends HttpExecutionRouteDefinition, TPathPrefix extends string, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TMiddlewares extends readonly HttpRouteMiddleware[]> = Omit<TRoute, 'path' | 'responses' | 'middlewares'> & {
+    readonly path: JoinHttpPath<TPathPrefix, TRoute['path']>;
+    readonly responses: TResponses & TRoute['responses'];
+} & (readonly [
+    ...TMiddlewares,
+    ...(TRoute extends {
+        readonly middlewares: infer TRouteMiddlewares extends readonly HttpRouteMiddleware[];
+    } ? TRouteMiddlewares : readonly [])
+] extends readonly [] ? {} : {
+    readonly middlewares: readonly [
+        ...TMiddlewares,
+        ...(TRoute extends {
+            readonly middlewares: infer TRouteMiddlewares extends readonly HttpRouteMiddleware[];
+        } ? TRouteMiddlewares : readonly [])
+    ];
+});
+type ResolveHttpNode<TName extends string, TNode extends HttpContractNodeDefinition, TPathPrefix extends string, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TMiddlewares extends readonly HttpRouteMiddleware[]> = TNode extends HttpExecutionRouteDefinition ? Readonly<Record<TName, ResolveHttpRoute<TNode, TPathPrefix, TResponses, TMiddlewares>>> : TNode extends HttpContractBranchDefinition ? ResolveHttpRouteTree<TNode['routes'], JoinHttpPath<TPathPrefix, BranchPath<TNode>>, TResponses & BranchResponses<TNode>, readonly [...TMiddlewares, ...BranchMiddlewares<TNode>]> : never;
+type ResolveHttpRouteTree<TTree extends HttpContractRouteTree, TPathPrefix extends string = '', TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>> = {}, TMiddlewares extends readonly HttpRouteMiddleware[] = readonly []> = UnionToIntersection<{
+    [TName in keyof TTree & string]: ResolveHttpNode<TName, TTree[TName], TPathPrefix, TResponses, TMiddlewares>;
+}[keyof TTree & string]>;
+export type ResolvedHttpContractRoutes<TTree extends HttpContractRouteTree> = ResolveHttpRouteTree<TTree> extends infer TRoutes ? {
+    readonly [TName in keyof TRoutes]: Extract<TRoutes[TName], HttpExecutionRouteDefinition>;
+} : never;
+type HasResponseNameCollision<TLeft extends Readonly<Record<string, HttpExecutionResponseDefinition>>, TRight extends Readonly<Record<string, HttpExecutionResponseDefinition>>> = Extract<keyof TLeft, keyof TRight> extends never ? false : true;
+type IsHttpContractNodeInheritanceValid<TNode extends HttpContractNodeDefinition, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>>> = TNode extends HttpExecutionRouteDefinition ? HasResponseNameCollision<TResponses, TNode['responses']> extends true ? false : true : TNode extends HttpContractBranchDefinition ? HasResponseNameCollision<TResponses, BranchResponses<TNode>> extends true ? false : IsHttpContractTreeInheritanceValid<TNode['routes'], TResponses & BranchResponses<TNode>> : false;
+type IsHttpContractTreeInheritanceValid<TTree extends HttpContractRouteTree, TResponses extends Readonly<Record<string, HttpExecutionResponseDefinition>> = {}> = string extends keyof TTree ? true : false extends {
+    [TName in keyof TTree]: IsHttpContractNodeInheritanceValid<TTree[TName], TResponses>;
+}[keyof TTree] ? false : true;
+type HttpMiddlewareState<TRoute extends HttpExecutionRouteDefinition> = TRoute extends {
+    readonly middlewares: infer TMiddlewares extends readonly HttpRouteMiddleware[];
+} ? UnionToIntersection<MiddlewareContribution<TMiddlewares[number]>> : {};
+export interface HttpContract<TRoutes extends Readonly<Record<string, HttpExecutionRouteDefinition>> = Readonly<Record<string, HttpExecutionRouteDefinition>>> {
+    readonly kind: 'http-contract';
+    readonly routes: TRoutes;
+}
+type RequestValue<TRequest extends HttpExecutionRequestDefinition | undefined, TPart extends keyof HttpExecutionRequestDefinition, TFallback> = TRequest extends HttpExecutionRequestDefinition ? TRequest[TPart] extends StandardSchemaV1 ? SchemaOutput<TRequest[TPart]> : TFallback : TFallback;
+type RawHttpQuery = Readonly<Record<string, string | readonly string[] | undefined>>;
+type RawHttpRequestHeaders = Readonly<Record<string, string | undefined>>;
+type HttpParamsValue<TRequest extends HttpExecutionRequestDefinition | undefined> = TRequest extends {
+    readonly params: infer TParams;
+} ? TParams extends Readonly<Record<string, StandardSchemaV1>> ? {
+    readonly [K in keyof TParams]: SchemaOutput<TParams[K]>;
+} : Readonly<Record<string, string>> : Readonly<Record<string, string>>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type IsUnknown<T> = unknown extends T ? [keyof T] extends [never] ? true : false : false;
+type ResponseHeadersSchema<TResponse> = TResponse extends {
+    readonly headers: infer THeaders;
+} ? THeaders extends StandardSchemaV1 ? THeaders : THeaders extends {
+    readonly schema: infer TSchema extends StandardSchemaV1;
+} ? TSchema : never : never;
+type ResponseHeadersOutput<TResponse> = ResponseHeadersSchema<TResponse> extends infer TSchema ? [TSchema] extends [never] ? never : TSchema extends StandardSchemaV1 ? SchemaOutput<TSchema> : never : never;
+type HttpResultHeaders<THeaders> = IsAny<THeaders> extends true ? {
+    readonly headers?: HttpHeaders;
+} : IsUnknown<THeaders> extends true ? {
+    readonly headers?: HttpHeaders;
+} : [THeaders] extends [never] ? {
+    readonly headers?: never;
+} : undefined extends THeaders ? {
+    readonly headers?: Exclude<THeaders, undefined>;
+} : {
+    readonly headers: THeaders;
+};
+export type HttpExecutionResult<TVariant extends string = string, TBody = unknown, THeaders = unknown> = {
+    readonly kind: 'http-result';
+    readonly response: TVariant;
+    readonly body: TBody;
+} & HttpResultHeaders<THeaders>;
+export type HttpResponseResult<TBody, THeaders = unknown> = {
+    readonly body: TBody;
+} & HttpResultHeaders<THeaders>;
+type ResponseBodyOutput<TResponse extends HttpExecutionResponseDefinition> = TResponse extends {
+    readonly stream: 'server';
+    readonly body: infer TBody extends StandardSchemaV1;
+} ? AsyncIterable<SchemaOutput<TBody>> : TResponse['body'] extends StandardSchemaV1 ? SchemaOutput<TResponse['body']> : undefined;
+type ResponseValue<TResponse extends HttpExecutionResponseDefinition> = (TResponse['body'] extends StandardSchemaV1 ? {
+    readonly body: ResponseBodyOutput<TResponse>;
+} : {
+    readonly body?: undefined;
+}) & HttpResultHeaders<ResponseHeadersOutput<TResponse>>;
+type DeclaredHttpResponseResult<TVariant extends string, TResponse extends HttpExecutionResponseDefinition> = HttpExecutionResult<TVariant, ResponseBodyOutput<TResponse>, ResponseHeadersOutput<TResponse>>;
+type DeclaredHttpResult<TRoute extends HttpExecutionRouteDefinition, TVariant extends keyof TRoute['responses'] & string> = DeclaredHttpResponseResult<TVariant, TRoute['responses'][TVariant]>;
+type DeclaredHttpResults<TRoute extends HttpExecutionRouteDefinition> = {
+    [TVariant in keyof TRoute['responses'] & string]: DeclaredHttpResult<TRoute, TVariant>;
+}[keyof TRoute['responses'] & string];
+type ResponseHelpers<TResponses extends HttpExecutionRouteDefinition['responses']> = {
+    readonly [TVariant in keyof TResponses]: TVariant extends string ? TResponses[TVariant] extends infer TResponse extends HttpExecutionResponseDefinition ? (value: ResponseValue<TResponse>) => DeclaredHttpResponseResult<TVariant, TResponse> : never : never;
+};
+export type HttpExecutionContext<TRoute extends HttpExecutionRouteDefinition = HttpExecutionRouteDefinition> = {
+    readonly input: {
+        readonly params: HttpParamsValue<TRoute['request']>;
+        readonly query: RequestValue<TRoute['request'], 'query', RawHttpQuery>;
+        readonly headers: RequestValue<TRoute['request'], 'headers', RawHttpRequestHeaders>;
+        readonly body: RequestValue<TRoute['request'], 'body', undefined>;
+    };
+    readonly response: ResponseHelpers<TRoute['responses']>;
+    readonly signal: AbortSignal;
+    readonly state: Readonly<HttpMiddlewareState<TRoute>>;
+};
+export type HttpHandlers<TContract extends HttpContract> = {
+    readonly [TName in keyof TContract['routes']]: (context: HttpExecutionContext<TContract['routes'][TName]>) => DeclaredHttpResults<TContract['routes'][TName]> | Promise<DeclaredHttpResults<TContract['routes'][TName]>>;
+};
+export interface HttpImplementationDefinition<TContract extends HttpContract = HttpContract> {
+    readonly name: string;
+    readonly contract: TContract;
+    readonly factory: () => HttpHandlers<TContract>;
+}
+interface CompiledHttpRoute {
+    readonly name: string;
+    readonly method: string;
+    readonly path: string;
+    readonly segments: readonly HttpPathSegment[];
+    readonly dispatch: string;
+    readonly definition: HttpExecutionRouteDefinition;
+    readonly middlewares: readonly AnyHttpMiddleware[];
+    readonly source?: SourceLocation;
+}
+interface CompiledHttpExecution {
+    readonly routes: readonly CompiledHttpRoute[];
+    readonly factory: () => Record<string, (context: HttpExecutionContext) => HttpExecutionResult | Promise<HttpExecutionResult>>;
+}
+export interface HttpExtensionRuntime {
+    fetch(request: Request): Promise<Response>;
+    drain(context: ExecutionExtensionDrainContext): Promise<void>;
+}
+export interface HttpHostApi {
+    fetch(request: Request): Promise<Response>;
+}
+declare const httpExecutionExtensionIdentity: unique symbol;
+export declare const httpExecutionExtension: ExecutionExtension<HttpImplementationDefinition & ExecutionDefinition, CompiledHttpExecution, 'http', HttpHostApi, HttpExtensionRuntime> & {
+    readonly [httpExecutionExtensionIdentity]: true;
+};
+export type HttpExecutionDefinition<TContract extends HttpContract = HttpContract> = HttpImplementationDefinition<TContract> & ExecutionDefinition<typeof httpExecutionExtension>;
+type HttpStatusDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type HttpStatusHundreds = '2' | '3' | '4' | '5';
+type IsValidHttpResponseStatus<TStatus extends number> = number extends TStatus ? false : `${TStatus}` extends `${HttpStatusHundreds}${HttpStatusDigit}${HttpStatusDigit}` ? true : false;
+type IsBodylessHttpStatus<TStatus extends number> = TStatus extends 204 | 205 | 304 ? true : false;
+type IsResponseStatusCompatible<TResponse> = TResponse extends HttpExecutionResponseDefinition ? IsValidHttpResponseStatus<TResponse['status']> extends true ? IsBodylessHttpStatus<TResponse['status']> extends true ? TResponse extends {
+    readonly body: StandardSchemaV1;
+} | {
+    readonly stream: 'server';
+} ? false : true : TResponse extends {
+    readonly stream: 'server';
+} ? TResponse extends {
+    readonly body: StandardSchemaV1;
+} ? true : false : true : false : false;
+type AreResponseStatusesCompatible<TResponses extends HttpExecutionRouteDefinition['responses']> = false extends {
+    [TVariant in keyof TResponses]: IsResponseStatusCompatible<TResponses[TVariant]>;
+}[keyof TResponses] ? false : true;
+type IsResponseHeadersSchemaCompatible<TResponse> = ResponseHeadersSchema<TResponse> extends infer THeaders ? [THeaders] extends [never] ? true : THeaders extends StandardSchemaV1 ? SchemaOutput<THeaders> extends HttpHeaders | undefined ? true : false : true : true;
+type AreResponseHeadersSchemasCompatible<TResponses extends HttpExecutionRouteDefinition['responses']> = false extends {
+    [TVariant in keyof TResponses]: IsResponseHeadersSchemaCompatible<TResponses[TVariant]>;
+}[keyof TResponses] ? false : true;
+type ErrorMappingResult<TResponse> = TResponse extends {
+    readonly error: infer TMapping extends HttpErrorMapping<any, any>;
+} ? Awaited<ReturnType<TMapping['map']>> : never;
+type IsErrorMappingCompatible<TResponse> = TResponse extends HttpExecutionResponseDefinition ? TResponse extends {
+    readonly error: HttpErrorMapping<any, any>;
+} ? TResponse extends {
+    readonly body: StandardSchemaV1;
+} ? ErrorMappingResult<TResponse> extends HttpResponseResult<ResponseBodyOutput<TResponse>, ResponseHeadersOutput<TResponse>> ? true : false : false : true : false;
+type AreErrorMappingsCompatible<TResponses extends HttpExecutionRouteDefinition['responses']> = false extends {
+    [TVariant in keyof TResponses]: IsErrorMappingCompatible<TResponses[TVariant]>;
+}[keyof TResponses] ? false : true;
+type HasRequiredStringContentType<TValue> = [TValue] extends [
+    {
+        readonly 'content-type': string;
+    }
+] ? true : false;
+type IsExactParamsSchemaMap<TPath extends string, TSchemas extends Readonly<Record<string, StandardSchemaV1>>> = Exclude<keyof TSchemas, PathParamNames<TPath>> extends never ? Exclude<PathParamNames<TPath>, keyof TSchemas> extends never ? true : false : false;
+type IsRawStringCompatible<TInput> = string extends TInput ? true : [Extract<TInput, string>] extends [never] ? false : true;
+type DoParamsSchemasAcceptStrings<TSchemas extends Readonly<Record<string, StandardSchemaV1>>> = false extends {
+    [TName in keyof TSchemas]: IsRawStringCompatible<SchemaInput<TSchemas[TName]>>;
+}[keyof TSchemas] ? false : true;
+type MiddlewareShortCircuit<TMiddleware> = typeof httpMiddlewareShortCircuit extends keyof TMiddleware ? TMiddleware extends {
+    readonly [httpMiddlewareShortCircuit]?: infer TResult;
+} ? Exclude<TResult, undefined> : never : never;
+type RouteMiddlewareShortCircuits<TRoute extends HttpExecutionRouteDefinition> = TRoute extends {
+    readonly middlewares: infer TMiddlewares extends readonly HttpRouteMiddleware[];
+} ? MiddlewareShortCircuit<TMiddlewares[number]> : never;
+type AreMiddlewareShortCircuitsCompatible<TRoute extends HttpExecutionRouteDefinition> = [RouteMiddlewareShortCircuits<TRoute>] extends [never] ? true : Exclude<RouteMiddlewareShortCircuits<TRoute>, DeclaredHttpResults<TRoute>> extends never ? true : false;
+type HttpRouteConstraint<TRoute extends HttpExecutionRouteDefinition> = (AreResponseStatusesCompatible<TRoute['responses']> extends true ? AreResponseHeadersSchemasCompatible<TRoute['responses']> extends true ? AreErrorMappingsCompatible<TRoute['responses']> extends true ? unknown : {
+    readonly responses: never;
+} : {
+    readonly responses: never;
+} : {
+    readonly responses: never;
+}) & (TRoute['request'] extends {
+    readonly body: StandardSchemaV1;
+} ? TRoute['request'] extends {
+    readonly headers: infer THeaders extends StandardSchemaV1;
+} ? HasRequiredStringContentType<SchemaInput<THeaders>> extends true ? HasRequiredStringContentType<SchemaOutput<THeaders>> extends true ? unknown : {
+    readonly request: never;
+} : {
+    readonly request: never;
+} : {
+    readonly request: never;
+} : unknown) & (TRoute['request'] extends {
+    readonly params: infer TParams extends Readonly<Record<string, StandardSchemaV1>>;
+} ? IsExactParamsSchemaMap<TRoute['path'], TParams> extends true ? DoParamsSchemasAcceptStrings<TParams> extends true ? unknown : {
+    readonly request: never;
+} : {
+    readonly request: never;
+} : unknown) & (AreMiddlewareShortCircuitsCompatible<TRoute> extends true ? unknown : {
+    readonly middlewares: never;
+});
+type HttpContractConstraint<TRoutes extends Readonly<Record<string, HttpExecutionRouteDefinition>>> = {
+    readonly [TName in keyof TRoutes]: HttpRouteConstraint<TRoutes[TName]>;
+};
+type ErrorOf<TDefinition> = TDefinition extends HttpErrorMatcher<infer TError> ? TError : never;
+export declare function httpError<TDefinition extends HttpErrorMatcher<{
+    readonly data: unknown;
+}>>(definition: TDefinition): HttpErrorMapping<ErrorOf<TDefinition>, {
+    readonly body: ErrorOf<TDefinition>['data'];
+}>;
+export declare function httpError<TDefinition extends HttpErrorMatcher<{
+    readonly data: unknown;
+}>, const TResult>(definition: TDefinition, map: (error: ErrorOf<TDefinition>) => TResult | Promise<TResult>): HttpErrorMapping<ErrorOf<TDefinition>, TResult>;
+export declare function defineHttpContract<const TTree extends HttpContractRouteTree>(routes: TTree & (IsHttpContractTreeInheritanceValid<TTree> extends true ? unknown : never) & (ResolvedHttpContractRoutes<TTree> extends HttpContractConstraint<ResolvedHttpContractRoutes<TTree>> ? unknown : never)): HttpContract<ResolvedHttpContractRoutes<TTree>>;
+export declare function defineHttpImplementation<const TContract extends HttpContract>(definition: {
+    readonly name?: string;
+    readonly contract: TContract;
+    readonly factory: HttpImplementationDefinition<TContract>['factory'];
+}): HttpExecutionDefinition<TContract>;
+export declare function bindHttpServer(driver: HttpServerDriver): RuntimeCapabilityBinding<HttpServerDriver>;
+export declare function defineHttpMiddleware<TContribution extends object = {}>(definition: {
+    readonly name: string;
+    readonly state?: Type<TContribution>;
+    readonly factory: HttpMiddleware<NoInfer<TContribution>>['factory'];
+}): HttpMiddleware<TContribution>;
+export declare const validate: Readonly<{
+    body: Readonly<{
+        kind: 'http-validation';
+        part: 'body';
+    }>;
+}>;
+export declare const executionHttp: Readonly<{
+    contract: typeof defineHttpContract;
+    implementation: typeof defineHttpImplementation;
+    middleware: typeof defineHttpMiddleware;
+    validate: Readonly<{
+        body: Readonly<{
+            kind: 'http-validation';
+            part: 'body';
+        }>;
+    }>;
+    error: typeof httpError;
+    extension: ExecutionExtension<HttpImplementationDefinition<HttpContract<Readonly<Record<string, HttpExecutionRouteDefinition>>>> & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, CompiledHttpExecution, "http", HttpHostApi, HttpExtensionRuntime> & {
+        readonly [httpExecutionExtensionIdentity]: true;
+    };
+    serverCapability: import("../core/extension.js").RuntimeCapability<HttpServerDriver>;
+    bindServer: typeof bindHttpServer;
+}>;
+export declare function withHttpFrameworkHeaders(result: HttpExecutionResult, headers: HttpHeaders): HttpExecutionResult;
+export {};