@rafads/plugin-openapi 1.5.38

package/dist/react/client.d.ts

@@ -0,0 +1,233 @@
+export declare const OpenApiClient: import("effect/unstable/reactivity/AtomHttpApi").AtomHttpApiClient<"Plugin_openapiClient", `Plugin_${string}Client`, import("effect/unstable/httpapi/HttpApiGroup").HttpApiGroup<"openapi", import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"previewSpec", "POST", "/openapi/preview", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly spec: import("effect/Schema").String;
+    readonly specFormat: import("effect/Schema").optional<import("effect/Schema").String>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly title: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+    readonly description: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+    readonly version: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+    readonly servers: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly url: import("effect/Schema").String;
+        readonly description: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly variables: import("effect/Schema").OptionFromOptional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly default: import("effect/Schema").String;
+            readonly enum: import("effect/Schema").OptionFromOptional<import("effect/Schema").$Array<import("effect/Schema").String>>;
+            readonly description: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        }>>>;
+    }>>;
+    readonly operationCount: import("effect/Schema").Number;
+    readonly tags: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly securitySchemes: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly name: import("effect/Schema").String;
+        readonly type: import("effect/Schema").Literals<readonly ["http", "apiKey", "oauth2", "openIdConnect"]>;
+        readonly scheme: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly bearerFormat: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly in: import("effect/Schema").OptionFromOptional<import("effect/Schema").Literals<readonly ["header", "query", "cookie"]>>;
+        readonly headerName: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly description: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly flows: import("effect/Schema").OptionFromOptional<import("effect/Schema").Struct<{
+            readonly authorizationCode: import("effect/Schema").OptionFromOptional<import("effect/Schema").Struct<{
+                readonly authorizationUrl: import("effect/Schema").String;
+                readonly tokenUrl: import("effect/Schema").String;
+                readonly refreshUrl: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+                readonly scopes: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>;
+            }>>;
+            readonly clientCredentials: import("effect/Schema").OptionFromOptional<import("effect/Schema").Struct<{
+                readonly tokenUrl: import("effect/Schema").String;
+                readonly refreshUrl: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+                readonly scopes: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>;
+            }>>;
+        }>>;
+        readonly openIdConnectUrl: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+    }>>;
+    readonly authStrategies: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly schemes: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>>;
+    readonly headerPresets: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly label: import("effect/Schema").String;
+        readonly headers: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").NullOr<import("effect/Schema").String>>;
+        readonly secretHeaders: import("effect/Schema").$Array<import("effect/Schema").String>;
+    }>>;
+    readonly oauth2Presets: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly label: import("effect/Schema").String;
+        readonly securitySchemeName: import("effect/Schema").String;
+        readonly flow: import("effect/Schema").Literals<readonly ["authorizationCode", "clientCredentials"]>;
+        readonly authorizationUrl: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly tokenUrl: import("effect/Schema").String;
+        readonly resource: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly refreshUrl: import("effect/Schema").OptionFromOptional<import("effect/Schema").String>;
+        readonly scopes: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>;
+        readonly identityScopes: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"auto">, import("effect/Schema").Literal<false>, import("effect/Schema").$Array<import("effect/Schema").String>]>;
+        readonly supportsClientIdMetadataDocument: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    }>>;
+    readonly healthCheckCandidates: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly operation: import("effect/Schema").String;
+        readonly method: import("effect/Schema").String;
+        readonly requiredArgCount: import("effect/Schema").Number;
+        readonly destructive: import("effect/Schema").Boolean;
+        readonly summary: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly parameters: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").String;
+            readonly location: import("effect/Schema").String;
+            readonly required: import("effect/Schema").Boolean;
+            readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>>>;
+        readonly responseFields: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").String;
+            readonly type: import("effect/Schema").String;
+        }>>>;
+    }>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@rafads/sdk").IntegrationAlreadyExistsError | typeof import("@rafads/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"addSpec", "POST", "/openapi/specs", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly spec: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"url">;
+        readonly url: import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"blob">;
+        readonly value: import("effect/Schema").String;
+    }>]>;
+    readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly name: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly baseUrl: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+    readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+    readonly specFormat: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly family: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly healthCheck: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly operation: import("effect/Schema").String;
+        readonly args: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
+        readonly identityField: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>>;
+    readonly authenticationTemplate: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly authorizationUrl: import("effect/Schema").String;
+        readonly tokenUrl: import("effect/Schema").String;
+        readonly resource: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly supportsClientIdMetadataDocument: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly type: import("effect/Schema").Literal<"apiKey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+        readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+    }>]>>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
+    readonly toolCount: import("effect/Schema").Number;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@rafads/sdk").IntegrationAlreadyExistsError | typeof import("@rafads/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getIntegration", "GET", "/openapi/integrations/:slug", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    slug: import("effect/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<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+    readonly slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
+    readonly description: import("effect/Schema").String;
+    readonly kind: import("effect/Schema").String;
+    readonly canRemove: import("effect/Schema").Boolean;
+    readonly canRefresh: import("effect/Schema").Boolean;
+}>>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@rafads/sdk").IntegrationAlreadyExistsError | typeof import("@rafads/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getConfig", "GET", "/openapi/integrations/:slug/config", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    slug: import("effect/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<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+    readonly specUrl: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly baseUrl: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+    readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+    readonly authenticationTemplate: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly authorizationUrl: import("effect/Schema").String;
+        readonly tokenUrl: import("effect/Schema").String;
+        readonly resource: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly supportsClientIdMetadataDocument: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"apikey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+            readonly name: import("effect/Schema").String;
+            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>>;
+    }>]>>>;
+}>>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@rafads/sdk").IntegrationAlreadyExistsError | typeof import("@rafads/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"configure", "POST", "/openapi/integrations/:slug/config", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    slug: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly authenticationTemplate: import("effect/Schema").optional<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly authorizationUrl: import("effect/Schema").String;
+        readonly tokenUrl: import("effect/Schema").String;
+        readonly resource: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly supportsClientIdMetadataDocument: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly type: import("effect/Schema").Literal<"apiKey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly headers: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+        readonly queryParams: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"variable">;
+            readonly name: import("effect/Schema").String;
+        }>]>>]>>>;
+    }>]>>>;
+    readonly mode: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["merge", "replace"]>>;
+    readonly baseUrl: import("effect/Schema").optional<import("effect/Schema").String>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly authenticationTemplate: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"oauth2">;
+        readonly authorizationUrl: import("effect/Schema").String;
+        readonly tokenUrl: import("effect/Schema").String;
+        readonly resource: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+        readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly supportsClientIdMetadataDocument: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    }>, import("effect/Schema").Struct<{
+        readonly slug: import("effect/Schema").String;
+        readonly kind: import("effect/Schema").Literal<"apikey">;
+        readonly label: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly placements: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly carrier: import("effect/Schema").Literals<readonly ["header", "query"]>;
+            readonly name: import("effect/Schema").String;
+            readonly prefix: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly variable: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly literal: import("effect/Schema").optional<import("effect/Schema").String>;
+        }>>;
+    }>]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@rafads/sdk").IntegrationAlreadyExistsError | typeof import("@rafads/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"updateSpec", "POST", "/openapi/integrations/:slug/spec", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    slug: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly spec: import("effect/Schema").optional<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"url">;
+        readonly url: import("effect/Schema").String;
+    }>, import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"blob">;
+        readonly value: import("effect/Schema").String;
+    }>]>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
+    readonly toolCount: import("effect/Schema").Number;
+    readonly addedTools: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly removedTools: import("effect/Schema").$Array<import("effect/Schema").String>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").decodeTo<import("effect/Schema").declareConstructor<import("@rafads/sdk").IntegrationNotFoundError, {
+    readonly _tag: "IntegrationNotFoundError";
+    readonly slug: string;
+}, readonly [import("effect/Schema").TaggedStruct<"IntegrationNotFoundError", {
+    readonly slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
+}>], {
+    readonly _tag: "IntegrationNotFoundError";
+    readonly slug: string & import("effect/Brand").Brand<"IntegrationSlug">;
+}>, import("effect/Schema").TaggedStruct<"IntegrationNotFoundError", {
+    readonly slug: import("effect/Schema").brand<import("effect/Schema").String, "IntegrationSlug">;
+}>, never, never> | typeof import("@rafads/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"removeSpec", "DELETE", "/openapi/integrations/:slug", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    slug: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Void>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("@rafads/sdk").IntegrationAlreadyExistsError | typeof import("@rafads/sdk").InternalError | typeof import("../sdk").OpenApiParseError | typeof import("../sdk").OpenApiExtractionError | typeof import("../sdk").OpenApiOAuthError>, never, never>, false>>;

package/dist/react/index.d.ts

@@ -0,0 +1,5 @@
+export { openApiIntegrationPlugin } from "./integration-plugin";
+export { OpenApiClient } from "./client";
+export { OpenApiIntegrationDetailsFields } from "./OpenApiIntegrationDetailsFields";
+export { authenticationFromEditorValue, authMethodsFromConfig, editorValueFromAuthentication, openApiWireAuthInput, placementsFromApiKey, templateFromPlacements, } from "./auth-method-config";
+export { previewOpenApiSpec, addOpenApiSpec, removeOpenApiSpec, openapiConfigure, openApiConfigAtom, openApiConfigFamily, openApiIntegrationAtom, openApiIntegrationFamily, } from "./atoms";

package/dist/react/integration-plugin.d.ts

@@ -0,0 +1,6 @@
+import type { IntegrationPlugin, IntegrationPreset } from "@rafads/sdk/client";
+export interface OpenApiClientConfig {
+    readonly presets?: readonly IntegrationPreset[];
+}
+export declare const createOpenApiIntegrationPlugin: (config?: OpenApiClientConfig) => IntegrationPlugin;
+export declare const openApiIntegrationPlugin: IntegrationPlugin;

package/dist/react/plugin-client.d.ts

@@ -0,0 +1,2 @@
+import { type OpenApiClientConfig } from "./integration-plugin";
+export default function createOpenApiClientPlugin(config?: OpenApiClientConfig): import("@rafads/sdk/client").ClientPluginSpec<"openapi">;

package/dist/sdk/backing.d.ts

@@ -0,0 +1,188 @@
+import { Effect } from "effect";
+import type { Layer } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { type HealthCheckCandidate, type HealthCheckResult, type HealthCheckSpec, type IntegrationRecord, type PluginCtx, type ResolveToolsResult, type StorageFailure, type ToolDef, type ToolInvocationCredential } from "@rafads/sdk/core";
+import { type OpenApiIntegrationConfig } from "./config";
+import { OpenApiExtractionError, OpenApiInvocationError, OpenApiParseError } from "./errors";
+import { type ToolDefinition } from "./definitions";
+import { type InvokeOptions } from "./invoke";
+import { type ParsedDocument } from "./parse";
+import { type KeepPathItem, type SpecStructure } from "./split";
+import { type OpenapiStore, type StoredOperation } from "./store";
+export declare const extractOpenApiUpstreamMessage: (body: unknown, status: number) => string;
+/** Rewrite OpenAPI `#/components/schemas/X` refs to standard `#/$defs/X`. */
+export declare const normalizeOpenApiRefs: (node: unknown) => unknown;
+export interface CompiledOpenApiSpec {
+    readonly definitions: readonly ToolDefinition[];
+    readonly hoistedDefs: Record<string, unknown>;
+    readonly title: string | undefined;
+    readonly description: string | undefined;
+}
+export declare const compileOpenApiDocument: (doc: ParsedDocument) => Effect.Effect<CompiledOpenApiSpec, OpenApiExtractionError>;
+export declare const compileOpenApiSpec: (specText: string) => Effect.Effect<CompiledOpenApiSpec, OpenApiParseError | OpenApiExtractionError>;
+/** Test-only reset so unit tests can observe cold-cache behavior. */
+export declare const clearCompiledOpenApiSpecCache: () => void;
+/** Compile through the module-level LRU. `specHash` is the content hash the
+ *  spec text was loaded by (`OpenApiIntegrationConfig.specHash`). A missing
+ *  hash (legacy config shape) bypasses the cache rather than paying to hash
+ *  multi-MB text on the request path. */
+export declare const compileOpenApiSpecCached: (specHash: string | null | undefined, specText: string) => Effect.Effect<CompiledOpenApiSpec, OpenApiParseError | OpenApiExtractionError>;
+export declare const openApiToolDefsFromCompiled: (compiled: CompiledOpenApiSpec) => readonly ToolDef[];
+export declare const openApiStoredOperationsFromCompiled: (integration: string, compiled: CompiledOpenApiSpec) => readonly StoredOperation[];
+/**
+ * Serialize a document's `components.schemas` into the content-addressed defs
+ * blob JSON (`{ "<Name>": <normalized schema>, ... }`), one schema at a time.
+ * Normalizing + stringifying per entry keeps the whole normalized definition
+ * tree from ever being co-resident with the parsed document, so the streaming
+ * add path's peak stays near parse level. The serve path JSON-parses this blob
+ * to rebuild the shared `definitions` instead of re-parsing the spec.
+ */
+export declare const buildDefsJson: (doc: ParsedDocument) => string;
+/**
+ * Streaming twin of `buildDefsJson`: serialize the content-addressed defs blob
+ * from a `SpecStructure` by parsing each `components.schemas` entry in isolation
+ * (indent-4 range) rather than from a whole-document parse. Used by the fully
+ * streaming add path so the 37MB Microsoft Graph spec never builds its
+ * ~300MB tree. The blob carries *all* source schemas (it is shared across every
+ * tenant/selection on the same spec hash); extra unreferenced `$defs` are
+ * harmless. Like `buildDefsJson`, normalizing + stringifying per entry keeps the
+ * whole normalized tree from being co-resident with any parsed schema, and the
+ * ConsString accumulation avoids the join-doubling of an array build.
+ */
+export declare const buildDefsJsonStreaming: (structure: SpecStructure) => string;
+export interface OpenApiPersistResult {
+    readonly toolCount: number;
+    readonly toolNames: readonly string[];
+}
+/**
+ * Compile a parsed document straight to persisted operation bindings, streaming
+ * in bounded chunks so a huge spec's bindings are never all co-resident with
+ * the parsed tree. This is the memory-safe replacement for
+ * `compileOpenApiDocument` + `openApiStoredOperationsFromCompiled` + `putOperations`
+ * on the add/update path: it skips per-op input/output schema assembly (the
+ * serve path rebuilds those on demand from the bindings). Clears existing
+ * operations first, then appends each chunk. When `specHash` is given, also
+ * stream-serializes the document's `#/$defs/*` into the content-addressed defs
+ * blob so the serve path can resolve the shared `definitions` without
+ * re-parsing the spec.
+ */
+export declare const compileAndPersistOpenApiOperations: ({ doc, integration, storage, specHash, chunkSize, }: {
+    readonly doc: ParsedDocument;
+    readonly integration: string;
+    readonly storage: OpenapiStore;
+    readonly specHash?: string;
+    readonly chunkSize?: number;
+}) => Effect.Effect<OpenApiPersistResult, OpenApiExtractionError | StorageFailure>;
+/** Parse spec text, then stream-compile + persist its bindings (and, when
+ *  `specHash` is given, the content-addressed defs blob). */
+export declare const compileAndPersistOpenApiSpec: ({ specText, integration, storage, specHash, chunkSize, }: {
+    readonly specText: string;
+    readonly integration: string;
+    readonly storage: OpenapiStore;
+    readonly specHash?: string;
+    readonly chunkSize?: number;
+}) => Effect.Effect<OpenApiPersistResult, OpenApiParseError | OpenApiExtractionError | StorageFailure>;
+/**
+ * Fully streaming add/update path: compile + persist operation bindings (and the
+ * content-addressed defs blob) straight from spec *text*, without ever parsing
+ * the whole document. The text is structurally split, then each path-item and
+ * each schema is parsed in isolation and discarded, so peak memory stays near
+ * one item rather than the ~300MB whole-tree parse that OOMs a 128MB Workers
+ * isolate on the 37MB Microsoft Graph spec.
+ *
+ * There is deliberately no whole-parse fallback: a spec that does not present
+ * the streamable block-YAML profile (no top-level `paths:` block) is a hard
+ * `OpenApiExtractionError`, because the fallback is exactly the OOM this path
+ * exists to avoid. `keepPathItem` optionally filters/trims path-items (the
+ * Microsoft Graph scope selection), so the same primitive serves a full-spec
+ * compile and a selection identically.
+ */
+export declare const compileAndPersistOpenApiSpecStreaming: ({ specText, integration, storage, specHash, chunkSize, keepPathItem, }: {
+    readonly specText: string;
+    readonly integration: string;
+    readonly storage: OpenapiStore;
+    readonly specHash?: string;
+    readonly chunkSize?: number;
+    readonly keepPathItem?: KeepPathItem;
+}) => Effect.Effect<OpenApiPersistResult, OpenApiExtractionError | StorageFailure>;
+export declare const loadOpenApiSpecText: (storage: OpenapiStore, config: OpenApiIntegrationConfig) => Effect.Effect<string | null, StorageFailure>;
+/**
+ * Resolve the tool defs + shared definitions for a connection refresh
+ * (`tools/list`). Fast path: serve from the persisted operation bindings plus
+ * the content-addressed defs blob, rebuilding each tool's input/output schema
+ * on demand, so a 37MB spec is never re-parsed (the 2nd OOM site). The defs
+ * blob is global per `specHash`, so the heavy normalize work is done once at
+ * add time and shared across every tenant on the same spec. Falls back to the
+ * spec re-parse for legacy rows persisted before the defs blob existed (or if
+ * the blob is missing/corrupt).
+ */
+export declare const resolveOpenApiBackedTools: ({ integration, config, storage, }: {
+    readonly integration: {
+        readonly slug: string;
+    };
+    readonly config: unknown;
+    readonly storage: OpenapiStore;
+}) => Effect.Effect<ResolveToolsResult, StorageFailure>;
+export declare const invokeOpenApiBackedTool: (input: {
+    readonly ctx: PluginCtx<OpenapiStore>;
+    readonly toolRow: {
+        readonly integration: string;
+        readonly name: string;
+    };
+    readonly credential: ToolInvocationCredential;
+    readonly args: unknown;
+    readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>;
+    readonly invokeOptions?: InvokeOptions;
+}) => Effect.Effect<{
+    readonly ok: false;
+    readonly error: import("@rafads/sdk/core").ToolError;
+} | {
+    readonly ok: true;
+    readonly data: unknown;
+    readonly http?: import("@rafads/sdk/core").ToolHttpMeta;
+}, StorageFailure | OpenApiExtractionError | OpenApiInvocationError, never>;
+/** Pre-approval argument validation: run the exact request-building pass
+ *  `invoke` runs (path params, request body, base64 payloads) and discard the
+ *  built request. Fails with the same pre-flight OpenApiInvocationError the
+ *  real invocation would raise, so a call guaranteed to fail is rejected
+ *  before the executor pauses it for approval. Legacy rows without a
+ *  persisted binding skip validation (re-parsing the spec here would repeat
+ *  invokeTool's heavy fallback for no user-visible gain). */
+export declare const validateOpenApiBackedToolArgs: (input: {
+    readonly ctx: PluginCtx<OpenapiStore>;
+    readonly toolRow: {
+        readonly integration: string;
+        readonly name: string;
+    };
+    readonly args: unknown;
+}) => Effect.Effect<void, StorageFailure | OpenApiInvocationError, never>;
+export declare const resolveOpenApiBackedAnnotations: (input: {
+    readonly ctx: PluginCtx<OpenapiStore>;
+    readonly integration: string;
+    readonly toolRows: readonly {
+        readonly name: string;
+    }[];
+}) => Effect.Effect<Record<string, {
+    requiresApproval?: boolean;
+    approvalDescription?: string;
+}>, StorageFailure, never>;
+/** Run the given probe against a resolved credential and classify the outcome.
+ *  The spec is resolved by CORE (its own storage) and passed in; this never
+ *  reads it from the plugin config. Never fails for credential/upstream
+ *  reasons: a rejected credential is a `HealthCheckResult` with
+ *  `status: "expired"`, not an error. */
+export declare const checkHealthOpenApi: (input: {
+    readonly ctx: PluginCtx<OpenapiStore>;
+    readonly integration: IntegrationRecord;
+    readonly credential: ToolInvocationCredential;
+    readonly spec?: HealthCheckSpec;
+    readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>;
+}) => Effect.Effect<HealthCheckResult, StorageFailure>;
+/** List the operations a user can pick as the health check, ranked
+ *  non-destructive-first then fewest-required-args so the obvious "GET /me"
+ *  identity endpoint floats to the top. Recompiles the spec once (best-effort)
+ *  to recover human summaries the stored binding does not keep. */
+export declare const listHealthCheckCandidatesOpenApi: (input: {
+    readonly ctx: PluginCtx<OpenapiStore>;
+    readonly integration: IntegrationRecord;
+}) => Effect.Effect<readonly HealthCheckCandidate[], StorageFailure>;

package/dist/sdk/client-credentials-oauth.test.d.ts

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

package/dist/sdk/compiled-spec-cache.test.d.ts

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

package/dist/sdk/config.d.ts

@@ -0,0 +1,81 @@
+import { Schema } from "effect";
+import type { Authentication } from "./types";
+export declare const AuthenticationSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly kind: Schema.Literal<"oauth2">;
+    readonly authorizationUrl: Schema.String;
+    readonly tokenUrl: Schema.String;
+    readonly resource: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly scopes: Schema.$Array<Schema.String>;
+    readonly supportsClientIdMetadataDocument: Schema.optional<Schema.Boolean>;
+}>, Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly kind: Schema.Literal<"apikey">;
+    readonly label: Schema.optional<Schema.String>;
+    readonly placements: Schema.$Array<Schema.Struct<{
+        readonly carrier: Schema.Literals<readonly ["header", "query"]>;
+        readonly name: Schema.String;
+        readonly prefix: Schema.optional<Schema.String>;
+        readonly variable: Schema.optional<Schema.String>;
+        readonly literal: Schema.optional<Schema.String>;
+    }>>;
+}>]>;
+export declare const OpenApiIntegrationConfigSchema: Schema.Struct<{
+    /** Hex SHA-256 of the resolved spec text — the content address of the spec
+     *  blob (`spec/<hash>` in the plugin blob store). */
+    readonly specHash: Schema.optional<Schema.String>;
+    /** Origin URL the spec was fetched from, when known. Enables refresh. */
+    readonly specUrl: Schema.optional<Schema.String>;
+    /** Optional base URL override. */
+    readonly baseUrl: Schema.optional<Schema.String>;
+    /** Static headers applied to every request (no secret material). */
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    /** Static query params applied to every request (no secret material). */
+    readonly queryParams: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    /** Adapter id used to fetch/convert the source format, when not plain OpenAPI. */
+    readonly specFormat: Schema.optional<Schema.String>;
+    /** Catalog family for grouped integration display. */
+    readonly family: Schema.optional<Schema.String>;
+    /** The auth methods a connection's value can be applied through. */
+    readonly authenticationTemplate: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly slug: Schema.String;
+        readonly kind: Schema.Literal<"oauth2">;
+        readonly authorizationUrl: Schema.String;
+        readonly tokenUrl: Schema.String;
+        readonly resource: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly scopes: Schema.$Array<Schema.String>;
+        readonly supportsClientIdMetadataDocument: Schema.optional<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly slug: Schema.String;
+        readonly kind: Schema.Literal<"apikey">;
+        readonly label: Schema.optional<Schema.String>;
+        readonly placements: Schema.$Array<Schema.Struct<{
+            readonly carrier: Schema.Literals<readonly ["header", "query"]>;
+            readonly name: Schema.String;
+            readonly prefix: Schema.optional<Schema.String>;
+            readonly variable: Schema.optional<Schema.String>;
+            readonly literal: Schema.optional<Schema.String>;
+        }>>;
+    }>]>>>;
+}>;
+export type OpenApiIntegrationConfig = Omit<typeof OpenApiIntegrationConfigSchema.Type, "authenticationTemplate"> & {
+    /** Branded over the schema's structural form so the template renderer can
+     *  treat `slug` as an `AuthTemplateSlug`. */
+    readonly authenticationTemplate?: readonly Authentication[];
+};
+/** Decode the opaque integration config blob into the openapi shape.
+ *  Returns null when the blob is missing/incompatible. */
+export declare const decodeOpenApiIntegrationConfig: (value: unknown) => OpenApiIntegrationConfig | null;
+export interface RenderedAuth {
+    readonly headers: Record<string, string>;
+    readonly queryParams: Record<string, string>;
+}
+/** Render an auth template against a connection's resolved input `values`
+ *  (`variable → value`). Each placement substitutes from its own entry, so a
+ *  method with two distinct inputs (e.g. Datadog) fills each header from a
+ *  different value. */
+export declare const renderAuthTemplate: (template: Authentication, values: Record<string, string | null>) => RenderedAuth;
+/** The distinct input variables a template references — the inputs a connection
+ *  must supply. An oauth template needs `token`; an apiKey method needs every
+ *  variable across its placements. */
+export declare const requiredTemplateVariables: (template: Authentication) => readonly string[];

package/dist/sdk/configure.test.d.ts

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

package/dist/sdk/definitions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Derives structured `group.leaf` tool paths from extracted OpenAPI operations.
+ *
+ * Ported from the v3 executor's `definitions.ts`. Turns flat operation IDs like
+ * `zones_listZones` into nested paths like `zones.listZones` that the tree UI
+ * can render with proper nesting.
+ */
+import type { ExtractedOperation } from "./types";
+export interface ToolDefinition {
+    /** Dot-separated path like `zones.listZones` */
+    readonly toolPath: string;
+    /** The group segment */
+    readonly group: string;
+    /** The leaf segment */
+    readonly leaf: string;
+    /** Index into the original operations array */
+    readonly operationIndex: number;
+    /** The original operation */
+    readonly operation: ExtractedOperation;
+}
+/**
+ * The minimal per-operation metadata the tool-path planner needs. Kept
+ * deliberately light (no schemas) so the streaming compile path can plan paths
+ * for tens of thousands of operations without holding the full extracted
+ * operations in memory.
+ */
+export interface OperationPathInput {
+    readonly operationId: string;
+    readonly explicitToolPath: string | undefined;
+    readonly method: string;
+    readonly pathTemplate: string;
+    /** The first non-empty tag, used to seed the group segment. */
+    readonly tag0: string | undefined;
+}
+/** A resolved tool path plus its index back into the input operations array. */
+export interface PlannedToolPath {
+    readonly toolPath: string;
+    readonly group: string;
+    readonly leaf: string;
+    readonly operationIndex: number;
+}
+/**
+ * Plan structured `group.leaf` tool paths from lightweight per-operation
+ * metadata. Path derivation + collision resolution need a global view of every
+ * operation, but only its name/method/path/tag, never its schemas. Keeping this
+ * pass schema-free lets the streaming compile path plan paths for a 16k-op spec
+ * without materializing the full extracted operations.
+ *
+ * The returned `operationIndex` points back into the `inputs` array.
+ */
+export declare const planToolPaths: (inputs: readonly OperationPathInput[]) => PlannedToolPath[];
+/**
+ * Compile extracted operations into tool definitions with structured
+ * `group.leaf` paths suitable for tree rendering. Thin wrapper over
+ * `planToolPaths` that re-attaches each operation by index.
+ */
+export declare const compileToolDefinitions: (operations: readonly ExtractedOperation[]) => ToolDefinition[];

package/dist/sdk/derive-auth.d.ts

@@ -0,0 +1,11 @@
+import type { HeaderPreset, OAuth2Preset, SpecPreview, SpecPreviewSummary } from "./preview";
+import type { Authentication } from "./types";
+type PreviewAuthMetadata = SpecPreview | SpecPreviewSummary;
+export declare function resolveOAuthUrl(url: string, baseUrl: string): string;
+export declare const resolvedOAuthScopes: (apiScopes: Iterable<string>, identityScopes: OAuth2Preset["identityScopes"]) => string[];
+export declare const detectedAuthenticationTemplates: (headerPresets: readonly HeaderPreset[], oauth2Presets: readonly OAuth2Preset[], baseUrl: string) => readonly Authentication[];
+export declare const firstBaseUrlForPreview: (preview: PreviewAuthMetadata) => string;
+/** The fallback `addSpec` uses when no explicit template was passed: every
+ *  spec-detected method, resolved against the integration's base URL. */
+export declare const deriveAuthenticationTemplateFromPreview: (preview: PreviewAuthMetadata, baseUrl: string | undefined) => readonly Authentication[];
+export {};

package/dist/sdk/describe-auth-methods.test.d.ts

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