@wirebench/engine 2.2.0 → 3.1.0-rc.1

package/dist/asyncapi/update.js

@@ -0,0 +1,220 @@
+/**
+ * Update Definition for an AsyncAPI-imported WebSocket API: a per-operation report of what a new
+ * version of the document changes, and applying it without losing anything the user made.
+ *
+ * The rule is the one gRPC and WSDL keep: **nothing is ever deleted.** A channel the document no
+ * longer has keeps its request, flagged `orphaned`; one that came back has the flag cleared. A value
+ * the mapping generated (URL, query, headers, subprotocols, a message sample, the API's URL and auth)
+ * follows the contract only while it still equals what the old contract generated; an edited one is
+ * kept, and for a message the new sample is added beside it as `<name> (updated)`.
+ *
+ * Pure: it compares through {@link mapAsyncApi}'s output and writes nothing.
+ */
+import { uniqueSlug } from '../project/paths.js';
+import { createWsFolder, wsApiRequests, } from '../ws/model.js';
+import { mapAsyncApi } from './map.js';
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function opRef(op) {
+    return { key: op.key, channel: op.channel, direction: op.direction };
+}
+function channelServers(doc, channel) {
+    if (channel === undefined)
+        return [];
+    return channel.servers === 'all'
+        ? [...doc.servers]
+        : doc.servers.filter((s) => channel.servers.includes(s.key));
+}
+function reasonsFor(old, next, a, b) {
+    const ca = old.channels.find((c) => c.key === a.channel);
+    const cb = next.channels.find((c) => c.key === b.channel);
+    const reasons = [];
+    if (!same(ca?.address, cb?.address) || !same(ca?.parameters, cb?.parameters)) {
+        reasons.push('address');
+    }
+    const keysA = a.messages.map((m) => m.key);
+    const keysB = b.messages.map((m) => m.key);
+    const payloadChanged = a.messages.some((m) => {
+        const n = b.messages.find((x) => x.key === m.key);
+        return n !== undefined && !same(m, n);
+    });
+    if (payloadChanged)
+        reasons.push('payload');
+    if (!same(ca?.bindings, cb?.bindings))
+        reasons.push('bindings');
+    const security = (doc, c) => channelServers(doc, c).map((s) => [s.key, s.security]);
+    if (!same(security(old, ca), security(next, cb)))
+        reasons.push('security');
+    if (a.direction !== b.direction || !same(keysA, keysB))
+        reasons.push('messages');
+    return reasons;
+}
+/** Operations added, removed and changed between two versions, keyed by operation id. */
+export function planAsyncApiUpdate(old, next) {
+    const oldOps = new Map(old.operations.map((o) => [o.key, o]));
+    const nextOps = new Map(next.operations.map((o) => [o.key, o]));
+    // Requests are linked by channel, so an operation that moved to another channel key is, as applying
+    // sees it, removed from the old channel's request and added to the new one's — not an address change.
+    const sameChannel = (a, b) => a !== undefined && b !== undefined && a.channel === b.channel;
+    const added = next.operations.filter((o) => !sameChannel(oldOps.get(o.key), o)).map(opRef);
+    const removed = old.operations.filter((o) => !sameChannel(o, nextOps.get(o.key))).map(opRef);
+    const changed = [];
+    for (const b of next.operations) {
+        const a = oldOps.get(b.key);
+        if (a === undefined || !sameChannel(a, b))
+            continue;
+        const reasons = reasonsFor(old, next, a, b);
+        if (reasons.length > 0)
+            changed.push({ op: opRef(b), reasons });
+    }
+    return { added, removed, changed };
+}
+const GENERATED = ['url', 'query', 'headers', 'subprotocols'];
+function byChannel(api) {
+    const map = new Map();
+    for (const r of wsApiRequests(api))
+        if (r.contract !== undefined)
+            map.set(r.contract.channel, r);
+    return map;
+}
+/** The folder a mapped request sits in (the mapping makes one level, by tag), or undefined at the root. */
+function folderOf(api, id) {
+    return api.folders.find((f) => f.requests.some((r) => r.id === id))?.name;
+}
+/**
+ * Applies `next` to an API imported from `old`. Never deletes a request or a saved message.
+ */
+export function applyAsyncApiUpdate(api, old, next, options = {}) {
+    const mapOptions = options.server !== undefined ? { server: options.server } : {};
+    // The old mapping's ids are never kept: only its generated values are compared.
+    const oldMapped = mapAsyncApi(old, { ...mapOptions, newId: () => 'old' }).api;
+    const nextMapped = mapAsyncApi(next, {
+        ...mapOptions,
+        ...(options.newId !== undefined ? { newId: options.newId } : {}),
+    }).api;
+    const oldReqs = byChannel(oldMapped);
+    const nextReqs = byChannel(nextMapped);
+    const requestsOrphaned = [];
+    const requestsRestored = [];
+    const requestsRewritten = [];
+    const messagesReplaced = [];
+    const messagesAdded = [];
+    const update = (req) => {
+        const channel = req.contract?.channel;
+        if (channel === undefined)
+            return req;
+        const target = nextReqs.get(channel);
+        if (target === undefined) {
+            if (req.orphaned === true)
+                return req;
+            requestsOrphaned.push(req.id);
+            return { ...req, orphaned: true };
+        }
+        let out = req;
+        if (req.orphaned === true) {
+            requestsRestored.push(req.id);
+            const { orphaned, ...rest } = req;
+            void orphaned;
+            out = rest;
+        }
+        const before = oldReqs.get(channel);
+        let rewritten = false;
+        for (const field of GENERATED) {
+            if (before !== undefined && same(out[field], before[field]) && !same(out[field], target[field])) {
+                out = { ...out, [field]: target[field] };
+                rewritten = true;
+            }
+        }
+        if (rewritten)
+            requestsRewritten.push(req.id);
+        const messages = [...out.messages];
+        let touched = false;
+        const slugs = new Set(messages.map((m) => m.slug));
+        for (const sample of target.messages) {
+            const key = sample.contract.message;
+            const generated = sample.contract.generated;
+            const linked = messages.filter((m) => m.contract?.message === key);
+            if (linked.length === 0) {
+                const slug = uniqueSlug(sample.name, slugs);
+                slugs.add(slug);
+                messages.push({ ...sample, slug });
+                messagesAdded.push(sample.id);
+                touched = true;
+                continue;
+            }
+            if (linked.some((m) => m.content === generated))
+                continue;
+            const untouched = linked.filter((m) => m.content === m.contract.generated);
+            if (untouched.length > 0) {
+                for (const m of untouched) {
+                    messages[messages.indexOf(m)] = { ...m, content: generated, contract: { message: key, generated } };
+                    messagesReplaced.push(m.id);
+                }
+                touched = true;
+                continue;
+            }
+            const name = `${sample.name} (updated)`;
+            const slug = uniqueSlug(name, slugs);
+            slugs.add(slug);
+            messages.push({ ...sample, name, slug });
+            messagesAdded.push(sample.id);
+            touched = true;
+        }
+        return touched ? { ...out, messages } : out;
+    };
+    const updateFolder = (f) => ({
+        ...f,
+        folders: f.folders.map(updateFolder),
+        requests: f.requests.map(update),
+    });
+    let result = { ...api, folders: api.folders.map(updateFolder), requests: api.requests.map(update) };
+    // Channels the API has no request for yet: into the folder their tag names, else the root.
+    const have = byChannel(result);
+    const requestsAdded = [];
+    const all = wsApiRequests(result);
+    let order = all.reduce((n, r) => Math.max(n, r.order + 1), 0);
+    for (const [channel, fresh] of nextReqs) {
+        if (have.has(channel))
+            continue;
+        const folderName = folderOf(nextMapped, fresh.id);
+        const siblings = folderName === undefined ? result.requests : (result.folders.find((f) => f.name === folderName)?.requests ?? []);
+        const slug = uniqueSlug(fresh.name, new Set(siblings.map((r) => r.slug)));
+        const req = { ...fresh, slug, order: order++ };
+        requestsAdded.push(req.id);
+        messagesAdded.push(...req.messages.map((m) => m.id));
+        if (folderName === undefined) {
+            result = { ...result, requests: [...result.requests, req] };
+        }
+        else if (result.folders.some((f) => f.name === folderName)) {
+            result = {
+                ...result,
+                folders: result.folders.map((f) => (f.name === folderName ? { ...f, requests: [...f.requests, req] } : f)),
+            };
+        }
+        else {
+            const folderSlug = uniqueSlug(folderName, new Set(result.folders.map((f) => f.slug)));
+            const folder = createWsFolder(folderName, {
+                ...(options.newId !== undefined ? { newId: options.newId } : {}),
+                slug: folderSlug,
+                order: result.folders.length,
+                requests: [req],
+            });
+            result = { ...result, folders: [...result.folders, folder] };
+        }
+    }
+    if (same(result.url, oldMapped.url) && !same(result.url, nextMapped.url))
+        result = { ...result, url: nextMapped.url };
+    if (same(result.auth, oldMapped.auth) && !same(result.auth, nextMapped.auth)) {
+        const { auth, ...rest } = result;
+        void auth;
+        result = nextMapped.auth !== undefined ? { ...rest, auth: nextMapped.auth } : rest;
+    }
+    return {
+        api: result,
+        requestsAdded,
+        requestsOrphaned,
+        requestsRestored,
+        requestsRewritten,
+        messagesReplaced,
+        messagesAdded,
+    };
+}

package/dist/errors.d.ts

@@ -49,6 +49,14 @@ export declare class WorkspaceError extends WirebenchError {
 export declare class OpenApiError extends WirebenchError {
     constructor(code: string, message: string, options?: WirebenchErrorOptions);
 }
+/**
+ * Thrown when an AsyncAPI document cannot be read at all: `asyncapi-malformed` (not JSON/YAML, or
+ * not a document with an `asyncapi` version) or `asyncapi-version-unsupported` (a version other
+ * than 2.x or 3.0). Anything parseable but unmappable is a note on the document, not this.
+ */
+export declare class AsyncApiError extends WirebenchError {
+    constructor(code: string, message: string, options?: WirebenchErrorOptions);
+}
 /** Thrown when a Postman collection cannot be read, or is structurally invalid. */
 export declare class PostmanError extends WirebenchError {
     constructor(code: string, message: string, options?: WirebenchErrorOptions);
@@ -73,5 +81,13 @@ export declare class WsError extends WirebenchError {
 export declare class ValidationError extends WirebenchError {
     constructor(code: string, message: string, options?: WirebenchErrorOptions);
 }
+/**
+ * Thrown when a sequence step would put a value taken from a response somewhere ADR-0015 forbids:
+ * the origin of a URL or target (`sequence-origin-from-response`), or a line break or NUL into a
+ * URL, header or metadata (`sequence-value-invalid`).
+ */
+export declare class SequenceError extends WirebenchError {
+    constructor(code: string, message: string, options?: WirebenchErrorOptions);
+}
 /** Type guard identifying any {@link WirebenchError} (base class or subclass). */
 export declare function isWirebenchError(e: unknown): e is WirebenchError;

package/dist/errors.js

@@ -73,6 +73,17 @@ export class OpenApiError extends WirebenchError {
         this.name = 'OpenApiError';
     }
 }
+/**
+ * Thrown when an AsyncAPI document cannot be read at all: `asyncapi-malformed` (not JSON/YAML, or
+ * not a document with an `asyncapi` version) or `asyncapi-version-unsupported` (a version other
+ * than 2.x or 3.0). Anything parseable but unmappable is a note on the document, not this.
+ */
+export class AsyncApiError extends WirebenchError {
+    constructor(code, message, options) {
+        super(code, message, options);
+        this.name = 'AsyncApiError';
+    }
+}
 /** Thrown when a Postman collection cannot be read, or is structurally invalid. */
 export class PostmanError extends WirebenchError {
     constructor(code, message, options) {
@@ -115,6 +126,17 @@ export class ValidationError extends WirebenchError {
         this.name = 'ValidationError';
     }
 }
+/**
+ * Thrown when a sequence step would put a value taken from a response somewhere ADR-0015 forbids:
+ * the origin of a URL or target (`sequence-origin-from-response`), or a line break or NUL into a
+ * URL, header or metadata (`sequence-value-invalid`).
+ */
+export class SequenceError extends WirebenchError {
+    constructor(code, message, options) {
+        super(code, message, options);
+        this.name = 'SequenceError';
+    }
+}
 /** Type guard identifying any {@link WirebenchError} (base class or subclass). */
 export function isWirebenchError(e) {
     return e instanceof WirebenchError;

package/dist/grpc/events.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What a gRPC call reports while it runs (spec §3.2): the request side opening for pushes, the
+ * initial metadata, each response message decoded, and the request side half-closed.
+ */
+import type { GrpcResponseMessage } from './call.js';
+export type GrpcLiveEvent = {
+    readonly protocol: 'grpc';
+    readonly kind: 'open';
+} | {
+    readonly protocol: 'grpc';
+    readonly kind: 'headers';
+    readonly httpStatus: number;
+    readonly headers: Readonly<Record<string, string>>;
+} | {
+    readonly protocol: 'grpc';
+    readonly kind: 'message';
+    readonly index: number;
+    readonly message: GrpcResponseMessage;
+} | {
+    readonly protocol: 'grpc';
+    readonly kind: 'closed';
+};

package/dist/grpc/events.js

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

package/dist/grpc/expand.d.ts

@@ -6,7 +6,7 @@
  * message alone, never to a header or the target.
  */
 import type { PropertyScopes, UnresolvedRef } from '../project/properties.js';
-import type { KeyValueEntry } from '../rest/model.js';
+import type { KeyValueEntry } from '../http/entries.js';
 /** The parts of a call that carry text a property can appear in. */
 export interface GrpcExpandable {
     readonly target: string;

package/dist/grpc/expand.js

@@ -6,25 +6,35 @@
  * message alone, never to a header or the target.
  */
 import { expand } from '../project/properties.js';
-import { escapeForLanguage } from '../rest/body.js';
+import { assertNoControlCharacters, assertOriginIndependent, expandWithSequenceEscaped, } from '../project/sequence-guards.js';
+import { escapeForLanguage } from '../http/escape.js';
 /** Expands every property reference in a call's target, metadata and message text. */
 export function expandGrpcInput(input, scopes, options = {}) {
     const unresolved = [];
-    const run = (text) => {
+    const run = (text, place) => {
         const result = expand(text, scopes);
         unresolved.push(...result.unresolved);
+        assertNoControlCharacters(place, result, scopes);
         return result.text;
     };
+    // The message is JSON. A Sequence value is JSON-escaped whether or not the request asks, because it
+    // came from a response and could otherwise add fields to the message (ADR-0015).
     const runMessage = (text) => {
         const result = expand(text, scopes);
         unresolved.push(...result.unresolved);
-        return options.escape === true ? expand(text, escapedScopes(scopes)).text : result.text;
+        return expandWithSequenceEscaped((s) => (options.escape === true ? expand(text, escapedScopes(s)) : expand(text, s)).text, scopes, (value) => escapeForLanguage(value, 'json'));
     };
+    // A target is nothing but where the call goes, so no part of it may come from a response.
+    assertOriginIndependent('The target', (s) => expand(input.target, s).text, scopes, (target) => target);
     return {
         input: {
             ...input,
-            target: run(input.target),
-            metadata: input.metadata.map((row) => ({ ...row, name: run(row.name), value: run(row.value) })),
+            target: run(input.target, 'The target'),
+            metadata: input.metadata.map((row) => ({
+                ...row,
+                name: run(row.name, 'A metadata key'),
+                value: run(row.value, `The ${row.name} metadata`),
+            })),
             messageText: runMessage(input.messageText),
         },
         unresolved,

package/dist/grpc/files.d.ts

@@ -0,0 +1,271 @@
+/**
+ * The gRPC files of a project folder: `apis/<slug>/api.yaml` with `kind: grpc`, and each
+ * `*.request.yaml` of its request tree (spec §3.2).
+ */
+import { z } from 'zod';
+/** The four shapes a gRPC method can take. */
+export declare const grpcMethodKindSchema: z.ZodEnum<{
+    unary: "unary";
+    "server-streaming": "server-streaming";
+    "client-streaming": "client-streaming";
+    "bidi-streaming": "bidi-streaming";
+}>;
+/**
+ * `apis/<slug>/requests/[<folder>/…]<name>.request.yaml` for a gRPC request. The message text lives
+ * in the sibling file `message` names, validated as a path segment before it is read (ADR-0005),
+ * so a JSON message is a JSON file in git like a REST raw body.
+ */
+export declare const grpcRequestFileSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"grpc">;
+    id: z.ZodString;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    service: z.ZodString;
+    method: z.ZodString;
+    methodKind: z.ZodDefault<z.ZodEnum<{
+        unary: "unary";
+        "server-streaming": "server-streaming";
+        "client-streaming": "client-streaming";
+        "bidi-streaming": "bidi-streaming";
+    }>>;
+    metadata: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    message: z.ZodOptional<z.ZodString>;
+    auth: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            basic: "basic";
+            ntlm: "ntlm";
+        }>;
+        username: z.ZodOptional<z.ZodString>;
+        passwordRef: z.ZodOptional<z.ZodString>;
+        passwordEnv: z.ZodOptional<z.ZodString>;
+        domain: z.ZodOptional<z.ZodString>;
+        workstation: z.ZodOptional<z.ZodString>;
+        preemptive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"inherit">;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"bearer">;
+        tokenRef: z.ZodOptional<z.ZodString>;
+        tokenEnv: z.ZodOptional<z.ZodString>;
+        scheme: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"api-key">;
+        name: z.ZodString;
+        valueRef: z.ZodOptional<z.ZodString>;
+        valueEnv: z.ZodOptional<z.ZodString>;
+        in: z.ZodEnum<{
+            header: "header";
+            query: "query";
+        }>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth2">;
+        grant: z.ZodEnum<{
+            "client-credentials": "client-credentials";
+            "authorization-code": "authorization-code";
+        }>;
+        tokenUrl: z.ZodString;
+        authorizationUrl: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodString;
+        clientSecretRef: z.ZodOptional<z.ZodString>;
+        clientSecretEnv: z.ZodOptional<z.ZodString>;
+        scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        audience: z.ZodOptional<z.ZodString>;
+        clientAuth: z.ZodDefault<z.ZodEnum<{
+            basic: "basic";
+            body: "body";
+        }>>;
+        pkce: z.ZodDefault<z.ZodBoolean>;
+        refreshTokenRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>]>>;
+    settings: z.ZodDefault<z.ZodObject<{
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        trustInvalid: z.ZodOptional<z.ZodBoolean>;
+        sslKeystoreRef: z.ZodOptional<z.ZodString>;
+        bindAddress: z.ZodOptional<z.ZodString>;
+        maxSizeBytes: z.ZodOptional<z.ZodNumber>;
+        escapeProperties: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    orphaned: z.ZodOptional<z.ZodBoolean>;
+    assertions: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"status">;
+        equals: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodNumber, z.ZodNumber, z.ZodString, z.ZodEnum<{
+            [x: string]: string;
+        }>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNumber, z.ZodString, z.ZodEnum<{
+            [x: string]: string;
+        }>]>>]>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"soap-fault">;
+        expect: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            present: "present";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"match">;
+        language: z.ZodEnum<{
+            xpath: "xpath";
+            xquery: "xquery";
+            jsonpath: "jsonpath";
+        }>;
+        expression: z.ZodString;
+        namespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        equals: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        matches: z.ZodOptional<z.ZodString>;
+        exists: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"schema">;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"sla">;
+        maxMs: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"callback">;
+        catchUrl: z.ZodString;
+        withinMs: z.ZodDefault<z.ZodNumber>;
+        match: z.ZodDefault<z.ZodObject<{
+            method: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            pathMatches: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                name: z.ZodString;
+            }, z.core.$loose>>>;
+            body: z.ZodOptional<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                language: z.ZodEnum<{
+                    xpath: "xpath";
+                    jsonpath: "jsonpath";
+                }>;
+                path: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        expect: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            body: z.ZodOptional<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                language: z.ZodEnum<{
+                    xpath: "xpath";
+                    jsonpath: "jsonpath";
+                }>;
+                path: z.ZodString;
+            }, z.core.$loose>>;
+            header: z.ZodOptional<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                matches: z.ZodOptional<z.ZodString>;
+                exists: z.ZodOptional<z.ZodBoolean>;
+                name: z.ZodString;
+            }, z.core.$loose>>;
+            signature: z.ZodOptional<z.ZodLiteral<"verified">>;
+        }, z.core.$loose>>>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "type">>>;
+    scripts: z.ZodOptional<z.ZodObject<{
+        pre: z.ZodOptional<z.ZodString>;
+        post: z.ZodOptional<z.ZodString>;
+        api: z.ZodDefault<z.ZodEnum<{
+            wirebench: "wirebench";
+            postman: "postman";
+        }>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        secrets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** `apis/<slug>/api.yaml` for a gRPC API. */
+export declare const grpcApiFileSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"grpc">;
+    id: z.ZodString;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    target: z.ZodString;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    auth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            basic: "basic";
+            ntlm: "ntlm";
+        }>;
+        username: z.ZodOptional<z.ZodString>;
+        passwordRef: z.ZodOptional<z.ZodString>;
+        passwordEnv: z.ZodOptional<z.ZodString>;
+        domain: z.ZodOptional<z.ZodString>;
+        workstation: z.ZodOptional<z.ZodString>;
+        preemptive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"inherit">;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"bearer">;
+        tokenRef: z.ZodOptional<z.ZodString>;
+        tokenEnv: z.ZodOptional<z.ZodString>;
+        scheme: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"api-key">;
+        name: z.ZodString;
+        valueRef: z.ZodOptional<z.ZodString>;
+        valueEnv: z.ZodOptional<z.ZodString>;
+        in: z.ZodEnum<{
+            header: "header";
+            query: "query";
+        }>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth2">;
+        grant: z.ZodEnum<{
+            "client-credentials": "client-credentials";
+            "authorization-code": "authorization-code";
+        }>;
+        tokenUrl: z.ZodString;
+        authorizationUrl: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodString;
+        clientSecretRef: z.ZodOptional<z.ZodString>;
+        clientSecretEnv: z.ZodOptional<z.ZodString>;
+        scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        audience: z.ZodOptional<z.ZodString>;
+        clientAuth: z.ZodDefault<z.ZodEnum<{
+            basic: "basic";
+            body: "body";
+        }>>;
+        pkce: z.ZodDefault<z.ZodBoolean>;
+        refreshTokenRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>]>>;
+    definition: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            proto: "proto";
+            reflection: "reflection";
+        }>>;
+        source: z.ZodString;
+        cache: z.ZodDefault<z.ZodBoolean>;
+        roots: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reflectionVersion: z.ZodOptional<z.ZodEnum<{
+            v1: "v1";
+            v1alpha: "v1alpha";
+            auto: "auto";
+        }>>;
+        trustInvalid: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** A gRPC `api.yaml` as parsed. */
+export type GrpcApiFile = z.infer<typeof grpcApiFileSchema>;
+/** A gRPC `*.request.yaml` as parsed. */
+export type GrpcRequestFile = z.infer<typeof grpcRequestFileSchema>;