@executor-js/plugin-openapi 1.4.28 → 1.4.30

package/dist/sdk/store.d.ts

@@ -1,220 +1,11 @@
-import { Effect, Schema } from "effect";
+import { Effect } from "effect";
 import { type StorageDeps, type StorageFailure } from "@executor-js/sdk/core";
-import { ConfiguredHeaderValue, OAuth2SourceConfig, OperationBinding } from "./types";
-export declare const openapiSchema: {
-    readonly openapi_source: {
-        readonly fields: {
-            readonly id: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly scope_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly name: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly spec: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly source_url: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly base_url: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly oauth2: {
-                readonly type: "json";
-                readonly required: false;
-            };
-        };
-    };
-    readonly openapi_operation: {
-        readonly fields: {
-            readonly id: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly scope_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly source_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly binding: {
-                readonly type: "json";
-                readonly required: true;
-            };
-        };
-    };
-    readonly openapi_source_header: {
-        readonly fields: {
-            readonly id: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly scope_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly source_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly name: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly kind: {
-                readonly type: ["text", "binding"];
-                readonly required: true;
-            };
-            readonly text_value: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly slot_key: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly prefix: {
-                readonly type: "string";
-                readonly required: false;
-            };
-        };
-    };
-    readonly openapi_source_query_param: {
-        readonly fields: {
-            readonly id: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly scope_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly source_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly name: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly kind: {
-                readonly type: ["text", "binding"];
-                readonly required: true;
-            };
-            readonly text_value: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly slot_key: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly prefix: {
-                readonly type: "string";
-                readonly required: false;
-            };
-        };
-    };
-    readonly openapi_source_spec_fetch_header: {
-        readonly fields: {
-            readonly id: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly scope_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly source_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly name: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly kind: {
-                readonly type: ["text", "binding"];
-                readonly required: true;
-            };
-            readonly text_value: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly slot_key: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly prefix: {
-                readonly type: "string";
-                readonly required: false;
-            };
-        };
-    };
-    readonly openapi_source_spec_fetch_query_param: {
-        readonly fields: {
-            readonly id: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly scope_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly source_id: {
-                readonly type: "string";
-                readonly required: true;
-                readonly index: true;
-            };
-            readonly name: {
-                readonly type: "string";
-                readonly required: true;
-            };
-            readonly kind: {
-                readonly type: ["text", "binding"];
-                readonly required: true;
-            };
-            readonly text_value: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly slot_key: {
-                readonly type: "string";
-                readonly required: false;
-            };
-            readonly prefix: {
-                readonly type: "string";
-                readonly required: false;
-            };
-        };
-    };
-};
+import { OAuth2SourceConfig, OperationBinding, type ConfiguredHeaderValue } from "./types";
+export { StoredSourceSchema, type StoredSourceSchemaType, headerBindingSlot, oauth2ClientIdSlot, oauth2ClientSecretSlot, oauth2ConnectionSlot, queryParamBindingSlot, } from "./source-contracts";
+export declare const openapiSchema: {};
 export type OpenapiSchema = typeof openapiSchema;
 export interface SourceConfig {
     readonly spec: string;
-    /** Origin URL when the spec was fetched from http(s). Absent for
-     *  raw-text adds. Persisted so `refreshSource` can re-fetch. */
     readonly sourceUrl?: string;
     readonly baseUrl?: string;
     readonly namespace?: string;
@@ -229,70 +20,15 @@ export interface OpenApiSpecFetchCredentials {
 }
 export interface StoredSource {
     readonly namespace: string;
-    /** Executor scope id this source row lives in. Writes stamp this on
-     *  `scope_id`; reads return whichever scope's row the adapter's
-     *  fall-through filter sees first. */
     readonly scope: string;
     readonly name: string;
     readonly config: SourceConfig;
 }
-export declare const StoredSourceSchema: Schema.Struct<{
-    readonly namespace: Schema.String;
-    readonly scope: Schema.String;
-    readonly name: Schema.String;
-    readonly config: Schema.Struct<{
-        readonly spec: Schema.String;
-        readonly sourceUrl: Schema.optional<Schema.String>;
-        readonly baseUrl: Schema.optional<Schema.String>;
-        readonly namespace: Schema.optional<Schema.String>;
-        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
-            readonly kind: Schema.Literal<"binding">;
-            readonly slot: Schema.String;
-            readonly prefix: Schema.optional<Schema.String>;
-        }>]>>>;
-        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
-            readonly kind: Schema.Literal<"binding">;
-            readonly slot: Schema.String;
-            readonly prefix: Schema.optional<Schema.String>;
-        }>]>>>;
-        readonly specFetchCredentials: Schema.optional<Schema.Struct<{
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
-                readonly kind: Schema.Literal<"binding">;
-                readonly slot: Schema.String;
-                readonly prefix: Schema.optional<Schema.String>;
-            }>]>>>;
-            readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
-                readonly kind: Schema.Literal<"binding">;
-                readonly slot: Schema.String;
-                readonly prefix: Schema.optional<Schema.String>;
-            }>]>>>;
-        }>>;
-        readonly oauth2: Schema.optional<Schema.Struct<{
-            readonly kind: Schema.Literal<"oauth2">;
-            readonly securitySchemeName: Schema.String;
-            readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
-            readonly tokenUrl: Schema.String;
-            readonly authorizationUrl: Schema.NullOr<Schema.String>;
-            readonly issuerUrl: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly clientIdSlot: Schema.String;
-            readonly clientSecretSlot: Schema.NullOr<Schema.String>;
-            readonly connectionSlot: Schema.String;
-            readonly scopes: Schema.$Array<Schema.String>;
-        }>>;
-    }>;
-}>;
-export type StoredSourceSchema = typeof StoredSourceSchema.Type;
-export type StoredSourceSchemaType = typeof StoredSourceSchema.Type;
 export interface StoredOperation {
     readonly toolId: string;
     readonly sourceId: string;
     readonly binding: OperationBinding;
 }
-export declare const headerBindingSlot: (headerName: string) => string;
-export declare const queryParamBindingSlot: (name: string) => string;
-export declare const oauth2ClientIdSlot: (securitySchemeName: string) => string;
-export declare const oauth2ClientSecretSlot: (securitySchemeName: string) => string;
-export declare const oauth2ConnectionSlot: (securitySchemeName: string) => string;
 export interface OpenapiStore {
     readonly upsertSource: (input: StoredSource, operations: readonly StoredOperation[]) => Effect.Effect<void, StorageFailure>;
     readonly updateSourceMeta: (namespace: string, scope: string, patch: {
@@ -300,6 +36,7 @@ export interface OpenapiStore {
         readonly baseUrl?: string;
         readonly headers?: Record<string, ConfiguredHeaderValue>;
         readonly queryParams?: Record<string, ConfiguredHeaderValue>;
+        readonly specFetchCredentials?: OpenApiSpecFetchCredentials;
         readonly oauth2?: OAuth2SourceConfig;
     }) => Effect.Effect<void, StorageFailure>;
     readonly getSource: (namespace: string, scope: string) => Effect.Effect<StoredSource | null, StorageFailure>;
@@ -308,4 +45,4 @@ export interface OpenapiStore {
     readonly listOperationsBySource: (sourceId: string, scope: string) => Effect.Effect<readonly StoredOperation[], StorageFailure>;
     readonly removeSource: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
 }
-export declare const makeDefaultOpenapiStore: ({ adapter }: StorageDeps<OpenapiSchema>) => OpenapiStore;
+export declare const makeDefaultOpenapiStore: ({ pluginStorage, }: StorageDeps<OpenapiSchema>) => OpenapiStore;

package/dist/sdk/types.d.ts

@@ -1,4 +1,20 @@
 import { Schema } from "effect";
+import { type OAuth2FlowType, type OAuth2SourceConfigType } from "@executor-js/sdk/http-source";
+export declare const OAuth2Flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
+export type OAuth2Flow = OAuth2FlowType;
+export declare const OAuth2SourceConfig: Schema.Struct<{
+    readonly kind: Schema.Literal<"oauth2">;
+    readonly securitySchemeName: Schema.String;
+    readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
+    readonly tokenUrl: Schema.String;
+    readonly authorizationUrl: Schema.withDecodingDefault<Schema.optional<Schema.NullOr<Schema.String>>>;
+    readonly issuerUrl: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly clientIdSlot: Schema.String;
+    readonly clientSecretSlot: Schema.NullOr<Schema.String>;
+    readonly connectionSlot: Schema.String;
+    readonly scopes: Schema.$Array<Schema.String>;
+}>;
+export type OAuth2SourceConfig = OAuth2SourceConfigType;
 export declare const OperationId: Schema.brand<Schema.String, "OperationId">;
 export type OperationId = typeof OperationId.Type;
 export declare const HttpMethod: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
@@ -255,71 +271,6 @@ export declare const OpenApiCredentialInput: Schema.Union<readonly [Schema.Struc
     readonly prefix: Schema.optional<Schema.String>;
 }>]>]>;
 export type OpenApiCredentialInput = typeof OpenApiCredentialInput.Type;
-export declare const OpenApiSourceBindingValue: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"secret">;
-    readonly secretId: Schema.brand<Schema.String, "SecretId">;
-    readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
-}>, Schema.Struct<{
-    readonly kind: Schema.Literal<"connection">;
-    readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
-}>, Schema.Struct<{
-    readonly kind: Schema.Literal<"text">;
-    readonly text: Schema.String;
-}>]>;
-export type OpenApiSourceBindingValue = typeof OpenApiSourceBindingValue.Type;
-export declare const OpenApiSourceBindingInput: Schema.Struct<{
-    readonly sourceId: Schema.String;
-    readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
-    readonly scope: Schema.brand<Schema.String, "ScopeId">;
-    readonly slot: Schema.String;
-    readonly value: Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"secret">;
-        readonly secretId: Schema.brand<Schema.String, "SecretId">;
-        readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"connection">;
-        readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"text">;
-        readonly text: Schema.String;
-    }>]>;
-}>;
-export type OpenApiSourceBindingInput = typeof OpenApiSourceBindingInput.Type;
-export declare const OpenApiSourceBindingRef: Schema.Struct<{
-    readonly sourceId: Schema.String;
-    readonly sourceScopeId: Schema.brand<Schema.String, "ScopeId">;
-    readonly scopeId: Schema.brand<Schema.String, "ScopeId">;
-    readonly slot: Schema.String;
-    readonly value: Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"secret">;
-        readonly secretId: Schema.brand<Schema.String, "SecretId">;
-        readonly secretScopeId: Schema.optional<Schema.brand<Schema.String, "ScopeId">>;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"connection">;
-        readonly connectionId: Schema.brand<Schema.String, "ConnectionId">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"text">;
-        readonly text: Schema.String;
-    }>]>;
-    readonly createdAt: Schema.Date;
-    readonly updatedAt: Schema.Date;
-}>;
-export type OpenApiSourceBindingRef = typeof OpenApiSourceBindingRef.Type;
-export declare const OAuth2Flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
-export type OAuth2Flow = typeof OAuth2Flow.Type;
-export declare const OAuth2SourceConfig: Schema.Struct<{
-    readonly kind: Schema.Literal<"oauth2">;
-    readonly securitySchemeName: Schema.String;
-    readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
-    readonly tokenUrl: Schema.String;
-    readonly authorizationUrl: Schema.NullOr<Schema.String>;
-    readonly issuerUrl: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly clientIdSlot: Schema.String;
-    readonly clientSecretSlot: Schema.NullOr<Schema.String>;
-    readonly connectionSlot: Schema.String;
-    readonly scopes: Schema.$Array<Schema.String>;
-}>;
-export type OAuth2SourceConfig = typeof OAuth2SourceConfig.Type;
 export declare const InvocationResult: Schema.Struct<{
     readonly status: Schema.Number;
     readonly headers: Schema.$Record<Schema.String, Schema.String>;

package/dist/testing/index.d.ts

@@ -1,5 +1,8 @@
-import { Context, Effect, Layer } from "effect";
-import { HttpClient, HttpServer } from "effect/unstable/http";
+import { Context, Effect, Layer, Scope } from "effect";
+import { HttpClient, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpApi } from "effect/unstable/httpapi";
+import { OAuthTestServer } from "@executor-js/sdk/testing";
+import type { OpenApiPluginExtension, OpenApiSpecConfig } from "../sdk/plugin";
 declare const OpenApiTestServerAddressError_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: "OpenApiTestServerAddressError";
 } & Readonly<A>;
@@ -14,21 +17,156 @@ export declare class OpenApiTestServerSpecError extends OpenApiTestServerSpecErr
     readonly cause: unknown;
 }> {
 }
-export interface OpenApiTestServerOptions {
-    readonly spec: unknown;
-}
 export interface OpenApiTestServerShape {
     readonly baseUrl: string;
     readonly specJson: string;
     readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>;
 }
-export declare const openApiSpecJsonWithServer: (spec: unknown, baseUrl: string) => Effect.Effect<string, OpenApiTestServerSpecError>;
-export declare const makeOpenApiTestServer: (options: OpenApiTestServerOptions) => Effect.Effect<OpenApiTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, HttpClient.HttpClient | HttpServer.HttpServer>;
-declare const OpenApiTestServer_base: Context.ServiceClass<OpenApiTestServer, "@executor-js/plugin-openapi/testing/OpenApiTestServer", OpenApiTestServerShape>;
-export declare class OpenApiTestServer extends OpenApiTestServer_base {
-    static readonly layer: (options: OpenApiTestServerOptions) => Layer.Layer<OpenApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, HttpClient.HttpClient | HttpServer.HttpServer>;
+export interface OpenApiHttpApiTestServerOptions {
+    readonly api: HttpApi.Any;
+    readonly handlersLayer: Layer.Layer<any, any, any>;
+    readonly specPath?: `/${string}`;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+    readonly captureSpecRequest?: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<void>;
+    readonly guardSpecRequest?: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse | null>;
+}
+export interface OpenApiHttpApiTestServerShape extends OpenApiTestServerShape {
+    readonly specUrl: string;
+}
+export interface MutableOpenApiSpecTestServerShape extends OpenApiTestServerShape {
+    readonly specUrl: string;
+    readonly setApi: (api: HttpApi.Any) => Effect.Effect<void, OpenApiTestServerSpecError>;
+    readonly requestCount: Effect.Effect<number>;
+}
+export interface OpenApiTestRequest {
+    readonly method: string;
+    readonly url: string;
+    readonly path: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+export interface OpenApiEchoTestServerOptions {
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+    readonly oauth2?: {
+        readonly authorizationUrl: string;
+        readonly tokenUrl: string;
+        readonly scopes?: Readonly<Record<string, string>>;
+        readonly validateAuthorization?: (authorization: string | null) => Effect.Effect<boolean>;
+        readonly wwwAuthenticate?: string;
+    };
+}
+export interface OpenApiEchoTestServerShape extends OpenApiTestServerShape {
+    readonly specUrl: string;
+    readonly requests: Effect.Effect<readonly OpenApiTestRequest[]>;
+    readonly clearRequests: Effect.Effect<void>;
+}
+export type OpenApiTestSourceOptions = Omit<OpenApiSpecConfig, "spec" | "baseUrl" | "name" | "namespace"> & {
+    readonly baseUrl?: string | null;
+    readonly name?: string;
+    readonly namespace?: string;
+};
+export type OpenApiHttpApiTestSourceOptions = Omit<OpenApiSpecConfig, "spec" | "name" | "namespace" | "baseUrl"> & {
+    readonly name?: string;
+    readonly namespace?: string;
+    readonly baseUrl?: string | null;
+    readonly specBaseUrl?: string;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+};
+type OpenApiHttpApiAddSpecCredentialInput = string | {
+    readonly kind: "secret";
+    readonly prefix?: string;
+};
+type OpenApiHttpApiAddSpecCredentialsInput = {
+    readonly headers?: Record<string, OpenApiHttpApiAddSpecCredentialInput>;
+    readonly queryParams?: Record<string, OpenApiHttpApiAddSpecCredentialInput>;
+};
+export type OpenApiHttpApiTestAddSpecPayloadOptions = Omit<OpenApiHttpApiTestSourceOptions, "scope" | "headers" | "queryParams" | "specFetchCredentials"> & OpenApiHttpApiAddSpecCredentialsInput & {
+    readonly specFetchCredentials?: OpenApiHttpApiAddSpecCredentialsInput;
+};
+export type OpenApiTestSourceExecutor = {
+    readonly openapi: Pick<OpenApiPluginExtension, "addSpec">;
+};
+export interface OpenApiTestSpecOptions {
+    readonly baseUrl?: string;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+}
+export declare const makeOpenApiTestSpecJson: (api: HttpApi.Any, options?: OpenApiTestSpecOptions) => string;
+export declare const makeOpenApiTestSourceConfig: (server: OpenApiTestServerShape, options: OpenApiTestSourceOptions) => OpenApiSpecConfig;
+export declare const addOpenApiTestSource: (executor: OpenApiTestSourceExecutor, server: OpenApiTestServerShape, options: OpenApiTestSourceOptions) => Effect.Effect<{
+    readonly sourceId: string;
+    readonly toolCount: number;
+}, import("@executor-js/sdk/core").StorageFailure | import("../sdk").OpenApiParseError | import("../sdk").OpenApiExtractionError | import("../sdk").OpenApiOAuthError, never>;
+export declare const makeOpenApiHttpApiTestSourceConfig: (api: HttpApi.Any, options: OpenApiHttpApiTestSourceOptions) => OpenApiSpecConfig;
+export declare const addOpenApiHttpApiTestSource: (executor: OpenApiTestSourceExecutor, api: HttpApi.Any, options: OpenApiHttpApiTestSourceOptions) => Effect.Effect<{
+    readonly sourceId: string;
+    readonly toolCount: number;
+}, import("@executor-js/sdk/core").StorageFailure | import("../sdk").OpenApiParseError | import("../sdk").OpenApiExtractionError | import("../sdk").OpenApiOAuthError, never>;
+export declare const makeOpenApiHttpApiTestAddSpecPayload: (api: HttpApi.Any, options: OpenApiHttpApiTestAddSpecPayloadOptions) => {
+    specFetchCredentials?: OpenApiHttpApiAddSpecCredentialsInput | undefined;
+    oauth2?: {
+        readonly kind: "oauth2";
+        readonly scopes: readonly string[];
+        readonly clientSecretSlot: string | null;
+        readonly securitySchemeName: string;
+        readonly flow: "authorizationCode" | "clientCredentials";
+        readonly tokenUrl: string;
+        readonly clientIdSlot: string;
+        readonly connectionSlot: string;
+        readonly issuerUrl?: string | null | undefined;
+        readonly authorizationUrl?: string | null | undefined;
+    } | undefined;
+    queryParams?: Record<string, OpenApiHttpApiAddSpecCredentialInput> | undefined;
+    headers?: Record<string, OpenApiHttpApiAddSpecCredentialInput> | undefined;
+    spec: {
+        readonly kind: "url";
+        readonly url: string;
+    } | {
+        readonly value: string;
+        readonly kind: "blob";
+    };
+    namespace: string;
+    name: string;
+    baseUrl: string;
+};
+export declare const makeOpenApiHttpApiTestSpecPayload: (api: HttpApi.Any, options?: OpenApiTestSpecOptions) => {
+    spec: string;
+};
+export declare const serveOpenApiHttpApiTestServer: (options: OpenApiHttpApiTestServerOptions) => Effect.Effect<OpenApiHttpApiTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope>;
+declare const OpenApiHttpApiTestServer_base: Context.ServiceClass<OpenApiHttpApiTestServer, "@executor-js/plugin-openapi/testing/OpenApiHttpApiTestServer", OpenApiHttpApiTestServerShape>;
+export declare class OpenApiHttpApiTestServer extends OpenApiHttpApiTestServer_base {
+    static readonly layer: (options: OpenApiHttpApiTestServerOptions) => Layer.Layer<OpenApiHttpApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+}
+export declare const serveMutableOpenApiSpecTestServer: (options: {
+    readonly initialApi: HttpApi.Any;
+    readonly specPath?: `/${string}`;
+    readonly transformSpec?: (spec: Record<string, unknown>) => Record<string, unknown>;
+}) => Effect.Effect<MutableOpenApiSpecTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope>;
+export declare const serveOpenApiEchoTestServer: (options?: OpenApiEchoTestServerOptions) => Effect.Effect<OpenApiEchoTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope>;
+export declare const serveOpenApiEchoTestServerWithOAuth: (options?: Omit<OpenApiEchoTestServerOptions, "oauth2"> & {
+    readonly scopes?: Readonly<Record<string, string>>;
+    readonly wwwAuthenticate?: string;
+}) => Effect.Effect<OpenApiEchoTestServerShape, OpenApiTestServerAddressError | OpenApiTestServerSpecError, Scope.Scope | OAuthTestServer>;
+declare const OpenApiEchoTestServer_base: Context.ServiceClass<OpenApiEchoTestServer, "@executor-js/plugin-openapi/testing/OpenApiEchoTestServer", OpenApiEchoTestServerShape>;
+export declare class OpenApiEchoTestServer extends OpenApiEchoTestServer_base {
+    static readonly layer: (options?: OpenApiEchoTestServerOptions) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+    static readonly layerWithOAuth: (options?: Omit<OpenApiEchoTestServerOptions, "oauth2"> & {
+        readonly scopes?: Readonly<Record<string, string>>;
+        readonly wwwAuthenticate?: string;
+    }) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, OAuthTestServer>;
 }
 export declare const TestLayers: {
-    server: (options: OpenApiTestServerOptions) => Layer.Layer<OpenApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, HttpClient.HttpClient | HttpServer.HttpServer>;
+    httpApi: (options: OpenApiHttpApiTestServerOptions) => Layer.Layer<OpenApiHttpApiTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+    echo: (options?: OpenApiEchoTestServerOptions) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, never>;
+    echoWithOAuth: (options?: Omit<OpenApiEchoTestServerOptions, "oauth2"> & {
+        readonly scopes?: Readonly<Record<string, string>>;
+        readonly wwwAuthenticate?: string;
+    }) => Layer.Layer<OpenApiEchoTestServer, OpenApiTestServerAddressError | OpenApiTestServerSpecError, OAuthTestServer>;
 };
+export interface OpenApiInvocationResult<TData = Record<string, unknown> | unknown[] | null> {
+    readonly status: number | null;
+    readonly headers: Record<string, string> | null;
+    readonly data: TData;
+    readonly error: unknown;
+}
+export declare const unwrapInvocation: <TData = Record<string, unknown> | null>(raw: unknown) => OpenApiInvocationResult<TData>;
 export {};