@executor-js/plugin-openapi 0.0.1 → 0.1.0

package/dist/sdk/openapi-utils.d.ts

@@ -13,12 +13,43 @@ export declare class DocResolver {
     resolve<T>(value: T | OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject): T | null;
     private resolvePointer;
 }
-export declare const resolveBaseUrl: (servers: readonly {
+/** Substitute `{var}` placeholders in a templated URL using a plain map. */
+export declare const substituteUrlVariables: (url: string, values: Record<string, string>) => string;
+type ServerLike = {
     url: string;
-    variables: import("effect/Option").Option<Record<string, string>>;
-}[]) => string;
-/** Pick the preferred media type entry (prefer application/json) */
+    variables: import("effect/Option").Option<Record<string, {
+        default: string;
+    } | string>>;
+};
+export declare const resolveBaseUrl: (servers: readonly ServerLike[]) => string;
+/**
+ * Return all declared media entries in spec order. `Object.entries` on a
+ * plain object preserves insertion order in modern engines, which matches
+ * spec declaration order as the parser produced it.
+ */
+export declare const declaredContents: (content: Record<string, MediaTypeObject> | undefined) => ReadonlyArray<{
+    mediaType: string;
+    media: MediaTypeObject;
+}>;
+/**
+ * Pick the default media type for a requestBody or response. Matches
+ * swagger-client behaviour: **first declared wins** (not JSON-first). Spec
+ * authors order content entries to signal intent (upload-heavy endpoints
+ * declare multipart first, JSON second); respecting that order avoids
+ * silently downgrading a multipart endpoint to JSON.
+ *
+ * For response bodies we still want a JSON preference because the server
+ * picks the response content type, not the client — the old `application/
+ * json` preference is preserved via `preferredResponseContent` below.
+ */
 export declare const preferredContent: (content: Record<string, MediaTypeObject> | undefined) => {
     mediaType: string;
     media: MediaTypeObject;
 } | undefined;
+/** Response-side content picker — still JSON-first because the server
+ *  picks the response media type, so we want to advertise a preference. */
+export declare const preferredResponseContent: (content: Record<string, MediaTypeObject> | undefined) => {
+    mediaType: string;
+    media: MediaTypeObject;
+} | undefined;
+export {};

package/dist/sdk/parse.d.ts

@@ -1,10 +1,34 @@
 import type { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
 import { Effect } from "effect";
-import { OpenApiParseError } from "./errors";
+import { HttpClient } from "effect/unstable/http";
+import { OpenApiExtractionError, OpenApiParseError } from "./errors";
 export type ParsedDocument = OpenAPIV3.Document | OpenAPIV3_1.Document;
-/** Parse, validate, and bundle an OpenAPI document from text or URL */
-export declare const parse: (input: string) => Effect.Effect<ParsedDocument, OpenApiParseError | OpenApiExtractionErrorFromParse, never>;
-import { OpenApiExtractionError } from "./errors";
+export interface SpecFetchCredentials {
+    readonly headers?: Record<string, string>;
+    readonly queryParams?: Record<string, string>;
+}
 declare class OpenApiExtractionErrorFromParse extends OpenApiExtractionError {
 }
+/**
+ * Fetch an OpenAPI spec URL and return its body text. Uses the Effect
+ * HttpClient so the caller chooses the transport via layer — in Cloudflare
+ * Workers, `FetchHttpClient.layer` binds to the Workers-native `fetch` and
+ * avoids json-schema-ref-parser's Node-polyfill http resolver, which hangs
+ * in production. Bounded by a 20s timeout.
+ */
+export declare const fetchSpecText: (url: string, credentials?: SpecFetchCredentials | undefined) => Effect.Effect<string, OpenApiParseError, HttpClient.HttpClient>;
+/**
+ * Resolve an input string to spec text — if it's a URL, fetch it via
+ * HttpClient; otherwise return it as-is.
+ */
+export declare const resolveSpecText: (input: string, credentials?: SpecFetchCredentials) => Effect.Effect<string, OpenApiParseError, HttpClient.HttpClient>;
+/**
+ * Parse an OpenAPI document from spec text and validate it's OpenAPI 3.x.
+ *
+ * NOTE: does NOT resolve `$ref`s. `DocResolver` + `normalizeOpenApiRefs`
+ * downstream work on refs lazily, so inlining them here would just waste
+ * memory — and for big specs (e.g. Cloudflare's API) that blows through
+ * the 128MB Cloudflare Workers memory cap.
+ */
+export declare const parse: (text: string) => Effect.Effect<ParsedDocument, OpenApiParseError | OpenApiExtractionErrorFromParse, never>;
 export {};

package/dist/sdk/plugin.d.ts

@@ -1,40 +1,295 @@
-import { Effect } from "effect";
-import { HttpClient } from "@effect/platform";
+import { Effect, Schema } from "effect";
 import type { Layer } from "effect";
-import { type ExecutorPlugin } from "@executor-js/sdk";
-import type { OpenApiOperationStore, StoredSource } from "./operation-store";
+import { HttpClient } from "effect/unstable/http";
+import { OpenApiExtensionService } from "../api/handlers";
+import { type StorageFailure } from "@executor-js/sdk/core";
+import { type ConfigFileSink } from "@executor-js/config";
+import { OpenApiExtractionError, OpenApiOAuthError, OpenApiParseError } from "./errors";
 import { SpecPreview } from "./preview";
-import { type HeaderValue as HeaderValueValue } from "./types";
-/** A header value — either a static string or a reference to a secret */
+import { type OpenapiStore, type SourceConfig, type StoredSource } from "./store";
+import { HeaderValue as HeaderValueSchema, OAuth2Auth, OAuth2SourceConfig, OpenApiSourceBindingInput, type OpenApiSourceBindingRef, type ConfiguredHeaderValue as ConfiguredHeaderValueValue, type HeaderValue as HeaderValueValue } from "./types";
 export type HeaderValue = HeaderValueValue;
+export type ConfiguredHeaderValue = ConfiguredHeaderValueValue;
+export type OpenApiHeaderInput = HeaderValue | ConfiguredHeaderValue;
+export type OpenApiOAuthInput = OAuth2Auth | OAuth2SourceConfig;
+export interface OpenApiSpecFetchCredentials {
+    readonly headers?: Record<string, HeaderValue>;
+    readonly queryParams?: Record<string, HeaderValue>;
+}
+export interface OpenApiPreviewInput {
+    readonly spec: string;
+    readonly specFetchCredentials?: OpenApiSpecFetchCredentials;
+}
 export interface OpenApiSpecConfig {
     readonly spec: string;
+    readonly specFetchCredentials?: OpenApiSpecFetchCredentials;
+    /**
+     * Executor scope id that owns this source row. Must be one of the
+     * executor's configured scopes. Typical shape: an admin adds the
+     * source at the outermost (organization) scope so it's visible to
+     * every inner (per-user) scope via fall-through reads.
+     */
+    readonly scope: string;
     readonly name?: string;
     readonly baseUrl?: string;
     readonly namespace?: string;
-    /** Headers applied to every request. Values can reference secrets. */
-    readonly headers?: Record<string, HeaderValue>;
+    readonly headers?: Record<string, OpenApiHeaderInput>;
+    readonly queryParams?: Record<string, HeaderValue>;
+    readonly oauth2?: OpenApiOAuthInput;
 }
 export interface OpenApiUpdateSourceInput {
     readonly name?: string;
     readonly baseUrl?: string;
-    readonly headers?: Record<string, HeaderValue>;
+    readonly headers?: Record<string, OpenApiHeaderInput>;
+    readonly queryParams?: Record<string, HeaderValue>;
+    /** Refresh the source's stored OAuth2 metadata after a successful
+     *  re-authenticate. */
+    readonly oauth2?: OpenApiOAuthInput;
 }
+/**
+ * Errors any OpenAPI extension method may surface. The first three are
+ * plugin-domain tagged errors that flow directly to clients (4xx, each
+ * carrying its own `HttpApiSchema` status). `StorageFailure` covers
+ * raw backend failures (`StorageError`) plus `UniqueViolationError`;
+ * the HTTP edge (`@executor-js/api`'s `withCapture`) translates
+ * `StorageError` to the opaque `InternalError({ traceId })` at Layer
+ * composition. `UniqueViolationError` passes through — plugins can
+ * `Effect.catchTag` it if they want a friendlier user-facing error.
+ */
+export type OpenApiExtensionFailure = OpenApiParseError | OpenApiExtractionError | OpenApiOAuthError | StorageFailure;
 export interface OpenApiPluginExtension {
-    /** Preview a spec without registering — returns metadata, auth strategies, header presets */
-    readonly previewSpec: (specText: string) => Effect.Effect<SpecPreview, Error>;
-    /** Add an OpenAPI spec and register its operations as tools */
+    readonly previewSpec: (input: string | OpenApiPreviewInput) => Effect.Effect<SpecPreview, OpenApiParseError | OpenApiExtractionError | OpenApiOAuthError | StorageFailure>;
     readonly addSpec: (config: OpenApiSpecConfig) => Effect.Effect<{
+        readonly sourceId: string;
         readonly toolCount: number;
-    }, Error>;
-    /** Remove all tools from a previously added spec by namespace */
-    readonly removeSpec: (namespace: string) => Effect.Effect<void>;
-    /** Fetch the full stored source by namespace (or null if missing) */
-    readonly getSource: (namespace: string) => Effect.Effect<StoredSource | null>;
-    /** Update config (baseUrl, headers) for an existing OpenAPI source */
-    readonly updateSource: (namespace: string, input: OpenApiUpdateSourceInput) => Effect.Effect<void>;
+    }, OpenApiParseError | OpenApiExtractionError | OpenApiOAuthError | StorageFailure>;
+    readonly removeSpec: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure>;
+    readonly getSource: (namespace: string, scope: string) => Effect.Effect<StoredSource | null, StorageFailure>;
+    readonly updateSource: (namespace: string, scope: string, input: OpenApiUpdateSourceInput) => Effect.Effect<void, StorageFailure>;
+    readonly listSourceBindings: (sourceId: string, sourceScope: string) => Effect.Effect<readonly OpenApiSourceBindingRef[], StorageFailure>;
+    readonly setSourceBinding: (input: OpenApiSourceBindingInput) => Effect.Effect<OpenApiSourceBindingRef, StorageFailure>;
+    readonly removeSourceBinding: (sourceId: string, sourceScope: string, slot: string, scope: string) => Effect.Effect<void, StorageFailure>;
+}
+export interface OpenApiPluginOptions {
+    readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient, never, never>;
+    /** If provided, source add/remove is mirrored to executor.jsonc
+     *  (best-effort — file errors are logged, not raised). */
+    readonly configFile?: ConfigFileSink;
 }
-export declare const openApiPlugin: (options?: {
-    readonly httpClientLayer?: Layer.Layer<HttpClient.HttpClient>;
-    readonly operationStore?: OpenApiOperationStore;
-}) => ExecutorPlugin<"openapi", OpenApiPluginExtension>;
+export declare const openApiPlugin: import("@executor-js/sdk/core").ConfiguredPlugin<"openapi", {
+    previewSpec: (input: string | OpenApiPreviewInput) => Effect.Effect<SpecPreview, StorageFailure | OpenApiParseError | OpenApiExtractionError | OpenApiOAuthError, never>;
+    addSpec: (config: OpenApiSpecConfig) => Effect.Effect<{
+        sourceId: string;
+        toolCount: number;
+    }, StorageFailure | OpenApiParseError | OpenApiExtractionError | OpenApiOAuthError, never>;
+    removeSpec: (namespace: string, scope: string) => Effect.Effect<void, StorageFailure, never>;
+    getSource: (namespace: string, scope: string) => Effect.Effect<{
+        config: SourceConfig;
+        namespace: string;
+        scope: string;
+        name: string;
+        legacy?: {
+            readonly headers?: Record<string, HeaderValueSchema>;
+            readonly oauth2?: OAuth2Auth;
+        };
+    } | null, StorageFailure, never>;
+    updateSource: (namespace: string, scope: string, input: OpenApiUpdateSourceInput) => Effect.Effect<void, StorageFailure, never>;
+    listSourceBindings: (sourceId: string, sourceScope: string) => Effect.Effect<readonly OpenApiSourceBindingRef[], StorageFailure, never>;
+    setSourceBinding: (input: OpenApiSourceBindingInput) => Effect.Effect<OpenApiSourceBindingRef, StorageFailure, never>;
+    removeSourceBinding: (sourceId: string, sourceScope: string, slot: string, scope: string) => Effect.Effect<void, StorageFailure, never>;
+}, OpenapiStore, OpenApiPluginOptions, {
+    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 headers: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly query_params: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly oauth2: {
+                readonly type: "json";
+                readonly required: false;
+            };
+            readonly invocation_config: {
+                readonly type: "json";
+                readonly required: true;
+            };
+        };
+    };
+    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_binding: {
+        readonly fields: {
+            readonly id: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly source_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly source_scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly target_scope_id: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly slot: {
+                readonly type: "string";
+                readonly required: true;
+                readonly index: true;
+            };
+            readonly value: {
+                readonly type: "json";
+                readonly required: true;
+            };
+            readonly created_at: {
+                readonly type: "date";
+                readonly required: true;
+            };
+            readonly updated_at: {
+                readonly type: "date";
+                readonly required: true;
+            };
+        };
+    };
+}, typeof OpenApiExtensionService, Layer.Layer<import("effect/unstable/httpapi/HttpApiGroup").ApiGroup<"executor", "openapi">, never, import("effect/unstable/http/HttpRouter").Request<"Requires", OpenApiExtensionService>>, import("effect/unstable/httpapi/HttpApiGroup").HttpApiGroup<"openapi", import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"previewSpec", "POST", "/scopes/:scopeId/openapi/preview", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.Struct<{
+    readonly spec: Schema.String;
+    readonly specFetchCredentials: Schema.optional<Schema.Struct<{
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+        }>]>>>;
+        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+        }>]>>>;
+    }>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof SpecPreview>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"addSpec", "POST", "/scopes/:scopeId/openapi/specs", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.Struct<{
+    readonly spec: Schema.String;
+    readonly specFetchCredentials: Schema.optional<Schema.Struct<{
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+        }>]>>>;
+        readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly secretId: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+        }>]>>>;
+    }>>;
+    readonly name: 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.Unknown>>;
+    readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly secretId: Schema.String;
+        readonly prefix: Schema.optional<Schema.String>;
+    }>]>>>;
+    readonly oauth2: Schema.optional<Schema.Union<readonly [typeof OAuth2Auth, typeof OAuth2SourceConfig]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.Struct<{
+    readonly toolCount: Schema.Number;
+    readonly namespace: Schema.String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getSource", "GET", "/scopes/:scopeId/openapi/sources/:namespace", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+    namespace: Schema.String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.NullOr<typeof import("./store").StoredSourceSchema>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"updateSource", "PATCH", "/scopes/:scopeId/openapi/sources/:namespace", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+    namespace: Schema.String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.Struct<{
+    readonly name: Schema.optional<Schema.String>;
+    readonly baseUrl: Schema.optional<Schema.String>;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly secretId: Schema.String;
+        readonly prefix: Schema.optional<Schema.String>;
+    }>]>>>;
+    readonly oauth2: Schema.optional<Schema.Union<readonly [typeof OAuth2Auth, typeof OAuth2SourceConfig]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.Struct<{
+    readonly updated: Schema.Boolean;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"listSourceBindings", "GET", "/scopes/:scopeId/openapi/sources/:namespace/base/:sourceScopeId/bindings", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+    namespace: Schema.String;
+    sourceScopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.$Array<typeof OpenApiSourceBindingRef>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"setSourceBinding", "POST", "/scopes/:scopeId/openapi/source-bindings", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<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">;
+    }>, 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;
+    }>]>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof OpenApiSourceBindingRef>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"removeSourceBinding", "POST", "/scopes/:scopeId/openapi/source-bindings/remove", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<Schema.Struct<{
+    scopeId: Schema.brand<Schema.String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly sourceScope: Schema.brand<Schema.String, "ScopeId">;
+    readonly slot: Schema.String;
+    readonly scope: Schema.brand<Schema.String, "ScopeId">;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<Schema.Struct<{
+    readonly removed: Schema.Boolean;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@executor-js/api").InternalError | typeof OpenApiParseError | typeof OpenApiExtractionError | typeof OpenApiOAuthError>, never, never>, false>>;

package/dist/sdk/preview-oauth2.test.d.ts

@@ -0,0 +1 @@
+export {};