@krak-stack/registry 0.1.2 → 0.1.4

package/dist/lib/httpapi-cli.js

@@ -0,0 +1,412 @@
+// ../../src/lib/httpapi-cli.ts
+import {
+  Console,
+  Context as Context3,
+  Effect as Effect3,
+  FileSystem,
+  Layer as Layer3,
+  Path,
+  Stdio,
+  Stream,
+  Terminal
+} from "effect";
+import { Command, Flag } from "effect/unstable/cli";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+
+// ../../src/lib/httpapi-client.ts
+import { Context, Effect, Layer } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import {
+  HttpApiClient as EffectHttpApiClient
+} from "effect/unstable/httpapi";
+var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
+  baseUrl,
+  httpClient: http
+});
+var isClientEffect = (value) => Effect.isEffect(value);
+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 ? Reflect.get(target, groupName) : target;
+  const endpointName = groupName ? operationId.slice(groupName.length + 1) : operationId;
+  const endpoint = Reflect.get(Object(group), endpointName);
+  if (typeof endpoint !== "function") {
+    return yield* Effect.fail(new Error(`No generated API client operation for ${operationId}`));
+  }
+  const result = endpoint({
+    headers: input.headers,
+    params: input.params,
+    query: input.query,
+    payload: input.body
+  });
+  if (!isClientEffect(result)) {
+    return yield* Effect.fail(new Error(`Generated API client operation ${operationId} is invalid`));
+  }
+  return yield* result;
+});
+
+class ApiClient extends Context.Service()("ApiClient") {
+  static layer = (config) => Layer.effect(this, Effect.gen(function* () {
+    const http = yield* HttpClient.HttpClient;
+    const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
+    return {
+      execute: Effect.fn("ApiClient.execute")(function* (options) {
+        return yield* executeGeneratedOperation(client, options);
+      })
+    };
+  }));
+}
+
+// ../../src/lib/httpapi-helpers.tsx
+import {
+  Context as Context2,
+  Effect as Effect2,
+  JsonSchema,
+  Layer as Layer2,
+  Option,
+  Schema,
+  SchemaRepresentation
+} from "effect";
+import { HttpApi as HttpApi2, OpenApi } from "effect/unstable/httpapi";
+var JsonObjectSchema = Schema.Record(Schema.String, Schema.Unknown).annotate({
+  identifier: "HttpJsonObject",
+  title: "HTTP JSON object",
+  description: "A JSON object passed to an HTTP API operation.",
+  examples: [{ id: "example-id" }]
+});
+var JsonObjectFromString = Schema.fromJsonString(JsonObjectSchema);
+var JsonValueFromString = Schema.fromJsonString(Schema.Unknown);
+var JsonSchemaAnnotations = Schema.Struct({
+  title: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  examples: Schema.optional(Schema.Array(Schema.Unknown))
+}).annotate({
+  identifier: "HttpJsonSchemaAnnotations",
+  title: "HTTP JSON Schema annotations",
+  description: "JSON Schema annotations surfaced on generated tool inputs."
+});
+var HttpApiToolInputSchema = Schema.Struct({
+  body: Schema.optional(Schema.Unknown)
+}).annotate({
+  identifier: "HttpApiToolInput",
+  title: "HTTP API tool input",
+  description: "Input accepted by an HTTP API-backed tool.",
+  examples: [{ body: { id: "example-id" } }]
+});
+var HttpApiMethods = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete"
+];
+var toHttpError = (message, error) => new Error(message, { cause: error });
+var sanitizeHttpName = (name) => name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+var httpApiToolName = (method, path, operation) => {
+  const fallback = `${method}_${path.replace(/^\/api\//, "").replace(/[/:{}]/g, "_")}`;
+  return (operation.operationId || fallback).replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").slice(0, 64);
+};
+var httpApiOperations = ({
+  spec,
+  methods = HttpApiMethods
+}) => {
+  const operations = [];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (operation)
+        operations.push({ method, path, operation });
+    }
+  }
+  return operations;
+};
+var httpApiToolEntries = Effect2.fn("Http.toolEntries")(function* (operations) {
+  return yield* Effect2.try({
+    try: () => {
+      const names = new Set;
+      return operations.map((entry) => {
+        const name = httpApiToolName(entry.method, entry.path, entry.operation);
+        if (!name || names.has(name)) {
+          throw new Error(`Duplicate or empty HTTP API tool name: ${name}`);
+        }
+        names.add(name);
+        return { ...entry, name };
+      });
+    },
+    catch: (error) => error instanceof Error ? error : new Error(String(error))
+  });
+});
+var decodeAnnotations = Schema.decodeUnknownOption(JsonSchemaAnnotations);
+var schemaWithVisibleAnnotations = (schema) => {
+  const directAnnotations = decodeAnnotations(schema).pipe(Option.getOrElse(() => ({})));
+  const allOf = Array.isArray(schema.allOf) ? schema.allOf : [];
+  const annotations = allOf.reduce((acc, item) => ({
+    ...acc,
+    ...decodeAnnotations(item).pipe(Option.getOrElse(() => ({})))
+  }), directAnnotations);
+  return {
+    ...schema,
+    ..."title" in annotations && !("title" in schema) ? { title: annotations.title } : {},
+    ..."description" in annotations && !("description" in schema) ? { description: annotations.description } : {},
+    ..."examples" in annotations && !("examples" in schema) ? { examples: annotations.examples } : {}
+  };
+};
+var referencedDefinitions = (schema, definitions) => {
+  const names = new Set;
+  const pending = [schema];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || typeof current !== "object")
+      continue;
+    if (Array.isArray(current)) {
+      pending.push(...current);
+      continue;
+    }
+    for (const [key, value] of Object.entries(current)) {
+      if (key === "$ref" && typeof value === "string") {
+        const name = value.match(/^#\/(?:\$defs|components\/schemas)\/(.+)$/)?.[1];
+        if (name && !names.has(name) && definitions[name]) {
+          names.add(name);
+          pending.push(definitions[name]);
+        }
+      } else if (key !== "$defs") {
+        pending.push(value);
+      }
+    }
+  }
+  return Object.fromEntries([...names].map((name) => [name, definitions[name]]));
+};
+var operationParameters = (parameters, location) => parameters.filter((parameter) => parameter.in === location);
+var httpApiOperationInputSchema = (operation) => {
+  const parameters = operation.parameters ?? [];
+  const pathParameters = operationParameters(parameters, "path");
+  const queryParameters = operationParameters(parameters, "query");
+  const headerParameters = operationParameters(parameters, "header");
+  const properties = {};
+  const required = [];
+  const body = operation.requestBody?.content?.["application/json"]?.schema;
+  for (const parameter of [
+    ...pathParameters,
+    ...queryParameters,
+    ...headerParameters
+  ]) {
+    properties[parameter.name] = {
+      ...parameter.schema ? schemaWithVisibleAnnotations(parameter.schema) : { type: "string" },
+      ...parameter.description ? { description: parameter.description } : {}
+    };
+    if (parameter.required)
+      required.push(parameter.name);
+  }
+  if (body) {
+    properties.body = body;
+    if (operation.requestBody?.required)
+      required.push("body");
+  }
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+};
+var decodeJsonObject = Schema.decodeUnknownOption(JsonObjectSchema);
+var decodeHttpApiOperationInput = Effect2.fn("Http.decodeApiOperationInput")(function* (input, operation) {
+  const payload = yield* Schema.decodeUnknownEffect(JsonObjectSchema)(input ?? {}).pipe(Effect2.mapError(() => new Error("Tool input must be a JSON object")));
+  const decoded = yield* Schema.decodeUnknownEffect(HttpApiToolInputSchema)(payload).pipe(Effect2.mapError(() => new Error("Tool input must be a JSON object")));
+  const parameters = operation.parameters ?? [];
+  const pickParameters = (location) => {
+    const nestedKey = location === "path" ? "params" : location;
+    const nested = decodeJsonObject(payload[nestedKey]).pipe(Option.getOrElse(() => ({})));
+    return Object.fromEntries(operationParameters(parameters, location).map((parameter) => [
+      parameter.name,
+      nested[parameter.name] ?? payload[parameter.name]
+    ]).filter(([, value]) => value !== undefined));
+  };
+  return {
+    ...decoded,
+    headers: pickParameters("header"),
+    params: pickParameters("path"),
+    query: pickParameters("query")
+  };
+});
+var parseJsonObject = Effect2.fn("Http.parseJsonObject")(function* (value, label) {
+  if (!value)
+    return {};
+  return yield* Schema.decodeUnknownEffect(JsonObjectFromString)(value).pipe(Effect2.mapError(() => new Error(`${label} must be a JSON object`)));
+});
+var parseJsonValue = Effect2.fn("Http.parseJsonValue")(function* (value, label) {
+  if (!value)
+    return;
+  return yield* Schema.decodeUnknownEffect(JsonValueFromString)(value).pipe(Effect2.mapError(() => new Error(`${label} must be valid JSON`)));
+});
+
+class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
+  make: (config) => Effect2.try({
+    try: () => {
+      if (!HttpApi2.isHttpApi(config.api)) {
+        throw new Error("HttpApiSpec requires a valid HttpApi");
+      }
+      const spec = OpenApi.fromApi(config.api);
+      const operations = httpApiOperations({
+        spec,
+        methods: config.methods
+      }).filter((operation) => config.include?.(operation) ?? true);
+      const operationJsonSchema = (operation) => {
+        const schema = httpApiOperationInputSchema(operation);
+        const document = JsonSchema.fromSchemaOpenApi3_1({
+          ...schema,
+          $defs: spec.components?.schemas
+        });
+        const definitions = document.definitions ?? {};
+        const usedDefinitions = referencedDefinitions(document.schema, definitions);
+        return {
+          ...document.schema,
+          ...Object.keys(usedDefinitions).length > 0 ? { $defs: usedDefinitions } : {}
+        };
+      };
+      return {
+        info: spec.info,
+        operations,
+        decodeOperationInput: decodeHttpApiOperationInput,
+        operationJsonSchema,
+        operationSchema: (operation) => {
+          const document = JsonSchema.fromSchemaOpenApi3_1(operationJsonSchema(operation));
+          return SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(document));
+        }
+      };
+    },
+    catch: (error) => toHttpError("Failed to build HTTP API spec", error)
+  })
+}) {
+  static layer = (config) => Layer2.effect(this, this.make(config));
+}
+
+// ../../src/lib/httpapi-cli.ts
+class HttpApiCli extends Context3.Service()("HttpApiCli", {
+  make: () => Effect3.gen(function* () {
+    const spec = yield* HttpApiSpec;
+    const command = yield* makeHttpApiCliCommand();
+    return {
+      command,
+      run: (args) => Command.runWith(command, { version: spec.info.version })(args)
+    };
+  })
+}) {
+  static layer = Layer3.effect(this, this.make());
+}
+var fallbackName = (value, fallback) => sanitizeHttpName(value) || fallback;
+var operationIdParts = (operation) => operation.operationId?.split(".").filter(Boolean) ?? [];
+var operationGroupName = (operation) => fallbackName(operationIdParts(operation)[0] ?? operation.tags?.[0] ?? "default", "default");
+var operationGroupTitle = (operation) => operation.tags?.[0] ?? operationGroupName(operation);
+var operationName = (method, path, operation) => fallbackName(operationIdParts(operation).at(-1) ?? `${method}_${path.replace(/^\/api\//, "").replace(/[/:{}]/g, "_")}`, `${method}_operation`);
+var toCliOperation = ({
+  method,
+  operation,
+  path
+}) => ({
+  groupName: operationGroupName(operation),
+  groupTitle: operationGroupTitle(operation),
+  name: operationName(method, path, operation),
+  method,
+  path,
+  summary: operation.summary ?? operation.description ?? "",
+  operation
+});
+var httpApiCliOperationGroups = (operations) => {
+  const groups = new Map;
+  for (const operation of operations) {
+    const group = groups.get(operation.groupName);
+    if (group) {
+      group.operations.push(operation);
+    } else {
+      groups.set(operation.groupName, {
+        name: operation.groupName,
+        title: operation.groupTitle,
+        operations: [operation]
+      });
+    }
+  }
+  return Array.from(groups.values()).map((group) => ({
+    ...group,
+    operations: Array.from(group.operations).sort((a, b) => a.name.localeCompare(b.name))
+  })).sort((a, b) => a.name.localeCompare(b.name));
+};
+var print = (value) => Console.log(value);
+var formatOperations = (operations) => operations.map((operation) => `${operation.groupName}	${operation.name}	${operation.method.toUpperCase()}	${operation.path}	${operation.summary}`).join(`
+`);
+var listOperations = (operations) => print(formatOperations(operations));
+var callOperation = (operation, callConfig, client) => Effect3.gen(function* () {
+  const body = yield* parseJsonValue(callConfig.body, "--body");
+  const headers = yield* parseJsonObject(callConfig.headers, "--headers");
+  const params = yield* parseJsonObject(callConfig.params, "--params");
+  const query = yield* parseJsonObject(callConfig.query, "--query");
+  const response = yield* client.execute({
+    operation: {
+      method: operation.method,
+      path: operation.path,
+      operation: operation.operation
+    },
+    input: { body, headers, params, query }
+  });
+  const formatted = JSON.stringify(response, null, 2) ?? "null";
+  return yield* print(formatted);
+});
+var listCommand = (groups) => Command.make("list", {}, () => print(groups.map((group) => `${group.name}	${group.title}	${group.operations.length}`).join(`
+`))).pipe(Command.withDescription("List command groups"));
+var groupListCommand = (group) => Command.make("list", {}, () => listOperations(group.operations)).pipe(Command.withDescription(`List ${group.title} operations`));
+var operationCommand = (operation, client) => Command.make(operation.name, {
+  body: Flag.string("body").pipe(Flag.withDefault(""), Flag.withDescription("JSON request body")),
+  headers: Flag.string("headers").pipe(Flag.withDefault("{}"), Flag.withDescription("JSON object for request headers")),
+  params: Flag.string("params").pipe(Flag.withDefault("{}"), Flag.withDescription("JSON object for path parameters")),
+  query: Flag.string("query").pipe(Flag.withDefault("{}"), Flag.withDescription("JSON object for query parameters"))
+}, (callConfig) => callOperation(operation, callConfig, client)).pipe(Command.withDescription(operation.summary || `${operation.method.toUpperCase()} ${operation.path}`));
+var groupCommand = (group, client) => Command.make(group.name).pipe(Command.withDescription(group.title), Command.withSubcommands([
+  groupListCommand(group),
+  ...group.operations.map((operation) => operationCommand(operation, client))
+]));
+var makeHttpApiCliCommand = Effect3.fn("HttpApiCli.makeCommand")(function* () {
+  const spec = yield* HttpApiSpec;
+  const client = yield* ApiClient;
+  const name = sanitizeHttpName(spec.info.title);
+  const groups = httpApiCliOperationGroups(spec.operations.map(toCliOperation));
+  return Command.make(name).pipe(Command.withDescription(spec.info.description ?? spec.info.title), Command.withSubcommands([
+    listCommand(groups),
+    ...groups.map((group) => groupCommand(group, client))
+  ]));
+});
+var cliEnvironmentLayer = (args) => Layer3.mergeAll(FileSystem.layerNoop({}), Path.layer, Stdio.layerTest({ args: Effect3.succeed(Array.from(args)) }), Layer3.succeed(Terminal.Terminal, Terminal.make({
+  columns: Effect3.sync(() => process.stdout.columns ?? 80),
+  rows: Effect3.sync(() => process.stdout.rows ?? 24),
+  readInput: Effect3.die("Terminal input is not supported"),
+  readLine: Effect3.die("Terminal input is not supported"),
+  display: (text) => Effect3.sync(() => process.stdout.write(text))
+})), Layer3.succeed(ChildProcessSpawner, ChildProcessSpawner.of({
+  spawn: () => Effect3.die("Child processes are not supported"),
+  exitCode: () => Effect3.die("Child processes are not supported"),
+  streamString: () => Stream.die("Child processes are not supported"),
+  streamLines: () => Stream.die("Child processes are not supported"),
+  lines: () => Effect3.die("Child processes are not supported"),
+  string: () => Effect3.die("Child processes are not supported")
+})));
+var httpApiCliEnvironmentLayer = (args) => cliEnvironmentLayer(args);
+var httpApiCli = (args = process.argv.slice(2)) => Effect3.gen(function* () {
+  const cli = yield* HttpApiCli;
+  return yield* cli.run(args);
+});
+var runHttpApiCli = (layer, args = process.argv.slice(2)) => {
+  Effect3.runPromise(httpApiCli(args).pipe(Effect3.provide(layer), Effect3.provide(httpApiCliEnvironmentLayer(args)))).catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+};
+export {
+  runHttpApiCli,
+  makeHttpApiCliCommand,
+  httpApiCliEnvironmentLayer,
+  httpApiCli,
+  HttpApiCli
+};

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

@@ -0,0 +1,20 @@
+import { Context, Effect, Layer } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { HttpApi, HttpApiGroup } from "effect/unstable/httpapi";
+import type { HttpApiOperationEntry, HttpApiOperationInput } from "./httpapi-helpers.js";
+export type ApiClientConfig<Id extends string, Groups extends HttpApiGroup.Constraint> = {
+    readonly api: HttpApi.HttpApi<Id, Groups>;
+    readonly baseUrl: string;
+};
+export type ApiClientExecuteOptions = {
+    readonly operation: HttpApiOperationEntry;
+    readonly input: HttpApiOperationInput;
+};
+export type ApiClientService = {
+    readonly execute: (options: ApiClientExecuteOptions) => Effect.Effect<unknown, unknown>;
+};
+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/unstable/httpapi/HttpApiMiddleware").MiddlewareClient<import("effect/unstable/httpapi/HttpApiEndpoint").Middleware<HttpApiGroup.Endpoints<Groups>>>, import("effect/Scope").Scope>>;
+}
+export {};

package/dist/lib/httpapi-client.js

@@ -0,0 +1,50 @@
+// ../../src/lib/httpapi-client.ts
+import { Context, Effect, Layer } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import {
+  HttpApiClient as EffectHttpApiClient
+} from "effect/unstable/httpapi";
+var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
+  baseUrl,
+  httpClient: http
+});
+var isClientEffect = (value) => Effect.isEffect(value);
+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 ? Reflect.get(target, groupName) : target;
+  const endpointName = groupName ? operationId.slice(groupName.length + 1) : operationId;
+  const endpoint = Reflect.get(Object(group), endpointName);
+  if (typeof endpoint !== "function") {
+    return yield* Effect.fail(new Error(`No generated API client operation for ${operationId}`));
+  }
+  const result = endpoint({
+    headers: input.headers,
+    params: input.params,
+    query: input.query,
+    payload: input.body
+  });
+  if (!isClientEffect(result)) {
+    return yield* Effect.fail(new Error(`Generated API client operation ${operationId} is invalid`));
+  }
+  return yield* result;
+});
+
+class ApiClient extends Context.Service()("ApiClient") {
+  static layer = (config) => Layer.effect(this, Effect.gen(function* () {
+    const http = yield* HttpClient.HttpClient;
+    const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
+    return {
+      execute: Effect.fn("ApiClient.execute")(function* (options) {
+        return yield* executeGeneratedOperation(client, options);
+      })
+    };
+  }));
+}
+export {
+  ApiClient
+};

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

@@ -0,0 +1,105 @@
+import { Context, Effect, JsonSchema, Layer, Schema } from "effect";
+import { HttpApi, OpenApi } from "effect/unstable/httpapi";
+export declare const JsonObjectSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+export type JsonObject = typeof JsonObjectSchema.Type;
+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 HttpApiOperationInput = {
+    readonly body?: unknown;
+    readonly headers: JsonObject;
+    readonly params: JsonObject;
+    readonly query: JsonObject;
+};
+export type HttpApiSpecConfig = {
+    readonly api: HttpApi.Constraint;
+    readonly methods?: ReadonlyArray<HttpApiMethod>;
+    readonly include?: (operation: HttpApiOperationEntry) => boolean;
+};
+export declare const toHttpError: (message: string, error: unknown) => 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: unknown, operation: HttpApiOperation) => Effect.Effect<{
+    body?: unknown;
+    headers: any;
+    params: any;
+    query: any;
+}, Error, never>;
+export declare const parseJsonObject: (value: string | undefined, label: string) => Effect.Effect<{
+    readonly [x: string]: unknown;
+}, Error, never>;
+export declare const parseJsonValue: (value: string | undefined, label: string) => Effect.Effect<unknown, Error, never>;
+declare const HttpApiSpec_base: Context.ServiceClass<HttpApiSpec, "HttpApiSpec", {
+    info: OpenApi.OpenAPISpecInfo;
+    operations: HttpApiOperationEntry[];
+    decodeOperationInput: (input: unknown, operation: HttpApiOperation) => Effect.Effect<{
+        body?: unknown;
+        headers: any;
+        params: any;
+        query: any;
+    }, Error, never>;
+    operationJsonSchema: (operation: HttpApiOperation) => {
+        $defs?: {
+            [k: string]: JsonSchema.JsonSchema;
+        } | undefined;
+    };
+    operationSchema: (operation: HttpApiOperation) => Schema.Top;
+}> & {
+    readonly make: (config: HttpApiSpecConfig) => Effect.Effect<{
+        info: OpenApi.OpenAPISpecInfo;
+        operations: HttpApiOperationEntry[];
+        decodeOperationInput: (input: unknown, operation: HttpApiOperation) => Effect.Effect<{
+            body?: unknown;
+            headers: any;
+            params: any;
+            query: any;
+        }, Error, never>;
+        operationJsonSchema: (operation: HttpApiOperation) => {
+            $defs?: {
+                [k: string]: JsonSchema.JsonSchema;
+            } | undefined;
+        };
+        operationSchema: (operation: HttpApiOperation) => Schema.Top;
+    }, 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 {};