@opencode-ai/codemode 0.0.0-beta-17492

package/dist/interpreter/scope.d.ts

@@ -0,0 +1,15 @@
+import { type AstNode, type Binding } from "./model.js";
+export declare class ScopeStack {
+    private readonly scopes;
+    constructor(scopes: Array<Map<string, Binding>>);
+    reserve(name: string, mutable: boolean, node: AstNode): void;
+    initialize(name: string, value: unknown, node: AstNode): void;
+    declare(name: string, value: unknown, mutable: boolean, node: AstNode): void;
+    get(name: string, node: AstNode): unknown;
+    set(name: string, value: unknown, node: AstNode): unknown;
+    resolve(name: string): Binding | undefined;
+    current(): Map<string, Binding>;
+    push(scope?: Map<string, Binding>): void;
+    pop(): void;
+    capture(): Array<Map<string, Binding>>;
+}

package/dist/interpreter/scope.js

@@ -0,0 +1,79 @@
+import { InterpreterRuntimeError } from "./model.js";
+export class ScopeStack {
+    scopes;
+    constructor(scopes) {
+        this.scopes = scopes;
+    }
+    reserve(name, mutable, node) {
+        const scope = this.current();
+        if (scope.has(name)) {
+            throw new InterpreterRuntimeError(`Identifier '${name}' has already been declared.`, node);
+        }
+        scope.set(name, { mutable, value: undefined, initialized: false });
+    }
+    initialize(name, value, node) {
+        const binding = this.current().get(name);
+        if (!binding || binding.initialized !== false) {
+            throw new InterpreterRuntimeError(`Identifier '${name}' has not been reserved for initialization.`, node);
+        }
+        binding.value = value;
+        binding.initialized = true;
+    }
+    declare(name, value, mutable, node) {
+        const scope = this.current();
+        if (scope.has(name)) {
+            throw new InterpreterRuntimeError(`Identifier '${name}' has already been declared.`, node);
+        }
+        scope.set(name, { mutable, value, initialized: true });
+    }
+    get(name, node) {
+        const binding = this.resolve(name);
+        if (!binding) {
+            throw new InterpreterRuntimeError(`Unknown identifier '${name}'.`, node).as("ReferenceError");
+        }
+        if (binding.initialized === false) {
+            throw new InterpreterRuntimeError(`Cannot access '${name}' before initialization.`, node).as("ReferenceError");
+        }
+        return binding.value;
+    }
+    set(name, value, node) {
+        const binding = this.resolve(name);
+        if (!binding) {
+            throw new InterpreterRuntimeError(`Unknown identifier '${name}'.`, node).as("ReferenceError");
+        }
+        if (binding.initialized === false) {
+            throw new InterpreterRuntimeError(`Cannot access '${name}' before initialization.`, node).as("ReferenceError");
+        }
+        if (!binding.mutable) {
+            throw new InterpreterRuntimeError(`Cannot assign to constant '${name}'.`, node).as("TypeError");
+        }
+        binding.value = value;
+        return value;
+    }
+    resolve(name) {
+        for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
+            const scope = this.scopes[index];
+            const binding = scope?.get(name);
+            if (binding) {
+                return binding;
+            }
+        }
+        return undefined;
+    }
+    current() {
+        const scope = this.scopes[this.scopes.length - 1];
+        if (!scope) {
+            throw new InterpreterRuntimeError("Interpreter scope stack is empty.");
+        }
+        return scope;
+    }
+    push(scope = new Map()) {
+        this.scopes.push(scope);
+    }
+    pop() {
+        this.scopes.pop();
+    }
+    capture() {
+        return this.scopes.slice();
+    }
+}

package/dist/interpreter/transpile.node.d.ts

@@ -0,0 +1,5 @@
+export interface TranspileResult {
+    readonly outputText: string;
+    readonly error?: string;
+}
+export declare const transpile: (source: string) => TranspileResult;

package/dist/interpreter/transpile.node.js

@@ -0,0 +1,19 @@
+import { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } from "typescript";
+// Full TypeScript transpilation on node/bun runtimes.
+export const transpile = (source) => {
+    const transpiled = transpileModule(source, {
+        reportDiagnostics: true,
+        compilerOptions: {
+            target: ScriptTarget.ESNext,
+            module: ModuleKind.ESNext,
+        },
+    });
+    const diagnostic = transpiled.diagnostics?.find((item) => item.category === DiagnosticCategory.Error);
+    if (diagnostic) {
+        return {
+            outputText: transpiled.outputText,
+            error: flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+        };
+    }
+    return { outputText: transpiled.outputText };
+};

package/dist/interpreter/transpile.workerd.d.ts

@@ -0,0 +1,5 @@
+export interface TranspileResult {
+    readonly outputText: string;
+    readonly error?: string;
+}
+export declare const transpile: (source: string) => TranspileResult;

package/dist/interpreter/transpile.workerd.js

@@ -0,0 +1,6 @@
+// workerd profile: the typescript compiler is ~11 MiB and probes node
+// internals at module init, so codemode programs are passed through
+// untranspiled. Plain-JS programs (the overwhelmingly common case) parse
+// fine downstream via acorn; TypeScript-only syntax surfaces as a parse
+// error from the interpreter instead of a transpile diagnostic.
+export const transpile = (source) => ({ outputText: source });

package/dist/openapi/index.d.ts

@@ -0,0 +1,7 @@
+import type { Options, Result } from "./types.js";
+export type { AuthResolver, Credential, Document, Operation, Options, Result, SecurityScheme, Skipped, Tools, } from "./types.js";
+/**
+ * Builds one CodeMode tool per representable OpenAPI 3.x operation. Auth remains host-side,
+ * tools require `HttpClient.HttpClient`, and unrepresentable operations land in `skipped`.
+ */
+export declare const fromSpec: (options: Options) => Result;

package/dist/openapi/index.js

@@ -0,0 +1,101 @@
+import { HttpClient } from "effect/unstable/http";
+import { make } from "../tool.js";
+import { invoke } from "./runtime.js";
+import { componentDefinitions, hasDirectionalSchemas, inputSchema, isRecord, methods, nonEmptyString, operationInput, operationOutput, operationPath, operationSecurityRequirements, securityRequirements, securitySchemes, specServerUrl, validateBaseUrl, } from "./spec.js";
+/**
+ * Builds one CodeMode tool per representable OpenAPI 3.x operation. Auth remains host-side,
+ * tools require `HttpClient.HttpClient`, and unrepresentable operations land in `skipped`.
+ */
+export const fromSpec = (options) => {
+    const document = options.spec;
+    const schemes = securitySchemes(document);
+    const defaultSecurity = securityRequirements(document.security);
+    const requestDefinitions = componentDefinitions(document, "request");
+    const responseDefinitions = hasDirectionalSchemas(document)
+        ? componentDefinitions(document, "response")
+        : requestDefinitions;
+    const paths = isRecord(document.paths) ? document.paths : {};
+    const used = new Set();
+    const namespaces = new Set();
+    const skipped = [];
+    const tools = Object.create(null);
+    for (const [path, pathValue] of Object.entries(paths)) {
+        if (!isRecord(pathValue))
+            continue;
+        for (const [method, operationValue] of Object.entries(pathValue)) {
+            if (!methods.has(method) || !isRecord(operationValue))
+                continue;
+            const segments = operationPath(method, path, operationValue, used, namespaces);
+            const operation = {
+                operationId: nonEmptyString(operationValue.operationId),
+                method: method.toUpperCase(),
+                path,
+                summary: nonEmptyString(operationValue.summary),
+                description: nonEmptyString(operationValue.description),
+            };
+            const output = operationOutput(document, operationValue, responseDefinitions);
+            if (!output.ok) {
+                skipped.push({ method: operation.method, path, reason: output.reason });
+                continue;
+            }
+            const resolvedBaseUrl = (() => {
+                if (options.baseUrl !== undefined)
+                    return validateBaseUrl(options.baseUrl);
+                if (operationValue.servers !== undefined)
+                    return specServerUrl(operationValue);
+                if (pathValue.servers !== undefined)
+                    return specServerUrl(pathValue);
+                return specServerUrl(document);
+            })();
+            if (!resolvedBaseUrl.ok) {
+                skipped.push({ method: operation.method, path, reason: resolvedBaseUrl.reason });
+                continue;
+            }
+            const parsedInput = operationInput(document, pathValue, operationValue);
+            if (!parsedInput.ok) {
+                skipped.push({ method: operation.method, path, reason: parsedInput.reason });
+                continue;
+            }
+            const input = parsedInput.value;
+            const security = operationSecurityRequirements(operationValue.security, defaultSecurity, schemes);
+            if (!security.ok) {
+                skipped.push({ method: operation.method, path, reason: security.reason });
+                continue;
+            }
+            const plan = {
+                operation,
+                url: `${resolvedBaseUrl.value.replace(/\/+$/, "")}${path}`,
+                fields: input.fields,
+                body: input.body,
+                security: security.value,
+                schemes,
+                auth: options.auth,
+                headers: options.headers ?? {},
+            };
+            used.add(segments.join("."));
+            for (const index of segments.slice(0, -1).keys())
+                namespaces.add(segments.slice(0, index + 1).join("."));
+            setTool(tools, segments, make({
+                description: operation.description ?? operation.summary ?? `${operation.method} ${path}`,
+                input: inputSchema(input.fields, requestDefinitions),
+                output: output.value,
+                execute: (input) => invoke(plan, input),
+            }));
+        }
+    }
+    return { tools, skipped };
+};
+const setTool = (tools, path, tool) => {
+    const [head, ...rest] = path;
+    if (head === undefined)
+        return;
+    if (rest.length === 0) {
+        tools[head] = tool;
+        return;
+    }
+    const child = tools[head];
+    if (child === undefined || !isRecord(child) || child._tag === "CodeModeTool") {
+        tools[head] = Object.create(null);
+    }
+    setTool(tools[head], rest, tool);
+};

package/dist/openapi/runtime.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import type { Plan } from "./types.js";
+export declare const invoke: (plan: Plan, input: unknown) => Effect.Effect<unknown, unknown, HttpClient.HttpClient>;

package/dist/openapi/runtime.js

@@ -0,0 +1,283 @@
+import { Effect, Option, Schema, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { ToolError, toolError } from "../tool-error.js";
+import { isRecord, own } from "./spec.js";
+const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+const maxErrorBodyChars = 1_024;
+const maxResponseBodyBytes = 50 * 1024 * 1024;
+export const invoke = (plan, input) => Effect.gen(function* () {
+    const value = isRecord(input) ? input : {};
+    let request = yield* buildRequest(plan, value);
+    const auth = yield* resolveAuth(plan);
+    for (const [name, item] of Object.entries(auth.query)) {
+        request = HttpClientRequest.setUrlParam(request, name, item);
+    }
+    request = HttpClientRequest.setHeaders(request, auth.headers);
+    const client = yield* HttpClient.HttpClient;
+    const response = yield* client
+        .execute(request)
+        .pipe(Effect.catch((cause) => Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} failed: transport error`, cause))));
+    const text = yield* readResponseBody(response, plan);
+    const mediaType = response.headers["content-type"]?.split(";")[0]?.trim().toLowerCase();
+    const json = mediaType === "application/json" || mediaType?.endsWith("+json") === true;
+    const decoded = text === "" ? Option.some(null) : json ? decodeJson(text) : Option.none();
+    const parsed = json ? Option.getOrElse(decoded, () => text) : text === "" ? null : text;
+    if (response.status < 200 || response.status >= 300) {
+        const rendered = typeof parsed === "string" ? parsed : (JSON.stringify(parsed) ?? "");
+        const summary = rendered === "" || rendered === "null"
+            ? "no response body"
+            : rendered.length > maxErrorBodyChars
+                ? `${rendered.slice(0, maxErrorBodyChars)}...`
+                : rendered;
+        return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} failed with HTTP ${response.status}: ${summary}`));
+    }
+    if (json && Option.isNone(decoded)) {
+        return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} returned malformed JSON.`));
+    }
+    return parsed;
+});
+const buildRequest = (plan, input) => Effect.gen(function* () {
+    // Validate model input before auth resolution can refresh credentials.
+    const url = buildUrl(plan, input);
+    if (url instanceof ToolError)
+        return yield* Effect.fail(url);
+    const missing = plan.fields.find((field) => field.required && field.location !== "path" && own(input, field.inputName) === undefined);
+    if (missing !== undefined) {
+        const label = missing.location === "body" ? "body field" : `${missing.location} parameter`;
+        return yield* Effect.fail(toolError(`Missing required ${label} '${missing.inputName}'.`));
+    }
+    let request = HttpClientRequest.make(plan.operation.method)(url);
+    const query = [];
+    for (const field of plan.fields) {
+        if (field.location !== "query")
+            continue;
+        const item = own(input, field.inputName);
+        if (item === undefined)
+            continue;
+        const serialized = serializeQuery(field, item);
+        if (serialized instanceof ToolError)
+            return yield* Effect.fail(serialized);
+        for (const parameter of serialized)
+            query.push(parameter);
+    }
+    if (query.length > 0)
+        request = HttpClientRequest.appendUrlParams(request, query);
+    request = HttpClientRequest.setHeaders(request, plan.headers);
+    for (const field of plan.fields) {
+        if (field.location !== "header")
+            continue;
+        const item = own(input, field.inputName);
+        if (item === undefined)
+            continue;
+        const serialized = serializeSimple(field, item, String);
+        if (serialized instanceof ToolError)
+            return yield* Effect.fail(serialized);
+        request = HttpClientRequest.setHeader(request, field.name, serialized);
+    }
+    const setBody = (value, mediaType) => HttpClientRequest.bodyJson(request, value).pipe(Effect.map((next) => HttpClientRequest.setHeader(next, "content-type", mediaType)), Effect.mapError((cause) => toolError(`Invalid JSON body for ${plan.operation.method} ${plan.operation.path}.`, cause)));
+    if (plan.body?.mode === "value") {
+        const field = plan.fields.find((field) => field.location === "body");
+        const body = field === undefined ? undefined : own(input, field.inputName);
+        if (body !== undefined)
+            request = yield* setBody(body, plan.body.mediaType);
+    }
+    if (plan.body?.mode === "object") {
+        const entries = plan.fields.flatMap((field) => {
+            if (field.location !== "body")
+                return [];
+            const item = own(input, field.inputName);
+            return item === undefined ? [] : [[field.name, item]];
+        });
+        if (plan.body.required || entries.length > 0) {
+            request = yield* setBody(Object.fromEntries(entries), plan.body.mediaType);
+        }
+    }
+    return request;
+});
+const resolveAuth = (plan) => Effect.gen(function* () {
+    const none = { headers: {}, query: {} };
+    if (plan.security.length === 0)
+        return none;
+    const unavailable = [];
+    alternatives: for (const requirement of plan.security) {
+        const names = Object.keys(requirement);
+        if (names.length === 0)
+            return none;
+        const credentials = [];
+        for (const name of names) {
+            const scheme = own(plan.schemes, name);
+            if (scheme === undefined || plan.auth === undefined) {
+                unavailable.push(name);
+                continue alternatives;
+            }
+            const credential = yield* plan.auth.resolve({
+                name,
+                definition: scheme,
+                scopes: requirement[name] ?? [],
+                operation: plan.operation,
+            });
+            if (credential === undefined) {
+                unavailable.push(name);
+                continue alternatives;
+            }
+            credentials.push([name, scheme, credential]);
+        }
+        const applied = applyCredentials(credentials);
+        return applied instanceof ToolError ? yield* Effect.fail(applied) : applied;
+    }
+    return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} requires authentication; no credential available for: ${[...new Set(unavailable)].join(", ")}.`));
+});
+const applyCredentials = (credentials) => {
+    const headers = new Map();
+    const query = new Map();
+    const add = (carrier, name, value) => {
+        const target = carrier === "header" ? headers : query;
+        if (target.has(name))
+            return toolError(`Authentication resolves multiple credentials for ${carrier} '${name}'.`);
+        target.set(name, value);
+    };
+    for (const [name, definition, credential] of credentials) {
+        if (credential.type === "bearer") {
+            const duplicate = add("header", "authorization", `Bearer ${credential.token}`);
+            if (duplicate !== undefined)
+                return duplicate;
+            continue;
+        }
+        if (credential.type === "basic") {
+            // Basic auth credentials are UTF-8; btoa rejects non-Latin-1 input.
+            const duplicate = add("header", "authorization", `Basic ${Buffer.from(`${credential.username}:${credential.password}`, "utf8").toString("base64")}`);
+            if (duplicate !== undefined)
+                return duplicate;
+            continue;
+        }
+        if (credential.type === "header") {
+            const duplicate = add("header", credential.name.toLowerCase(), credential.value);
+            if (duplicate !== undefined)
+                return duplicate;
+            continue;
+        }
+        if (definition.type !== "apiKey") {
+            return toolError(`Security scheme '${name}' is not an apiKey scheme; resolve a bearer, basic, or header credential for it.`);
+        }
+        if (definition.in === "cookie")
+            return toolError(`Cookie authentication '${name}' is not supported.`);
+        const parameter = definition.in === "header" ? definition.name.toLowerCase() : definition.name;
+        const duplicate = add(definition.in, parameter, credential.value);
+        if (duplicate !== undefined)
+            return duplicate;
+    }
+    return { headers: Object.fromEntries(headers), query: Object.fromEntries(query) };
+};
+const buildUrl = (plan, input) => {
+    let url = plan.url;
+    for (const field of plan.fields) {
+        if (field.location !== "path")
+            continue;
+        const item = own(input, field.inputName);
+        if (item === undefined) {
+            return toolError(`Missing required path parameter '${field.inputName}'.`);
+        }
+        const fieldValue = serializeSimple(field, item, (value) => encodeURIComponent(value).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`));
+        if (fieldValue instanceof ToolError)
+            return fieldValue;
+        // URL normalization collapses encoded `.` and `..`, which could retarget the request.
+        if (fieldValue === "" || fieldValue === "." || fieldValue === "..") {
+            return toolError(`Invalid path parameter '${field.inputName}'.`);
+        }
+        url = url.replaceAll(`{${field.name}}`, fieldValue);
+    }
+    const unresolved = url.match(/\{[^{}]+\}/);
+    if (unresolved !== null)
+        return toolError(`Unresolved path parameter ${unresolved[0]}.`);
+    return url;
+};
+const serializeSimple = (field, value, encode) => {
+    const scalar = (item) => item !== null && typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean"
+        ? toolError(`Parameter '${field.inputName}' contains an unsupported nested value.`)
+        : encode(String(item));
+    if (Array.isArray(value)) {
+        const items = value.map(scalar);
+        const invalid = items.find((item) => item instanceof ToolError);
+        return invalid ?? items.join(",");
+    }
+    if (!isRecord(value))
+        return scalar(value);
+    const entries = Object.entries(value).flatMap(([name, item]) => {
+        const rendered = scalar(item);
+        if (rendered instanceof ToolError)
+            return [rendered];
+        return field.explode ? [`${encode(name)}=${rendered}`] : [encode(name), rendered];
+    });
+    const invalid = entries.find((item) => item instanceof ToolError);
+    return invalid ?? entries.join(",");
+};
+const serializeQuery = (field, value) => {
+    if (field.style === "deepObject") {
+        if (!isRecord(value))
+            return toolError(`Deep-object parameter '${field.inputName}' must be an object.`);
+        const parameters = [];
+        for (const [name, item] of Object.entries(value)) {
+            if (item === undefined || (item !== null && typeof item === "object")) {
+                return toolError(`Deep-object parameter '${field.inputName}' contains an unsupported nested value.`);
+            }
+            parameters.push([`${field.name}[${name}]`, String(item)]);
+        }
+        return parameters;
+    }
+    if (Array.isArray(value)) {
+        if (!field.explode) {
+            const rendered = serializeSimple(field, value, String);
+            return rendered instanceof ToolError ? rendered : [[field.name, rendered]];
+        }
+        const parameters = [];
+        for (const item of value) {
+            if (item !== null && typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean") {
+                return toolError(`Parameter '${field.inputName}' contains an unsupported nested value.`);
+            }
+            parameters.push([field.name, String(item)]);
+        }
+        return parameters;
+    }
+    if (isRecord(value) && field.explode) {
+        const parameters = [];
+        for (const [name, item] of Object.entries(value)) {
+            if (item === undefined || (item !== null && typeof item === "object")) {
+                return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`);
+            }
+            parameters.push([name, String(item)]);
+        }
+        return parameters;
+    }
+    const rendered = serializeSimple(field, value, String);
+    return rendered instanceof ToolError ? rendered : [[field.name, rendered]];
+};
+const readResponseBody = (response, plan) => Effect.gen(function* () {
+    const contentLength = response.headers["content-length"];
+    const parsedSize = contentLength === undefined ? undefined : Number.parseInt(contentLength, 10);
+    const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined;
+    if (declaredSize !== undefined && declaredSize > maxResponseBodyBytes) {
+        return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`));
+    }
+    let body = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, declaredSize ?? 64 * 1024));
+    let size = 0;
+    yield* Stream.runForEach(response.stream, (chunk) => {
+        if (size + chunk.byteLength > maxResponseBodyBytes) {
+            return Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`));
+        }
+        if (size + chunk.byteLength > body.byteLength) {
+            const grown = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)));
+            body.copy(grown, 0, 0, size);
+            body = grown;
+        }
+        body.set(chunk, size);
+        size += chunk.byteLength;
+        return Effect.void;
+    }).pipe(Effect.catch((cause) => {
+        if (cause instanceof ToolError)
+            return Effect.fail(cause);
+        if (cause.reason._tag === "EmptyBodyError")
+            return Effect.void;
+        return Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} failed while reading the response body.`, cause));
+    }));
+    return new TextDecoder().decode(body.subarray(0, size));
+});

package/dist/openapi/spec.d.ts

@@ -0,0 +1,20 @@
+import type { JsonSchema } from "../tool.js";
+import type { Document, InputField, OperationInput, Parsed, SecurityRequirement, SecurityScheme } from "./types.js";
+export declare const methods: Set<string>;
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const nonEmptyString: (value: unknown) => string | undefined;
+export declare const own: <T>(record: Readonly<Record<string, T>>, key: string) => T | undefined;
+export declare const resolve: (document: Document, value: unknown) => unknown;
+type SchemaDirection = "request" | "response";
+export declare const hasDirectionalSchemas: (document: Document) => boolean;
+export declare const componentDefinitions: (document: Document, direction: SchemaDirection) => Readonly<Record<string, JsonSchema>>;
+export declare const operationInput: (document: Document, pathItem: Record<string, unknown>, operation: Record<string, unknown>) => Parsed<OperationInput>;
+export declare const inputSchema: (fields: ReadonlyArray<InputField>, definitions: Readonly<Record<string, JsonSchema>>) => JsonSchema;
+export declare const operationOutput: (document: Document, operation: Record<string, unknown>, definitions: Readonly<Record<string, JsonSchema>>) => Parsed<JsonSchema | undefined>;
+export declare const operationPath: (method: string, path: string, operation: Record<string, unknown>, used: ReadonlySet<string>, namespaces: ReadonlySet<string>) => ReadonlyArray<string>;
+export declare const specServerUrl: (source: Record<string, unknown>) => Parsed<string>;
+export declare const validateBaseUrl: (value: string) => Parsed<string>;
+export declare const securityRequirements: (value: unknown) => Parsed<ReadonlyArray<SecurityRequirement>>;
+export declare const operationSecurityRequirements: (value: unknown, defaults: Parsed<ReadonlyArray<SecurityRequirement>>, schemes: Readonly<Record<string, SecurityScheme>>) => Parsed<ReadonlyArray<SecurityRequirement>>;
+export declare const securitySchemes: (document: Document) => Readonly<Record<string, SecurityScheme>>;
+export {};