@krak-stack/registry 0.1.37 → 0.1.39

package/dist/lib/query.js

@@ -1,5 +1,12 @@
 // ../../src/lib/query.ts
-import { Effect, Schema, SchemaIssue, SchemaTransformation } from "effect";
+import {
+  Effect,
+  Option,
+  Schema,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaTransformation
+} from "effect";
 var parseSortParam = (sort) => {
   const id = sort.startsWith("-") ? sort.slice(1) : sort;
   if (!id || id.includes(",") || id.includes(":")) {
@@ -74,8 +81,14 @@ var SortParams = Schema.declare(Schema.is(SortParamsArray), {
   toCodecStringTree: () => Schema.link()(SortParamsFromString, SchemaTransformation.passthrough())
 });
 var Query = Schema.Struct({
-  page: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(0))),
-  pageSize: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })).pipe(Schema.withDecodingDefaultKey(Effect.succeed(10))),
+  page: Schema.optionalKey(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), {
+    decode: SchemaGetter.withDefault(Effect.succeed(0)),
+    encode: SchemaGetter.transformOptional(Option.filter((page) => page !== 0))
+  })),
+  pageSize: Schema.optionalKey(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 100 }))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })), {
+    decode: SchemaGetter.withDefault(Effect.succeed(20)),
+    encode: SchemaGetter.transformOptional(Option.filter((pageSize) => pageSize !== 20))
+  })),
   globalFilter: Schema.optional(Schema.String),
   sort: Schema.optional(SortParams)
 }).annotate({
@@ -85,7 +98,7 @@ var Query = Schema.Struct({
   examples: [
     {
       page: 0,
-      pageSize: 10,
+      pageSize: 20,
       globalFilter: "housing",
       sort: [
         { id: "publicName", direction: "desc" },
@@ -104,7 +117,7 @@ var PaginationMeta = Schema.Struct({
   identifier: "PaginationMeta",
   title: "Pagination Metadata",
   description: "Pagination metadata returned with a paginated list response.",
-  examples: [{ page: 0, pageSize: 10, total: 125, pageCount: 13 }]
+  examples: [{ page: 0, pageSize: 20, total: 125, pageCount: 7 }]
 }));
 var PaginatedResponse = (items) => Schema.Struct({
   data: Schema.Array(items),

package/dist/lib/webfetch-toolkit.d.ts

@@ -42,4 +42,4 @@ export declare const WebFetchToolkit: Toolkit.Toolkit<{
         readonly failureMode: "return";
     }, never>;
 }>;
-export declare const WebFetchToolkitLayer: (options?: Partial<WebFetchToolkitOptions>) => import("effect/Layer").Layer<Tool.Handler<"webFetch">, never, FileExtractionService | HttpClient.HttpClient>;
+export declare const WebFetchToolkitLayer: (options?: Partial<WebFetchToolkitOptions>) => import("effect/Layer").Layer<Tool.Handler<"webFetch">, Schema.SchemaError, FileExtractionService | HttpClient.HttpClient>;

package/dist/lib/webfetch-toolkit.js

@@ -127,7 +127,7 @@ var defaultWebFetchToolkitOptions = {
   maxResponseBytes: 2 * 1024 * 1024,
   maxContentCharacters: 30000
 };
-var decodeOptions = Schema2.decodeUnknownSync(WebFetchToolkitOptions);
+var decodeOptions = Schema2.decodeUnknownEffect(WebFetchToolkitOptions);
 var isPublicHttpsUrl = Schema2.makeFilter((value) => {
   try {
     const url = new URL(value);
@@ -213,60 +213,58 @@ var WebFetchTool = Tool.make("webFetch", {
   failureMode: "return"
 }).annotate(Tool.Title, "Read web page").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, true);
 var WebFetchToolkit = Toolkit.make(WebFetchTool);
-var WebFetchToolkitLayer = (options = {}) => {
-  const resolved = decodeOptions({
+var WebFetchToolkitLayer = (options = {}) => WebFetchToolkit.toLayer(Effect2.gen(function* () {
+  const resolved = yield* decodeOptions({
     ...defaultWebFetchToolkitOptions,
     ...options
   });
-  return WebFetchToolkit.toLayer(Effect2.gen(function* () {
-    const http = yield* HttpClient.HttpClient;
-    const extraction = yield* FileExtractionService;
-    return WebFetchToolkit.of({
-      webFetch: Effect2.fn("WebFetchToolkit.webFetch")(function* ({
-        url
-      }) {
-        const request = HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders({
-          accept: "text/markdown, text/plain;q=0.9, text/html;q=0.8, application/xhtml+xml;q=0.7, application/pdf;q=0.6, application/json;q=0.5",
-          "user-agent": "krak-stack-webfetch/1.0"
-        }));
-        const response = yield* HttpClient.filterStatusOk(http).execute(request).pipe(Effect2.mapError(() => failure("unavailable", "The web page could not be fetched")), Effect2.timeoutOrElse({
-          duration: "20 seconds",
-          orElse: () => Effect2.fail(failure("unavailable", "The web page request timed out"))
-        }));
-        const contentLength = response.headers["content-length"];
-        if (contentLength !== undefined) {
-          const decodedContentLength = decodeContentLength(contentLength);
-          if (Option.isNone(decodedContentLength) || decodedContentLength.value > resolved.maxResponseBytes) {
-            return yield* Effect2.fail(failure("too-large", "The web page exceeds the response size limit"));
-          }
-        }
-        const mediaType = response.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
-        const decodedMediaType = decodeMediaType(mediaType);
-        if (Option.isNone(decodedMediaType)) {
-          return yield* Effect2.fail(failure("unsupported-content", "The web page has an unsupported content type"));
-        }
-        const arrayBuffer = yield* response.arrayBuffer.pipe(Effect2.mapError(() => failure("invalid-response", "The web page body could not be read")));
-        if (arrayBuffer.byteLength > resolved.maxResponseBytes) {
+  const http = yield* HttpClient.HttpClient;
+  const extraction = yield* FileExtractionService;
+  return WebFetchToolkit.of({
+    webFetch: Effect2.fn("WebFetchToolkit.webFetch")(function* ({
+      url
+    }) {
+      const request = HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders({
+        accept: "text/markdown, text/plain;q=0.9, text/html;q=0.8, application/xhtml+xml;q=0.7, application/pdf;q=0.6, application/json;q=0.5",
+        "user-agent": "krak-stack-webfetch/1.0"
+      }));
+      const response = yield* HttpClient.filterStatusOk(http).execute(request).pipe(Effect2.mapError(() => failure("unavailable", "The web page could not be fetched")), Effect2.timeoutOrElse({
+        duration: "20 seconds",
+        orElse: () => Effect2.fail(failure("unavailable", "The web page request timed out"))
+      }));
+      const contentLength = response.headers["content-length"];
+      if (contentLength !== undefined) {
+        const decodedContentLength = decodeContentLength(contentLength);
+        if (Option.isNone(decodedContentLength) || decodedContentLength.value > resolved.maxResponseBytes) {
           return yield* Effect2.fail(failure("too-large", "The web page exceeds the response size limit"));
         }
-        const parsedUrl = new URL(url);
-        const filename = parsedUrl.pathname.split("/").at(-1) || "page.html";
-        const extracted = yield* extraction.markdown({
-          bytes: new Uint8Array(arrayBuffer),
-          filename,
-          mimeType: decodedMediaType.value
-        }).pipe(Effect2.mapError(() => failure("invalid-response", "The web page did not contain readable content")));
-        const bounded = truncateContent(extracted.content, resolved.maxContentCharacters);
-        return {
-          url,
-          contentType: decodedMediaType.value,
-          content: bounded.content,
-          truncated: extracted.truncated || bounded.truncated
-        };
-      })
-    });
-  }));
-};
+      }
+      const mediaType = response.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+      const decodedMediaType = decodeMediaType(mediaType);
+      if (Option.isNone(decodedMediaType)) {
+        return yield* Effect2.fail(failure("unsupported-content", "The web page has an unsupported content type"));
+      }
+      const arrayBuffer = yield* response.arrayBuffer.pipe(Effect2.mapError(() => failure("invalid-response", "The web page body could not be read")));
+      if (arrayBuffer.byteLength > resolved.maxResponseBytes) {
+        return yield* Effect2.fail(failure("too-large", "The web page exceeds the response size limit"));
+      }
+      const parsedUrl = new URL(url);
+      const filename = parsedUrl.pathname.split("/").at(-1) || "page.html";
+      const extracted = yield* extraction.markdown({
+        bytes: new Uint8Array(arrayBuffer),
+        filename,
+        mimeType: decodedMediaType.value
+      }).pipe(Effect2.mapError(() => failure("invalid-response", "The web page did not contain readable content")));
+      const bounded = truncateContent(extracted.content, resolved.maxContentCharacters);
+      return {
+        url,
+        contentType: decodedMediaType.value,
+        content: bounded.content,
+        truncated: extracted.truncated || bounded.truncated
+      };
+    })
+  });
+}));
 export {
   WebFetchFailure,
   WebFetchRequest,

package/dist/oxlint/anti-slop/index.js

@@ -349,8 +349,8 @@ function classifyWideningTarget(type, environment) {
   if (alias === undefined)
     return null;
   if ((alias.typeParameters?.params.length ?? 0) > 0) {
-    const substitutions2 = aliasSubstitution(alias, unwrapped, new Map);
-    return substitutions2 !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions2, new Set([name])) ? { kind: "generic container" } : null;
+    const substitutions = aliasSubstitution(alias, unwrapped, new Map);
+    return substitutions !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions, new Set([name])) ? { kind: "generic container" } : null;
   }
   const substitutions = aliasSubstitution(alias, unwrapped, new Map);
   if (substitutions === null)

package/dist/services/agent/client/index.js

@@ -227,7 +227,7 @@ function CopyButton({
   valueDescription,
   copyVariant = "default",
   locale: localeOverride,
-  messages: messages2,
+  messages,
   onCopied,
   onCopyError,
   resetDelay = 1500,
@@ -239,7 +239,7 @@ function CopyButton({
   const locale = useKrakstackLocale(localeOverride);
   const [copyState, setCopyState] = useState("idle");
   const copyTimeout = useRef(undefined);
-  const labels = copyButtonMessages(locale, messages2);
+  const labels = copyButtonMessages(locale, messages);
   const accessibleLabel = ariaLabel ?? (valueDescription ? `${labels.copy} ${valueDescription}` : labels.copy);
   const isLarge = copyVariant === "large";
   const defaultSize = copyVariant === "sm" ? "icon-xs" : isLarge ? "sm" : "icon-sm";
@@ -341,12 +341,12 @@ function CodeBlock({
   code,
   language = "text",
   locale: localeOverride,
-  messages: messages3
+  messages
 }) {
   const locale = useKrakstackLocale2(localeOverride);
   const normalizedLanguage = language.toLowerCase() || "text";
   const highlighted = highlight(code, { lang: normalizedLanguage });
-  const labels = codeBlockMessages(locale, messages3);
+  const labels = codeBlockMessages(locale, messages);
   return /* @__PURE__ */ jsxs2("div", {
     className: "not-prose bg-muted overflow-hidden rounded-md border text-[var(--th-token)]",
     "data-code-theme": true,
@@ -385,7 +385,7 @@ var MarkdownContent = ({
   codeBlocks,
   html,
   locale,
-  messages: messages3
+  messages
 }) => {
   const content = [];
   let remainingHtml = html;
@@ -404,7 +404,7 @@ var MarkdownContent = ({
         code: block.code,
         language: block.language,
         locale,
-        messages: messages3
+        messages
       })
     }, `code-${index}`));
     remainingHtml = remainingHtml.slice(markerIndex + marker.length);

package/dist/services/agent/index.js

@@ -43,7 +43,7 @@ var compileMarkdown = (source) => {
       codeBlocks.push({ code, language });
       return `<markdown-code-block data-index="${index}"></markdown-code-block>`;
     },
-    codespan: (children) => `<code data-inline-code>${escapeHtml(children)}</code>`,
+    codespan: (children) => `<code data-inline-code>${children}</code>`,
     emphasis: (children) => `<em>${children}</em>`,
     heading: (children, { id, level }) => {
       const headingId = escapeHtml(id ?? "");
@@ -282,8 +282,8 @@ class AgentService extends Context.Service()("AgentService", {
         }));
       });
       const complete = Stream.fromEffect(Effect.gen(function* () {
-        const history2 = yield* conversation.exportJson;
-        return { type: "history", value: history2 };
+        const history = yield* conversation.exportJson;
+        return { type: "history", value: history };
       })).pipe(Stream.concat(Stream.succeed({ type: "finish" })));
       const response = Stream.concat(renderedRounds, complete).pipe(Stream.provideService(LanguageModel.LanguageModel, model), Stream.catch((error) => Stream.fromEffect(Effect.logError("Agent stream failed", streamErrorDetails(error))).pipe(Stream.drain, Stream.concat(Stream.make({
         type: "error",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krak-stack/registry",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "Tree-shakable KrakStack components and Effect services.",
   "license": "MIT",
   "repository": {
@@ -29,7 +29,7 @@
       "types": "./dist/services/agent/schema.d.ts",
       "import": "./dist/services/agent/schema.js"
     },
-    "./httpapi-toolkit": {
+    "./httpapi/toolkit": {
       "types": "./dist/lib/httpapi-toolkit.d.ts",
       "import": "./dist/lib/httpapi-toolkit.js"
     },
@@ -37,17 +37,9 @@
       "types": "./dist/lib/httpapi-cli.d.ts",
       "import": "./dist/lib/httpapi-cli.js"
     },
-    "./httpapi/client": {
-      "types": "./dist/lib/httpapi-client.d.ts",
-      "import": "./dist/lib/httpapi-client.js"
-    },
-    "./httpapi/helpers": {
-      "types": "./dist/lib/httpapi-helpers.d.ts",
-      "import": "./dist/lib/httpapi-helpers.js"
-    },
-    "./httpapi/mcp": {
-      "types": "./dist/lib/httpapi-mcp.d.ts",
-      "import": "./dist/lib/httpapi-mcp.js"
+    "./httpapi/adapter": {
+      "types": "./dist/lib/httpapi-adapter.d.ts",
+      "import": "./dist/lib/httpapi-adapter.js"
     },
     "./opentelemetry/api": {
       "types": "./dist/services/opentelemetry/api.d.ts",

package/dist/lib/httpapi-client.d.ts

@@ -1,30 +0,0 @@
-import { Context, Effect, Layer, Schema } from "effect";
-import { HttpClient } from "effect/http";
-import { HttpApi, HttpApiGroup } from "effect/http-api";
-import type { HttpApiOperationEntry, HttpApiOperationInput } from "./httpapi-helpers.js";
-import type { Json } from "effect/Schema";
-export type ApiClientConfig<Id extends string, Groups extends HttpApiGroup.Constraint> = {
-    readonly api: HttpApi.HttpApi<Id, Groups>;
-    readonly baseUrl: string;
-    readonly encodeResult?: (result: ErrorOptions["cause"], operation: HttpApiOperationEntry) => Effect.Effect<Json, Error>;
-};
-export type ApiClientExecuteOptions = {
-    readonly operation: HttpApiOperationEntry;
-    readonly input: HttpApiOperationInput;
-};
-export type HttpApiOperationResultValue = null | undefined | string | number | boolean | Date | Uint8Array | ReadonlyArray<HttpApiOperationResultValue> | {
-    readonly [key: string]: HttpApiOperationResultValue;
-};
-export declare const HttpApiOperationResult: Schema.Union<readonly [Schema.Codec<HttpApiOperationResultValue, Json, never, never>, Schema.Undefined]>;
-export type HttpApiOperationResult = typeof HttpApiOperationResult.Type;
-export declare const encodeHttpApiOperationResult: (result: unknown) => Effect.Effect<string | number | boolean | Schema.JsonArray | Schema.JsonObject | null, Error, never>;
-export declare const makeHttpApiOperationResultEncoder: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>) => (result: unknown, operation: HttpApiOperationEntry) => Effect.Effect<string | number | boolean | Schema.JsonArray | Schema.JsonObject | null, Error, never>;
-export type ApiClientService = {
-    readonly encodeResult: (result: ErrorOptions["cause"], operation: HttpApiOperationEntry) => Effect.Effect<Json, Error>;
-    readonly execute: (options: ApiClientExecuteOptions) => Effect.Effect<ErrorOptions["cause"], Error>;
-};
-declare const ApiClient_base: Context.ServiceClass<ApiClient, "ApiClient", ApiClientService>;
-export declare class ApiClient extends ApiClient_base {
-    static readonly layer: <Id extends string, Groups extends HttpApiGroup.Constraint>(config: ApiClientConfig<Id, Groups>) => Layer.Layer<ApiClient, never, HttpClient.HttpClient | Exclude<import("effect/http-api/HttpApiMiddleware").MiddlewareClient<import("effect/http-api/HttpApiEndpoint").Middleware<HttpApiGroup.Endpoints<Groups>>>, import("effect/Scope").Scope>>;
-}
-export {};

package/dist/lib/httpapi-client.js

@@ -1,112 +0,0 @@
-// ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
-import { HttpClient } from "effect/http";
-import {
-  HttpApi,
-  HttpApiClient as EffectHttpApiClient,
-  OpenApi
-} from "effect/http-api";
-var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
-  decode: () => {
-    return;
-  },
-  encode: () => null
-})));
-var HttpApiOperationResultValue = Schema.suspend(() => Schema.Union([
-  Schema.Null,
-  UndefinedFromNull,
-  Schema.String,
-  Schema.Number,
-  Schema.Boolean,
-  Schema.DateFromString,
-  Schema.Uint8ArrayFromBase64,
-  Schema.Array(HttpApiOperationResultValue),
-  Schema.Record(Schema.String, HttpApiOperationResultValue)
-]));
-var HttpApiOperationResult = Schema.Union([
-  HttpApiOperationResultValue,
-  Schema.Undefined
-]).annotate({ identifier: "HttpApiOperationResult" });
-var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
-var reflectedSchema = (schema) => Schema.make(schema.ast);
-var operationResultSchemas = (api) => {
-  const schemas = new Map;
-  HttpApi.reflect(api, {
-    onGroup: () => {
-      return;
-    },
-    onEndpoint: ({ endpoint, group, successes }) => {
-      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
-      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
-      if (operationSchemas.length === 1 && operationSchemas[0]) {
-        schemas.set(operationId, operationSchemas[0]);
-      } else if (operationSchemas.length > 1) {
-        schemas.set(operationId, Schema.Union(operationSchemas));
-      }
-    }
-  });
-  return schemas;
-};
-var makeHttpApiOperationResultEncoder = (api) => {
-  const schemas = operationResultSchemas(api);
-  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
-    const operationId = operation.operation.operationId;
-    const schema = operationId ? schemas.get(operationId) : undefined;
-    if (!schema)
-      return encodeHttpApiOperationResult(result);
-    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
-      cause
-    })));
-  });
-};
-var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
-var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
-var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
-  baseUrl,
-  httpClient: http
-});
-var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperation")(function* (client, { input, operation: entry }) {
-  const operationId = entry.operation.operationId;
-  if (!operationId) {
-    return yield* Effect.fail(new Error(`No generated API client operation for ${entry.method} ${entry.path}`));
-  }
-  const target = Object(client);
-  const groupName = Object.keys(target).filter((name) => operationId.startsWith(`${name}.`)).sort((a, b) => b.length - a.length)[0];
-  const group = groupName ? Object.entries(target).find(([name]) => name === groupName)?.[1] : target;
-  const endpointName = groupName ? operationId.slice(groupName.length + 1) : operationId;
-  const endpointCandidate = group instanceof Function ? undefined : Object.entries(Object(group)).find(([name]) => name === endpointName)?.[1];
-  const endpoint = Schema.decodeUnknownOption(GeneratedOperation)(endpointCandidate);
-  if (endpoint._tag === "None") {
-    return yield* Effect.fail(new Error(`No generated API client operation for ${operationId}`));
-  }
-  const result = Schema.decodeUnknownOption(GeneratedOperationEffect)(endpoint.value({
-    headers: input.headers,
-    params: input.params,
-    query: input.query,
-    payload: input.body
-  }));
-  if (result._tag === "None") {
-    return yield* Effect.fail(new Error(`Generated API client operation ${operationId} is invalid`));
-  }
-  return yield* result.value;
-});
-
-class ApiClient extends Context.Service()("ApiClient") {
-  static layer = (config) => Layer.effect(this, Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient;
-    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
-    const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
-    return {
-      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
-      execute: Effect.fn("ApiClient.execute")(function* (options) {
-        return yield* executeGeneratedOperation(client, options);
-      })
-    };
-  }));
-}
-export {
-  ApiClient,
-  HttpApiOperationResult,
-  encodeHttpApiOperationResult,
-  makeHttpApiOperationResultEncoder
-};

package/dist/lib/httpapi-helpers.d.ts

@@ -1,101 +0,0 @@
-import { Context, Effect, JsonSchema, Layer, Schema } from "effect";
-import type { Json } from "effect/Schema";
-import { HttpApi, OpenApi } from "effect/http-api";
-export declare const JsonObjectSchema: Schema.$Record<Schema.String, Schema.Codec<Json, Json, never, never>>;
-export type JsonObject = typeof JsonObjectSchema.Type;
-type HttpBoundaryError = ErrorOptions["cause"];
-export type HttpApiDocument = ReturnType<typeof OpenApi.fromApi>;
-export type HttpApiMethod = "get" | "post" | "put" | "patch" | "delete";
-export declare const HttpApiMethods: ReadonlyArray<HttpApiMethod>;
-export type HttpApiParameter = {
-    readonly name: string;
-    readonly in: "path" | "query" | "header" | "cookie";
-    readonly required?: boolean;
-    readonly description?: string;
-    readonly schema?: JsonSchema.JsonSchema;
-};
-export type HttpApiOperation = {
-    readonly operationId?: string;
-    readonly summary?: string;
-    readonly description?: string;
-    readonly parameters?: ReadonlyArray<HttpApiParameter>;
-    readonly requestBody?: {
-        readonly required?: boolean;
-        readonly content?: Record<string, {
-            readonly schema?: JsonSchema.JsonSchema;
-        }>;
-    };
-    readonly tags?: ReadonlyArray<string>;
-};
-export type HttpApiOperationEntry = {
-    readonly method: HttpApiMethod;
-    readonly path: string;
-    readonly operation: HttpApiOperation;
-};
-export type HttpApiOperationInputValue = ErrorOptions["cause"];
-export type HttpApiOperationInputValues = Readonly<Record<string, HttpApiOperationInputValue>>;
-export type HttpApiOperationInput = {
-    readonly body?: HttpApiOperationInputValue;
-    readonly headers: HttpApiOperationInputValues;
-    readonly params: HttpApiOperationInputValues;
-    readonly query: HttpApiOperationInputValues;
-};
-export type HttpApiSpecConfig = {
-    readonly api: HttpApi.Constraint;
-    readonly methods?: ReadonlyArray<HttpApiMethod>;
-    readonly include?: (operation: HttpApiOperationEntry) => boolean;
-};
-export declare const toHttpError: (message: string, error: HttpBoundaryError) => Error;
-export declare const sanitizeHttpName: (name: string) => string;
-export declare const httpApiToolName: (method: string, path: string, operation: HttpApiOperation) => string;
-export declare const httpApiOperations: ({ spec, methods, }: {
-    readonly spec: HttpApiDocument;
-    readonly methods?: ReadonlyArray<HttpApiMethod>;
-}) => ReadonlyArray<HttpApiOperationEntry>;
-export declare const httpApiToolEntries: (operations: readonly HttpApiOperationEntry[]) => Effect.Effect<{
-    method: HttpApiMethod;
-    path: string;
-    operation: HttpApiOperation;
-    name: string;
-}[], Error, never>;
-export declare const httpApiOperationInputSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-export declare const decodeHttpApiOperationInput: (input: Json, operation: HttpApiOperation) => Effect.Effect<{
-    body?: Json | undefined;
-    headers: any;
-    params: any;
-    query: any;
-}, Error, never>;
-export declare const parseJsonObject: (value: string | undefined, label: string) => Effect.Effect<{
-    readonly [x: string]: Json;
-}, Error, never>;
-export declare const parseJsonValue: (value: string | undefined, label: string) => Effect.Effect<Json | undefined, Error, never>;
-declare const HttpApiSpec_base: Context.ServiceClass<HttpApiSpec, "HttpApiSpec", {
-    info: OpenApi.OpenAPISpecInfo;
-    operations: HttpApiOperationEntry[];
-    decodeOperationInput: (input: Json, operation: HttpApiOperation) => Effect.Effect<{
-        body?: Json | undefined;
-        headers: any;
-        params: any;
-        query: any;
-    }, Error, never>;
-    operationJsonSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-    operationSchema: (operation: HttpApiOperation) => Schema.Codec<unknown, unknown, never, never>;
-}> & {
-    readonly make: (config: HttpApiSpecConfig) => Effect.Effect<{
-        info: OpenApi.OpenAPISpecInfo;
-        operations: HttpApiOperationEntry[];
-        decodeOperationInput: (input: Json, operation: HttpApiOperation) => Effect.Effect<{
-            body?: Json | undefined;
-            headers: any;
-            params: any;
-            query: any;
-        }, Error, never>;
-        operationJsonSchema: (operation: HttpApiOperation) => JsonSchema.JsonSchema;
-        operationSchema: (operation: HttpApiOperation) => Schema.Codec<unknown, unknown, never, never>;
-    }, Error, never>;
-};
-export declare class HttpApiSpec extends HttpApiSpec_base {
-    static readonly layer: (config: HttpApiSpecConfig) => Layer.Layer<HttpApiSpec, Error, never>;
-}
-export type HttpApiSpecService = typeof HttpApiSpec.Service;
-export {};