@fungi.computer/forage 0.0.0-stage → 0.0.2

package/dist/describe.js

@@ -0,0 +1,66 @@
+import { describeOutputSchema, maximumDescriptionTypes, } from "./schemas.js";
+import { compareCodeUnits } from "./normalization.js";
+import { renderNamespaceIndex, renderOperationTypes } from "./rendering.js";
+import { ForageError } from "./errors.js";
+function boundedDescription(value) {
+    return value && value.length > 0 ? value : undefined;
+}
+function checkedDescription(output) {
+    const parsed = describeOutputSchema.safeParse(output);
+    if (!parsed.success) {
+        throw new ForageError("invalid_input", "Description output exceeded its bounds");
+    }
+    return parsed.data;
+}
+/** Pure deterministic description of an operation or its namespace. */
+export function describeCatalog(operations, rawInput) {
+    const operation = operations.find((candidate) => candidate.path === rawInput.path);
+    if (operation) {
+        const callPath = `env.${operation.path}`;
+        const output = {
+            path: operation.path,
+            description: boundedDescription(operation.description),
+            types: renderOperationTypes([operation.rendered]),
+            kind: "operation",
+            inputSchema: operation.inputSchema,
+            usage: `await ${callPath}({ ... })`,
+        };
+        if (output.types.length > maximumDescriptionTypes) {
+            throw new ForageError("invalid_input", "Description types exceed the bounded output");
+        }
+        return checkedDescription(output);
+    }
+    const prefix = `${rawInput.path}.`;
+    const namespaceOperations = operations
+        .filter((candidate) => candidate.path.startsWith(prefix))
+        .sort((left, right) => compareCodeUnits(left.path, right.path));
+    if (namespaceOperations.length === 0) {
+        throw new ForageError("unknown_target", `Unknown target: ${rawInput.path}`);
+    }
+    const first = namespaceOperations[0];
+    if (!first) {
+        throw new ForageError("unknown_target", `Unknown target: ${rawInput.path}`);
+    }
+    const selected = rawInput.methods?.length
+        ? namespaceOperations.filter((candidate) => rawInput.methods?.includes(candidate.path.slice(prefix.length)))
+        : namespaceOperations;
+    let types;
+    if (rawInput.detail === "index") {
+        types = renderNamespaceIndex(namespaceOperations.map((operation) => operation.rendered));
+    }
+    else if (rawInput.methods?.length && selected.length === 0) {
+        types = renderNamespaceIndex(namespaceOperations.map((operation) => operation.rendered));
+    }
+    else {
+        types = renderOperationTypes((selected.length > 0 ? selected : namespaceOperations).map((operation) => operation.rendered));
+    }
+    if (types.length > maximumDescriptionTypes) {
+        throw new ForageError("invalid_input", "Description types exceed the bounded output");
+    }
+    return checkedDescription({
+        path: rawInput.path,
+        description: boundedDescription(first.instructions),
+        types,
+        kind: "module",
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+import type { ForageFailure } from "./schemas.js";
+/** A bounded, machine-readable failure at a Forage public seam. */
+export declare class ForageError extends Error {
+    readonly code: ForageFailure["code"];
+    readonly failure: ForageFailure;
+    constructor(code: ForageFailure["code"], message: string, options?: ErrorOptions);
+}

package/dist/errors.js

@@ -0,0 +1,12 @@
+/** A bounded, machine-readable failure at a Forage public seam. */
+export class ForageError extends Error {
+    code;
+    failure;
+    constructor(code, message, options) {
+        const boundedMessage = message.slice(0, 1000);
+        super(boundedMessage, options);
+        this.name = "ForageError";
+        this.code = code;
+        this.failure = { code, message: boundedMessage };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export { catalogInputSchema, describeOutputSchema, forageDescribeInput, forageFailureSchema, forageSearchInput, operationSchema, searchOutputSchema, searchResultSchema, forageListInput, listOutputSchema, } from "./schemas.js";
+export type { CatalogInput, DescribeOutput, ForageDescribeInput, ForageFailure, ForageSearchInput, JsonSchemaSource, JsonSchemaTarget, Operation, SearchOutput, SearchResult, ForageListInput, ListOutput, } from "./schemas.js";
+export type { ForageDefinition } from "./definitions.js";
+export { ForageError } from "./errors.js";
+export { createCatalog } from "./catalog.js";
+export { appApiOperations, appMethodSchemas, appToolSchemas, appToolFamilySchemas, jsonSchemaToZod, } from "./app-api.js";
+export { listOperations } from "./list.js";
+export type { ForageCatalog } from "./catalog.js";
+export { forageDescribeDefinition, forageSearchDefinition, forageListDefinition, } from "./definitions.js";
+import { createCatalog } from "./catalog.js";
+import { forageDescribeDefinition, forageSearchDefinition, forageListDefinition } from "./definitions.js";
+/** Public convenience namespace contract. */
+export type ForageApi = {
+    /** Construct one immutable catalog revision. */
+    createCatalog: typeof createCatalog;
+    /** Structural search operation definition. */
+    forageSearchDefinition: typeof forageSearchDefinition;
+    /** Structural description operation definition. */
+    forageDescribeDefinition: typeof forageDescribeDefinition;
+    /** Structural exhaustive listing definition. */
+    forageListDefinition: typeof forageListDefinition;
+};
+/** Narrow convenience namespace for the package's public seams. */
+export declare const Forage: ForageApi;
+export default Forage;

package/dist/index.js

@@ -0,0 +1,16 @@
+export { catalogInputSchema, describeOutputSchema, forageDescribeInput, forageFailureSchema, forageSearchInput, operationSchema, searchOutputSchema, searchResultSchema, forageListInput, listOutputSchema, } from "./schemas.js";
+export { ForageError } from "./errors.js";
+export { createCatalog } from "./catalog.js";
+export { appApiOperations, appMethodSchemas, appToolSchemas, appToolFamilySchemas, jsonSchemaToZod, } from "./app-api.js";
+export { listOperations } from "./list.js";
+export { forageDescribeDefinition, forageSearchDefinition, forageListDefinition, } from "./definitions.js";
+import { createCatalog } from "./catalog.js";
+import { forageDescribeDefinition, forageSearchDefinition, forageListDefinition, } from "./definitions.js";
+/** Narrow convenience namespace for the package's public seams. */
+export const Forage = Object.freeze({
+    createCatalog,
+    forageSearchDefinition,
+    forageDescribeDefinition,
+    forageListDefinition,
+});
+export default Forage;

package/dist/json-schema-boundary.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod";
+export declare const schemaDepthLimit = 32;
+export declare const schemaNodeLimit = 50000;
+export declare const isUnsafeSchemaPropertyName: (name: string) => boolean;
+export declare const parameterName: z.ZodString;
+export declare const thirdPartyText: (limit: number) => z.core.$ZodBranded<z.ZodString, "ThirdPartyText", "out">;
+export declare const jsonSchemaContainer: z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+export declare function jsonSchemaValueInspection(budget?: {
+    nodes: number;
+}): z.ZodPipe<z.ZodUnknown, z.ZodTransform<"nodes_limit" | "depth_limit" | "unsafe_name" | null, unknown>>;

package/dist/json-schema-boundary.js

@@ -0,0 +1,56 @@
+import * as z from "zod";
+export const schemaDepthLimit = 32;
+export const schemaNodeLimit = 50_000;
+const unsafePropertyNames = new Set(["__proto__", "constructor", "prototype"]);
+export const isUnsafeSchemaPropertyName = (name) => unsafePropertyNames.has(name);
+export const parameterName = z
+    .string()
+    .min(1)
+    .max(128)
+    .refine((name) => !unsafePropertyNames.has(name));
+export const thirdPartyText = (limit) => z.string().max(limit).brand();
+// Maintained decoding of one container level avoids expanding ref-parser's DAG
+// or recursively decoding remote JSON before the domain budget is checked.
+export const jsonSchemaContainer = z.union([
+    z.array(z.unknown()),
+    z.record(z.string(), z.unknown()),
+]);
+export function jsonSchemaValueInspection(budget = { nodes: 0 }) {
+    return z
+        .unknown()
+        .transform((source) => {
+        const pending = [
+            { value: source, depth: 0, field: "" },
+        ];
+        while (pending.length) {
+            const next = pending.pop();
+            if (!next)
+                break;
+            if (++budget.nodes > schemaNodeLimit)
+                return "nodes_limit";
+            if (next.depth > schemaDepthLimit)
+                return "depth_limit";
+            const decoded = jsonSchemaContainer.safeParse(next.value);
+            if (!decoded.success) {
+                if (["name", "required"].includes(next.field) &&
+                    isUnsafeSchemaPropertyName(z.string().safeParse(next.value).data ?? ""))
+                    return "unsafe_name";
+                continue;
+            }
+            // Zod records discard __proto__: inspect the original keys before consuming
+            // their decoded children, including keys in const/enum/default/example data.
+            if (Object.getOwnPropertyNames(next.value).some(isUnsafeSchemaPropertyName))
+                return "unsafe_name";
+            for (const [field, child] of Object.entries(decoded.data)) {
+                if (pending.length + budget.nodes >= schemaNodeLimit)
+                    return "nodes_limit";
+                pending.push({
+                    value: child,
+                    depth: next.depth + 1,
+                    field: Array.isArray(decoded.data) ? next.field : field,
+                });
+            }
+        }
+        return null;
+    });
+}

package/dist/json-schema-subset.d.ts

@@ -0,0 +1,6 @@
+import * as z from "zod";
+/** Decode the supported schema subset before using the shared Zod compiler.
+ * Refuse depth over 32, more than 50,000 expanded nodes and reserved keys
+ * before recursive decoding. Callers bound transport bytes separately.
+ */
+export declare function jsonSchemaSubset(allowNullable?: boolean): z.ZodPipe<z.ZodUnknown, z.ZodType<boolean | Record<string, z.core.util.JSONType>, unknown, z.core.$ZodTypeInternals<boolean | Record<string, z.core.util.JSONType>, unknown>>>;

package/dist/json-schema-subset.js

@@ -0,0 +1,77 @@
+import * as z from "zod";
+import { jsonSchemaValueInspection, parameterName, thirdPartyText, } from "./json-schema-boundary.js";
+const jsonSchema = z.union([z.record(z.string(), z.json()), z.boolean()]);
+/** Decode the supported schema subset before using the shared Zod compiler.
+ * Refuse depth over 32, more than 50,000 expanded nodes and reserved keys
+ * before recursive decoding. Callers bound transport bytes separately.
+ */
+export function jsonSchemaSubset(allowNullable = false) {
+    const schema = z.lazy(() => {
+        const objectSchema = z.strictObject({
+            $schema: z.string().optional(),
+            title: thirdPartyText(200).optional(),
+            description: thirdPartyText(2048).optional(),
+            type: z
+                .union([
+                z.enum([
+                    "null",
+                    "boolean",
+                    "object",
+                    "array",
+                    "number",
+                    "integer",
+                    "string",
+                ]),
+                z.array(z.enum([
+                    "null",
+                    "boolean",
+                    "object",
+                    "array",
+                    "number",
+                    "integer",
+                    "string",
+                ])),
+            ])
+                .optional(),
+            enum: z.array(z.json()).min(1).optional(),
+            const: z.json().optional(),
+            properties: z.record(parameterName, schema).optional(),
+            required: z.array(parameterName).optional(),
+            additionalProperties: schema.optional(),
+            propertyNames: schema.optional(),
+            items: schema.optional(),
+            prefixItems: z.array(schema).optional(),
+            minItems: z.number().int().nonnegative().optional(),
+            maxItems: z.number().int().nonnegative().optional(),
+            uniqueItems: z.literal(false).optional(),
+            minLength: z.number().int().nonnegative().optional(),
+            maxLength: z.number().int().nonnegative().optional(),
+            minimum: z.number().optional(),
+            maximum: z.number().optional(),
+            exclusiveMinimum: z.union([z.number(), z.boolean()]).optional(),
+            exclusiveMaximum: z.union([z.number(), z.boolean()]).optional(),
+            multipleOf: z.number().positive().optional(),
+            allOf: z.array(schema).optional(),
+            anyOf: z.array(schema).optional(),
+            oneOf: z.array(schema).optional(),
+            readOnly: z.boolean().optional(),
+            writeOnly: z.boolean().optional(),
+            default: z.json().optional(),
+            example: z.json().optional(),
+            examples: z.array(z.json()).optional(),
+            deprecated: z.boolean().optional(),
+        });
+        const versioned = allowNullable
+            ? objectSchema.extend({ nullable: z.boolean().optional() })
+            : objectSchema;
+        return z.union([z.boolean(), versioned]).pipe(jsonSchema);
+    });
+    return z
+        .unknown()
+        .superRefine((value, context) => {
+        const refusal = jsonSchemaValueInspection().parse(value);
+        if (refusal)
+            context.addIssue({ code: "custom", message: refusal });
+    })
+        .pipe(schema);
+}

package/dist/list.d.ts

@@ -0,0 +1,8 @@
+import { type ForageListInput, type ListOutput, type SearchResult } from "./schemas.js";
+/**
+ * Page a trusted immutable operation-summary view. Hosts may filter the existing
+ * catalog to their bound operations before paging; this is the one cursor owner.
+ * Order is namespace then full path, compared by UTF-16 code units, never locale.
+ * Unlike search, no equivalent operations are merged into peers.
+ */
+export declare function listOperations(operations: readonly SearchResult[], catalogStamp: string, rawInput: ForageListInput): ListOutput;

package/dist/list.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { ForageError } from "./errors.js";
+import { compareCodeUnits, operationNamespace } from "./normalization.js";
+import { forageListInput, listOutputSchema, searchResultSchema, } from "./schemas.js";
+const cursorSchema = z.strictObject({
+    catalogStamp: listOutputSchema.shape.catalogStamp,
+    namespace: forageListInput.shape.namespace.unwrap().nullable(),
+    after: searchResultSchema.shape.path,
+});
+/**
+ * Page a trusted immutable operation-summary view. Hosts may filter the existing
+ * catalog to their bound operations before paging; this is the one cursor owner.
+ * Order is namespace then full path, compared by UTF-16 code units, never locale.
+ * Unlike search, no equivalent operations are merged into peers.
+ */
+export function listOperations(operations, catalogStamp, rawInput) {
+    const parsed = forageListInput.safeParse(rawInput);
+    if (!parsed.success)
+        throw new ForageError("invalid_input", parsed.error.message);
+    const input = parsed.data;
+    const namespace = input.namespace ?? null;
+    const sorted = operations
+        .filter((operation) => namespace === null || operation.path.startsWith(`${namespace}.`))
+        .sort((a, b) => compareCodeUnits(operationNamespace(a.path), operationNamespace(b.path)) || compareCodeUnits(a.path, b.path));
+    let start = 0;
+    if (input.cursor !== undefined) {
+        let cursor;
+        try {
+            cursor = cursorSchema.parse(JSON.parse(input.cursor));
+        }
+        catch (cause) {
+            throw new ForageError("invalid_input", "Invalid listing cursor", {
+                cause,
+            });
+        }
+        if (cursor.catalogStamp !== catalogStamp || cursor.namespace !== namespace)
+            throw new ForageError("invalid_input", "Listing cursor belongs to a different catalog or namespace");
+        const index = sorted.findIndex((operation) => operation.path === cursor.after);
+        if (index < 0)
+            throw new ForageError("invalid_input", "Listing cursor operation is absent from this view");
+        start = index + 1;
+    }
+    const results = sorted.slice(start, start + input.limit);
+    const last = results.at(-1);
+    return listOutputSchema.parse({
+        results,
+        total: sorted.length,
+        catalogStamp,
+        nextCursor: start + results.length < sorted.length && last !== undefined
+            ? JSON.stringify({ catalogStamp, namespace, after: last.path })
+            : null,
+    });
+}

package/dist/normalization.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { Operation } from "./schemas.js";
+export declare const jsonValueSchema: z.ZodJSONSchema;
+export type JsonValue = z.output<typeof jsonValueSchema>;
+/** A JSON object level within an already-parsed {@link JsonValue}. */
+export type JsonObject = Readonly<Record<string, JsonValue>>;
+/**
+ * Narrow an already-parsed JSON value to its object case. The value was
+ * validated once at its boundary, so each nested level is told apart by its
+ * shape here instead of re-validating the whole subtree at every level, which
+ * made walking a large schema quadratic.
+ */
+export declare function isJsonObject(value: JsonValue): value is JsonObject;
+export declare function compareCodeUnits(left: string, right: string): number;
+export declare function normalizeQuery(query: string): string;
+export declare function tokenize(text: string): string[];
+export declare function isStopword(token: string): boolean;
+export declare function stemVariants(token: string): string[];
+export declare function canonicalStringify(value: JsonValue): string;
+export declare function hashString64(value: string): string;
+export declare function operationMethod(path: Operation["path"]): string;
+export declare function operationNamespace(path: Operation["path"]): string;

package/dist/normalization.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+export const jsonValueSchema = z.json();
+const jsonPrimitiveSchema = z.union([z.string(), z.number(), z.boolean()]);
+/**
+ * Narrow an already-parsed JSON value to its object case. The value was
+ * validated once at its boundary, so each nested level is told apart by its
+ * shape here instead of re-validating the whole subtree at every level, which
+ * made walking a large schema quadratic.
+ */
+export function isJsonObject(value) {
+    return (value !== null &&
+        !Array.isArray(value) &&
+        !jsonPrimitiveSchema.safeParse(value).success);
+}
+export function compareCodeUnits(left, right) {
+    if (left === right)
+        return 0;
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = left.charCodeAt(index) - right.charCodeAt(index);
+        if (difference !== 0)
+            return difference;
+    }
+    return left.length - right.length;
+}
+export function normalizeQuery(query) {
+    return query
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .replace(/[_./:-]/g, " ")
+        .toLowerCase()
+        .trim();
+}
+export function tokenize(text) {
+    return text.split(/[^a-zA-Z0-9]+/).filter((token) => token.length > 0);
+}
+const stopwords = new Set([
+    "the",
+    "a",
+    "an",
+    "for",
+    "to",
+    "of",
+    "that",
+    "this",
+    "with",
+    "in",
+    "on",
+]);
+export function isStopword(token) {
+    return stopwords.has(token);
+}
+export function stemVariants(token) {
+    const variants = [];
+    const add = (variant) => {
+        if (variant !== token &&
+            variant.length >= 3 &&
+            !variants.includes(variant)) {
+            variants.push(variant);
+        }
+    };
+    if (token.endsWith("ing") && token.length > 4)
+        add(token.slice(0, -3));
+    if (token.endsWith("ed") && token.length > 3)
+        add(token.slice(0, -2));
+    if (token.endsWith("ies") && token.length > 4) {
+        add(token.slice(0, -3));
+        add(`${token.slice(0, -3)}y`);
+    }
+    if (token.endsWith("es") && token.length > 3)
+        add(token.slice(0, -2));
+    if (token.endsWith("s") && !token.endsWith("ss") && token.length > 3) {
+        add(token.slice(0, -1));
+    }
+    return variants;
+}
+export function canonicalStringify(value) {
+    if (value === null)
+        return "null";
+    const primitive = jsonPrimitiveSchema.safeParse(value);
+    if (primitive.success) {
+        return JSON.stringify(primitive.data);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => canonicalStringify(item)).join(",")}]`;
+    }
+    if (!isJsonObject(value))
+        return "null";
+    const entries = Object.entries(value).sort(([left], [right]) => compareCodeUnits(left, right));
+    return `{${entries
+        .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalStringify(entry)}`)
+        .join(",")}}`;
+}
+export function hashString64(value) {
+    let hash = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    const mask = (1n << 64n) - 1n;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= BigInt(value.charCodeAt(index));
+        hash = (hash * prime) & mask;
+    }
+    return hash.toString(16).padStart(16, "0");
+}
+export function operationMethod(path) {
+    return path.slice(path.indexOf(".") + 1);
+}
+export function operationNamespace(path) {
+    return path.slice(0, path.indexOf("."));
+}

package/dist/openapi.d.ts

@@ -0,0 +1,106 @@
+import * as z from "zod";
+/** Bounded provider-authored text. Hosts must frame it as data, never instructions. */
+export type OpenApiThirdPartyText = string & z.BRAND<"ThirdPartyText">;
+/** Optional owner-declared credential parameter excluded from guest input. */
+export type OpenApiIntakeOptions = {
+    authParameter?: {
+        in: "header" | "query";
+        name: string;
+    };
+};
+/** Stable intake and per-operation refusal codes. */
+export type OpenApiRefusalCode = "too_large" | "invalid_spec" | "not_openapi3" | "nodes_limit" | "depth_limit" | "alias_limit" | "external_reference" | "recursive_schema" | "operations_limit" | "invalid_operation" | "unsupported_schema" | "parameter_collision" | "unsafe_auth_parameter" | "unsafe_header" | "unsupported_parameter" | "unsupported_media" | "unsupported_path_item" | "unsupported_method" | "table_too_large" | "invalid_table" | "unsafe_name" | "unsafe_path";
+/** A bounded intake refusal, distinct from a listed unsupported operation. */
+export declare class OpenApiError extends Error {
+    readonly code: OpenApiRefusalCode;
+    readonly name = "OpenApiError";
+    constructor(code: OpenApiRefusalCode, message: string, cause?: unknown);
+}
+/** One stored operation, independent of spec-host URLs or credentials. */
+export declare const openApiOperationSchema: z.ZodObject<{
+    status: z.ZodLiteral<"supported">;
+    name: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    effect: z.ZodEnum<{
+        write: "write";
+        read: "read";
+    }>;
+    description: z.core.$ZodBranded<z.ZodString, "ThirdPartyText", "out">;
+    textSource: z.ZodLiteral<"third_party">;
+    tags: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ThirdPartyText", "out">>;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        in: z.ZodEnum<{
+            header: "header";
+            path: "path";
+            query: "query";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        schema: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodJSONSchema>, z.ZodBoolean]>;
+        style: z.ZodOptional<z.ZodString>;
+        explode: z.ZodOptional<z.ZodBoolean>;
+        allowReserved: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    input: z.ZodPipe<z.ZodUnknown, z.ZodType<boolean | Record<string, z.core.util.JSONType>, unknown, z.core.$ZodTypeInternals<boolean | Record<string, z.core.util.JSONType>, unknown>>>;
+    output: z.ZodPipe<z.ZodUnknown, z.ZodType<boolean | Record<string, z.core.util.JSONType>, unknown, z.core.$ZodTypeInternals<boolean | Record<string, z.core.util.JSONType>, unknown>>>;
+}, z.core.$strict>;
+/** Decoded normalized operation ready for selection, not an execution grant. */
+export type OpenApiOperation = z.output<typeof openApiOperationSchema>;
+/** An operation's supported call shape or bounded unsupported reason. */
+export type OpenApiPreviewOperation = OpenApiOperation | {
+    status: "unsupported";
+    name: string;
+    method: string;
+    path: string;
+    reason: OpenApiRefusalCode;
+};
+/** Pure intake: the host supplies bounded spec text, never a fetch locator. */
+export declare function normalizeOpenApi(source: string, options?: OpenApiIntakeOptions): Promise<{
+    title: string & z.core.$brand<"ThirdPartyText">;
+    version: string;
+    servers: string[];
+    authHints: ({
+        scheme: string;
+        kind: "api_key_header" | "api_key_query";
+        name: string;
+    } | {
+        scheme: string;
+        kind: "bearer" | "oauth" | "unsupported";
+    })[];
+    operations: OpenApiPreviewOperation[];
+    tableDigest: string;
+}>;
+/** Decode selected operations before persistence or execution; no authority is granted. */
+export declare function parseOpenApiTable(source: unknown): Promise<{
+    operations: {
+        status: "supported";
+        name: string;
+        method: "GET" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH" | "DELETE";
+        path: string;
+        effect: "write" | "read";
+        description: string & z.core.$brand<"ThirdPartyText">;
+        textSource: "third_party";
+        tags: (string & z.core.$brand<"ThirdPartyText">)[];
+        parameters: {
+            name: string;
+            in: "header" | "path" | "query";
+            required: boolean;
+            schema: boolean | Record<string, z.core.util.JSONType>;
+            style?: string | undefined;
+            explode?: boolean | undefined;
+            allowReserved?: boolean | undefined;
+        }[];
+        input: boolean | Record<string, z.core.util.JSONType>;
+        output: boolean | Record<string, z.core.util.JSONType>;
+    }[];
+    digest: string;
+}>;