@executor-js/plugin-openapi 0.0.1-beta.6 → 0.0.2

package/dist/sdk/types.d.ts

@@ -1,294 +1,262 @@
 import { Schema } from "effect";
-export declare const OperationId: Schema.brand<typeof Schema.String, "OperationId">;
+export declare const OperationId: Schema.brand<Schema.String, "OperationId">;
 export type OperationId = typeof OperationId.Type;
-export declare const HttpMethod: Schema.Literal<["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
+export declare const HttpMethod: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
 export type HttpMethod = typeof HttpMethod.Type;
-export declare const ParameterLocation: Schema.Literal<["path", "query", "header", "cookie"]>;
+export declare const ParameterLocation: Schema.Literals<readonly ["path", "query", "header", "cookie"]>;
 export type ParameterLocation = typeof ParameterLocation.Type;
-declare const OperationParameter_base: Schema.Class<OperationParameter, {
-    name: typeof Schema.String;
-    location: Schema.Literal<["path", "query", "header", "cookie"]>;
-    required: typeof Schema.Boolean;
-    schema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-    style: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    explode: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
-    }>;
-    allowReserved: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
-    }>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    name: typeof Schema.String;
-    location: Schema.Literal<["path", "query", "header", "cookie"]>;
-    required: typeof Schema.Boolean;
-    schema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-    style: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    explode: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
-    }>;
-    allowReserved: Schema.optionalWith<typeof Schema.Boolean, {
-        as: "Option";
-    }>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly name: string;
-} & {
-    readonly description: import("effect/Option").Option<string>;
-} & {
-    readonly required: boolean;
-} & {
-    readonly schema: import("effect/Option").Option<unknown>;
-} & {
-    readonly location: "query" | "path" | "header" | "cookie";
-} & {
-    readonly style: import("effect/Option").Option<string>;
-} & {
-    readonly explode: import("effect/Option").Option<boolean>;
-} & {
-    readonly allowReserved: import("effect/Option").Option<boolean>;
-}, {}, {}>;
+declare const OperationParameter_base: Schema.Class<OperationParameter, Schema.Struct<{
+    readonly name: Schema.String;
+    readonly location: Schema.Literals<readonly ["path", "query", "header", "cookie"]>;
+    readonly required: Schema.Boolean;
+    readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+    readonly style: Schema.OptionFromOptional<Schema.String>;
+    readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+    readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+}>, {}>;
 export declare class OperationParameter extends OperationParameter_base {
 }
-declare const OperationRequestBody_base: Schema.Class<OperationRequestBody, {
-    required: typeof Schema.Boolean;
-    contentType: typeof Schema.String;
-    schema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    required: typeof Schema.Boolean;
-    contentType: typeof Schema.String;
-    schema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly required: boolean;
-} & {
-    readonly schema: import("effect/Option").Option<unknown>;
-} & {
-    readonly contentType: string;
-}, {}, {}>;
+declare const EncodingObject_base: Schema.Class<EncodingObject, Schema.Struct<{
+    readonly contentType: Schema.OptionFromOptional<Schema.String>;
+    readonly style: Schema.OptionFromOptional<Schema.String>;
+    readonly explode: Schema.OptionFromOptional<Schema.Boolean>;
+    readonly allowReserved: Schema.OptionFromOptional<Schema.Boolean>;
+}>, {}>;
+/**
+ * OpenAPI 3.x `Encoding Object` (§4.8.15). Declared per-property inside a
+ * multipart/form-data or application/x-www-form-urlencoded request body.
+ *
+ * - `contentType` — for multipart, overrides the per-part `Content-Type`
+ *   header (e.g. `application/json` for a JSON-encoded metadata part).
+ * - `style` / `explode` / `allowReserved` — for form-urlencoded, control
+ *   array / object serialization the same way parameter-level style does.
+ */
+export declare class EncodingObject extends EncodingObject_base {
+}
+declare const MediaBinding_base: Schema.Class<MediaBinding, Schema.Struct<{
+    readonly contentType: Schema.String;
+    readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+    readonly encoding: Schema.OptionFromOptional<Schema.$Record<Schema.String, typeof EncodingObject>>;
+}>, {}>;
+export declare class MediaBinding extends MediaBinding_base {
+}
+declare const OperationRequestBody_base: Schema.Class<OperationRequestBody, Schema.Struct<{
+    readonly required: Schema.Boolean;
+    /** Default media type — first declared in spec order (not JSON-first).
+     *  Used when the caller does not override via the tool's `contentType` arg. */
+    readonly contentType: Schema.String;
+    /** Schema of the default media type. Kept for backward compat with stored
+     *  bindings from before `contents` was added. */
+    readonly schema: Schema.OptionFromOptional<Schema.Unknown>;
+    /** All declared media types in spec order. Populated by `extract.ts`
+     *  going forward; older persisted bindings may have this unset and will
+     *  fall back to `{contentType, schema}`. */
+    readonly contents: Schema.OptionFromOptional<Schema.$Array<typeof MediaBinding>>;
+}>, {}>;
 export declare class OperationRequestBody extends OperationRequestBody_base {
 }
-declare const ExtractedOperation_base: Schema.Class<ExtractedOperation, {
-    operationId: Schema.brand<typeof Schema.String, "OperationId">;
-    method: Schema.Literal<["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
-    pathTemplate: typeof Schema.String;
-    summary: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    tags: Schema.Array$<typeof Schema.String>;
-    parameters: Schema.Array$<typeof OperationParameter>;
-    requestBody: Schema.optionalWith<typeof OperationRequestBody, {
-        as: "Option";
-    }>;
-    inputSchema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-    outputSchema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-    deprecated: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-}, Schema.Struct.Encoded<{
-    operationId: Schema.brand<typeof Schema.String, "OperationId">;
-    method: Schema.Literal<["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
-    pathTemplate: typeof Schema.String;
-    summary: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    description: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    tags: Schema.Array$<typeof Schema.String>;
-    parameters: Schema.Array$<typeof OperationParameter>;
-    requestBody: Schema.optionalWith<typeof OperationRequestBody, {
-        as: "Option";
-    }>;
-    inputSchema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-    outputSchema: Schema.optionalWith<typeof Schema.Unknown, {
-        as: "Option";
-    }>;
-    deprecated: Schema.optionalWith<typeof Schema.Boolean, {
-        default: () => false;
-    }>;
-}>, never, {
-    readonly description: import("effect/Option").Option<string>;
-} & {
-    readonly inputSchema: import("effect/Option").Option<unknown>;
-} & {
-    readonly outputSchema: import("effect/Option").Option<unknown>;
-} & {
-    readonly tags: readonly string[];
-} & {
-    readonly summary: import("effect/Option").Option<string>;
-} & {
-    readonly parameters: readonly OperationParameter[];
-} & {
-    readonly operationId: string & import("effect/Brand").Brand<"OperationId">;
-} & {
-    readonly requestBody: import("effect/Option").Option<OperationRequestBody>;
-} & {
-    readonly deprecated?: boolean | undefined;
-} & {
-    readonly method: "delete" | "get" | "put" | "post" | "options" | "head" | "patch" | "trace";
-} & {
-    readonly pathTemplate: string;
-}, {}, {}>;
+declare const ExtractedOperation_base: Schema.Class<ExtractedOperation, Schema.Struct<{
+    readonly operationId: Schema.brand<Schema.String, "OperationId">;
+    readonly method: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
+    readonly pathTemplate: Schema.String;
+    readonly summary: Schema.OptionFromOptional<Schema.String>;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly parameters: Schema.$Array<typeof OperationParameter>;
+    readonly requestBody: Schema.OptionFromOptional<typeof OperationRequestBody>;
+    readonly inputSchema: Schema.OptionFromOptional<Schema.Unknown>;
+    readonly outputSchema: Schema.OptionFromOptional<Schema.Unknown>;
+    readonly deprecated: Schema.Boolean;
+}>, {}>;
 export declare class ExtractedOperation extends ExtractedOperation_base {
 }
-declare const ServerInfo_base: Schema.Class<ServerInfo, {
-    url: typeof Schema.String;
-    variables: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    url: typeof Schema.String;
-    variables: Schema.optionalWith<Schema.Record$<typeof Schema.String, typeof Schema.String>, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly url: string;
-} & {
-    readonly variables: import("effect/Option").Option<{
-        readonly [x: string]: string;
-    }>;
-}, {}, {}>;
+declare const ServerVariable_base: Schema.Class<ServerVariable, Schema.Struct<{
+    readonly default: Schema.String;
+    readonly enum: Schema.OptionFromOptional<Schema.$Array<Schema.String>>;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+}>, {}>;
+export declare class ServerVariable extends ServerVariable_base {
+}
+declare const ServerInfo_base: Schema.Class<ServerInfo, Schema.Struct<{
+    readonly url: Schema.String;
+    readonly description: Schema.OptionFromOptional<Schema.String>;
+    readonly variables: Schema.OptionFromOptional<Schema.$Record<Schema.String, typeof ServerVariable>>;
+}>, {}>;
 export declare class ServerInfo extends ServerInfo_base {
 }
-declare const ExtractionResult_base: Schema.Class<ExtractionResult, {
-    title: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    servers: Schema.Array$<typeof ServerInfo>;
-    operations: Schema.Array$<typeof ExtractedOperation>;
-}, Schema.Struct.Encoded<{
-    title: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    version: Schema.optionalWith<typeof Schema.String, {
-        as: "Option";
-    }>;
-    servers: Schema.Array$<typeof ServerInfo>;
-    operations: Schema.Array$<typeof ExtractedOperation>;
-}>, never, {
-    readonly title: import("effect/Option").Option<string>;
-} & {
-    readonly servers: readonly ServerInfo[];
-} & {
-    readonly version: import("effect/Option").Option<string>;
-} & {
-    readonly operations: readonly ExtractedOperation[];
-}, {}, {}>;
+declare const ExtractionResult_base: Schema.Class<ExtractionResult, Schema.Struct<{
+    readonly title: Schema.OptionFromOptional<Schema.String>;
+    readonly version: Schema.OptionFromOptional<Schema.String>;
+    readonly servers: Schema.$Array<typeof ServerInfo>;
+    readonly operations: Schema.$Array<typeof ExtractedOperation>;
+}>, {}>;
 export declare class ExtractionResult extends ExtractionResult_base {
 }
-declare const OperationBinding_base: Schema.Class<OperationBinding, {
-    method: Schema.Literal<["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
-    pathTemplate: typeof Schema.String;
-    parameters: Schema.Array$<typeof OperationParameter>;
-    requestBody: Schema.optionalWith<typeof OperationRequestBody, {
-        as: "Option";
-    }>;
-}, Schema.Struct.Encoded<{
-    method: Schema.Literal<["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
-    pathTemplate: typeof Schema.String;
-    parameters: Schema.Array$<typeof OperationParameter>;
-    requestBody: Schema.optionalWith<typeof OperationRequestBody, {
-        as: "Option";
-    }>;
-}>, never, {
-    readonly parameters: readonly OperationParameter[];
-} & {
-    readonly requestBody: import("effect/Option").Option<OperationRequestBody>;
-} & {
-    readonly method: "delete" | "get" | "put" | "post" | "options" | "head" | "patch" | "trace";
-} & {
-    readonly pathTemplate: string;
-}, {}, {}>;
+declare const OperationBinding_base: Schema.Class<OperationBinding, Schema.Struct<{
+    readonly method: Schema.Literals<readonly ["get", "put", "post", "delete", "patch", "head", "options", "trace"]>;
+    readonly pathTemplate: Schema.String;
+    readonly parameters: Schema.$Array<typeof OperationParameter>;
+    readonly requestBody: Schema.OptionFromOptional<typeof OperationRequestBody>;
+}>, {}>;
 export declare class OperationBinding extends OperationBinding_base {
 }
 /**
  * A header value — either a static string or a reference to a secret.
  * Stored as JSON-serializable data.
  */
-export declare const HeaderValue: Schema.Union<[typeof Schema.String, Schema.Struct<{
-    secretId: typeof Schema.String;
-    prefix: Schema.optional<typeof Schema.String>;
+export declare const HeaderValue: Schema.Union<readonly [Schema.String, Schema.Struct<{
+    readonly secretId: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
 }>]>;
 export type HeaderValue = typeof HeaderValue.Type;
-declare const InvocationConfig_base: Schema.Class<InvocationConfig, {
-    baseUrl: typeof Schema.String;
-    /** Headers applied to every request. Values can reference secrets. */
-    headers: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Struct<{
-        secretId: typeof Schema.String;
-        prefix: Schema.optional<typeof Schema.String>;
-    }>]>>, {
-        default: () => {};
-    }>;
-}, Schema.Struct.Encoded<{
-    baseUrl: typeof Schema.String;
+declare const ConfiguredHeaderBinding_base: Schema.Class<ConfiguredHeaderBinding, Schema.Struct<{
+    readonly kind: Schema.Literal<"binding">;
+    readonly slot: Schema.String;
+    readonly prefix: Schema.optional<Schema.String>;
+}>, {}>;
+export declare class ConfiguredHeaderBinding extends ConfiguredHeaderBinding_base {
+}
+export declare const ConfiguredHeaderValue: Schema.Union<readonly [Schema.String, typeof ConfiguredHeaderBinding]>;
+export type ConfiguredHeaderValue = typeof ConfiguredHeaderValue.Type;
+export declare const OpenApiSourceBindingValue: 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;
+}>]>;
+export type OpenApiSourceBindingValue = typeof OpenApiSourceBindingValue.Type;
+export declare const OpenApiSourceBindingInputSchema: 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;
+    }>]>;
+}>;
+declare const OpenApiSourceBindingInput_base: Schema.Class<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">;
+    }>, 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 declare class OpenApiSourceBindingInput extends OpenApiSourceBindingInput_base {
+}
+declare const OpenApiSourceBindingRef_base: Schema.Class<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">;
+    }>, 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 declare class OpenApiSourceBindingRef extends OpenApiSourceBindingRef_base {
+}
+export declare const OAuth2Flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
+export type OAuth2Flow = typeof OAuth2Flow.Type;
+declare const OAuth2Auth_base: Schema.Class<OAuth2Auth, Schema.Struct<{
+    readonly kind: Schema.Literal<"oauth2">;
+    /** Id of the Connection that owns this sign-in. Points at the core
+     *  `connection` table; resolve via `ctx.connections.get(id)` or
+     *  `ctx.connections.accessToken(id)`. Updated when the user signs in
+     *  again from the source detail UI (a fresh connection is minted and
+     *  this pointer is rewritten). */
+    readonly connectionId: Schema.String;
+    /** Key into `components.securitySchemes` this auth came from. Kept here
+     *  so a spec with multiple OAuth2 schemes can wire each one to its own
+     *  connection. */
+    readonly securitySchemeName: Schema.String;
+    /** OAuth2 grant type used for this source. Determines which flow the
+     *  sign-in button runs (authorizationCode opens a browser popup;
+     *  clientCredentials is server-to-server). */
+    readonly flow: Schema.Literals<readonly ["authorizationCode", "clientCredentials"]>;
+    /** Absolute token endpoint URL. */
+    readonly tokenUrl: Schema.String;
+    /** Absolute authorization endpoint URL. Only used for authorizationCode
+     *  flows; clientCredentials has no user consent step. */
+    readonly authorizationUrl: Schema.NullOr<Schema.String>;
+    /** Expected issuer for ID token validation. Defaults to authorization origin. */
+    readonly issuerUrl: Schema.optional<Schema.NullOr<Schema.String>>;
+    /** Secret id holding the OAuth client_id. */
+    readonly clientIdSecretId: Schema.String;
+    /** Secret id holding the OAuth client_secret. Optional for public
+     *  clients (PKCE-only authorizationCode). */
+    readonly clientSecretSecretId: Schema.NullOr<Schema.String>;
+    /** OAuth scopes requested on sign-in. Stored as a static list so the
+     *  sign-in button can re-request the same capabilities without having
+     *  to re-derive them from the OpenAPI spec. */
+    readonly scopes: Schema.$Array<Schema.String>;
+}>, {}>;
+export declare class OAuth2Auth extends OAuth2Auth_base {
+}
+declare const OAuth2SourceConfig_base: Schema.Class<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 declare class OAuth2SourceConfig extends OAuth2SourceConfig_base {
+}
+declare const InvocationConfig_base: Schema.Class<InvocationConfig, Schema.Struct<{
+    readonly baseUrl: Schema.String;
     /** Headers applied to every request. Values can reference secrets. */
-    headers: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Struct<{
-        secretId: typeof Schema.String;
-        prefix: Schema.optional<typeof Schema.String>;
-    }>]>>, {
-        default: () => {};
-    }>;
-}>, never, {
-    readonly headers?: {
-        readonly [x: string]: string | {
-            readonly secretId: string;
-            readonly prefix?: string | undefined;
-        };
-    } | undefined;
-} & {
-    readonly baseUrl: string;
-}, {}, {}>;
+    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>;
+    }>]>>>;
+    /**
+     * Optional OAuth2 auth — if set, the invoker resolves/refreshes the
+     * access token and injects `Authorization: Bearer <token>` on every
+     * request. Coexists with `headers` but wins for the Authorization header.
+     */
+    readonly oauth2: Schema.OptionFromOptional<typeof OAuth2Auth>;
+}>, {}>;
 export declare class InvocationConfig extends InvocationConfig_base {
 }
-declare const InvocationResult_base: Schema.Class<InvocationResult, {
-    status: typeof Schema.Number;
-    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
-    data: Schema.NullOr<typeof Schema.Unknown>;
-    error: Schema.NullOr<typeof Schema.Unknown>;
-}, Schema.Struct.Encoded<{
-    status: typeof Schema.Number;
-    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
-    data: Schema.NullOr<typeof Schema.Unknown>;
-    error: Schema.NullOr<typeof Schema.Unknown>;
-}>, never, {
-    readonly data: unknown;
-} & {
-    readonly error: unknown;
-} & {
-    readonly status: number;
-} & {
-    readonly headers: {
-        readonly [x: string]: string;
-    };
-}, {}, {}>;
+declare const InvocationResult_base: Schema.Class<InvocationResult, Schema.Struct<{
+    readonly status: Schema.Number;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly data: Schema.NullOr<Schema.Unknown>;
+    readonly error: Schema.NullOr<Schema.Unknown>;
+}>, {}>;
 export declare class InvocationResult extends InvocationResult_base {
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executor-js/plugin-openapi",
-  "version": "0.0.1-beta.6",
+  "version": "0.0.2",
   "homepage": "https://github.com/RhysSullivan/executor/tree/main/packages/plugins/openapi",
   "bugs": {
     "url": "https://github.com/RhysSullivan/executor/issues"
@@ -40,31 +40,26 @@
     "typecheck:slow": "bunx tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@apidevtools/swagger-parser": "^12.1.0",
-    "@effect/platform": "^0.96.0",
-    "@effect/platform-node": "^0.106.0",
-    "@executor/config": "1.4.3-beta.0",
-    "@executor-js/sdk": "0.0.1-beta.6",
-    "effect": "^3.21.0",
+    "@effect/platform-node": "4.0.0-beta.59",
+    "@executor-js/config": "0.0.2",
+    "@executor-js/sdk": "0.0.2",
+    "effect": "4.0.0-beta.59",
     "openapi-types": "^12.1.3",
     "yaml": "^2.7.1"
   },
   "devDependencies": {
-    "@effect-atom/atom-react": "^0.5.0",
-    "@effect/vitest": "^0.29.0",
-    "@executor/api": "1.4.3-beta.0",
-    "@executor/react": "1.4.3-beta.0",
+    "@effect/atom-react": "4.0.0-beta.59",
+    "@effect/vitest": "4.0.0-beta.59",
+    "@executor-js/storage-core": "0.0.2",
     "@types/node": "^24.3.1",
     "@types/react": "^19.1.0",
     "bun-types": "^1.2.22",
     "react": "^19.1.0",
     "tsup": "^8.5.0",
-    "vitest": "^4.1.3"
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "@effect-atom/atom-react": "^0.5.0",
-    "@executor/api": "1.4.3-beta.0",
-    "@executor/react": "1.4.3-beta.0",
+    "@effect/atom-react": "4.0.0-beta.59",
     "@tanstack/react-router": "^1.168.10",
     "react": "^19.1.0"
   },
@@ -72,17 +67,11 @@
     "react": {
       "optional": true
     },
-    "@effect-atom/atom-react": {
+    "@effect/atom-react": {
       "optional": true
     },
     "@tanstack/react-router": {
       "optional": true
-    },
-    "@executor/api": {
-      "optional": true
-    },
-    "@executor/react": {
-      "optional": true
     }
   }
 }