pullfrog 0.1.29 → 0.1.31

package/dist/utils/github.d.ts

@@ -1,5 +1,10 @@
 import { throttling } from "@octokit/plugin-throttling";
 import { Octokit } from "@octokit/rest";
+/** GitHub Actions OIDC request credentials, stashed before env wipes */
+export interface OidcCredentials {
+    requestUrl: string;
+    requestToken: string;
+}
 export interface InstallationToken {
     token: string;
     expires_at: string;
@@ -35,9 +40,23 @@ type GitHubAppPermissions = {
     workflows?: WriteOnly;
 };
 type AcquireTokenOptions = {
-    repos?: string[];
+    repos?: string[] | undefined;
     permissions?: GitHubAppPermissions;
+    /**
+     * stashed OIDC credentials for minting after restricted mode deletes
+     * ACTIONS_ID_TOKEN_REQUEST_* from process.env (mid-run token refresh)
+     */
+    oidc?: OidcCredentials | undefined;
 };
+/**
+ * mint a GitHub Actions OIDC ID token from stashed credentials without
+ * touching process.env — `core.getIDToken` reads the env vars directly,
+ * which restricted mode has already deleted by the time a refresh runs.
+ * throws TokenExchangeError on HTTP errors and a "timed out" Error on
+ * timeout so `acquireNewToken`'s retry predicate treats 5xx/429/timeouts
+ * as transient.
+ */
+export declare function fetchIdTokenFromStash(creds: OidcCredentials): Promise<string>;
 /**
  * ensure a GitHub token is available in the environment.
  *
@@ -51,6 +70,13 @@ type AcquireTokenOptions = {
  * main() directly and never calls this.
  */
 export declare function ensureGitHubToken(): Promise<void>;
+/**
+ * retry predicate shared by token mints: 4xx is terminal user state (app not
+ * installed, permissions wrong) — retrying just triples our log noise and the
+ * user's CI bill (see #693). 5xx/429 and network failures are transient
+ * (vercel cold start, github outage, rate limit) and should ride the backoff.
+ */
+export declare function isTransientTokenError(error: unknown): boolean;
 export declare function acquireNewToken(opts?: AcquireTokenOptions): Promise<string>;
 export interface RepoContext {
     owner: string;
@@ -74,5 +100,5 @@ export interface UsageSummary {
     };
 }
 export declare function writeGitHubUsageSummaryToFile(path: string): Promise<void>;
-export declare function createOctokit(token: string): OctokitWithPlugins;
+export declare function createOctokit(token: string, refreshAuth?: (stale: string) => Promise<string>): OctokitWithPlugins;
 export {};

package/dist/utils/instructions.d.ts

@@ -9,6 +9,9 @@ interface InstructionsContext {
     modes: Mode[];
     agentId: AgentId;
     outputSchema?: Record<string, unknown> | undefined;
+    /** commits are created via the GitHub API (commit_changes tool) so GitHub
+     * signs them — flips the Git instructions to the signed-commits flow. */
+    signedCommits: boolean;
     /** absolute path to the seeded learnings tmpfile, or null when the file
      * couldn't be seeded for some reason. main.ts always seeds, so in
      * practice this is always set; the null case keeps the type honest. */
@@ -21,6 +24,14 @@ interface InstructionsContext {
      * `describeSetupFailure`), rendered as a SETUP HOOK FAILED banner. empty
      * string when the hook succeeded, was skipped, or wasn't configured. */
     setupHookFailure: string;
+    /** operator-authored cross-repo brief (`Account.xrepoBrief`), rendered in
+     * the CROSS-REPO section on --xrepo runs. null/empty otherwise. */
+    xrepoBrief: string | null;
+    /** absolute path to the seeded cross-repo learnings tmpfile (--xrepo runs
+     * only), or null. */
+    xrepoLearningsFilePath: string | null;
+    /** server-parsed TOC for the cross-repo learnings body. */
+    xrepoLearningsHeadings: LearningsHeading[];
 }
 export interface ResolvedInstructions {
     full: string;

package/dist/utils/isTransientNetworkError.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Predicate for transient network errors that should be retried (vs. fail fast
+ * on explicit HTTP status / validation errors that carry their own message).
+ *
+ * Matches errors from `fetch` (`fetch failed`), TCP-level interruption
+ * (`ECONNRESET`, `ETIMEDOUT`), and `AbortSignal.timeout` (`AbortError`).
+ * Callers may pass `extraPatterns` to whitelist additional transient
+ * substrings on `error.message` (e.g. provider-specific framings).
+ */
+export declare function isTransientNetworkError(error: unknown, extraPatterns?: string[]): boolean;

package/dist/utils/learnings.d.ts

@@ -29,7 +29,9 @@ export { MAX_LEARNINGS_LENGTH, truncateAtLineBoundary };
  * agent-targetable on long-lived repos; there is no fixed taxonomy.
  */
 export declare const LEARNINGS_FILE_NAME = "pullfrog-learnings.md";
+export declare const XREPO_LEARNINGS_FILE_NAME = "pullfrog-xrepo-learnings.md";
 export declare function learningsFilePath(tmpdir: string): string;
+export declare function xrepoLearningsFilePath(tmpdir: string): string;
 /** seed the rolling learnings tmpfile with the verbatim DB body (or empty
  * string for fresh repos). returns the absolute path. the parsed TOC is
  * carried separately via `RepoSettings.learningsHeadings` and rendered
@@ -39,6 +41,11 @@ export declare function seedLearningsFile(params: {
     tmpdir: string;
     current: string | null;
 }): Promise<string>;
+/** seed the org-level cross-repo learnings tmpfile (--xrepo runs only). */
+export declare function seedXrepoLearningsFile(params: {
+    tmpdir: string;
+    current: string | null;
+}): Promise<string>;
 /** read the agent-edited learnings file. returns null when the file is
  * missing or unreadable (treated as "no change"). caps content at the
  * server's max length to avoid a 400 round-trip. */
@@ -60,3 +67,10 @@ export declare function readLearningsFile(path: string): Promise<string | null>;
  * normal end-of-run path and the SIGINT/SIGTERM handler.
  */
 export declare function persistLearnings(ctx: ToolContext): Promise<void>;
+/**
+ * Read the agent-edited cross-repo learnings tmpfile and PATCH it to
+ * `Account.xrepoLearnings`. Org-level analogue of `persistLearnings` —
+ * same best-effort + unchanged-from-seed gating. Only seeded on --xrepo runs,
+ * so this is a no-op when `xrepoLearningsFilePath` is unset.
+ */
+export declare function persistXrepoLearnings(ctx: ToolContext): Promise<void>;

package/dist/utils/modelAccess.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Model-access gate for explicitly-requested per-run models (`--opus`,
+ * `--model=<slug>`). An explicit model the run can't serve hard-fails *before*
+ * the agent starts with one consistent, reason-tailored error.
+ *
+ * The provenance split lives upstream: `payload.modelExplicit` is true only for
+ * a flag in the triggerer's own @pullfrog prompt. A standing default (repo
+ * setting, a model flag in org/repo `baseInstructions`, or a trigger's fallback
+ * instructions) keeps `modelExplicit = false` and never reaches the error
+ * branches here — a missing key for a standing default surfaces through
+ * `validateAgentApiKey`'s missing-key error instead (#938).
+ *
+ * `decideModelAccess` is pure (no env / IO) so the branching is unit-testable;
+ * `buildModelAccessError` renders the user-facing markdown that `main.ts`
+ * throws and `runErrorRenderer.ts` re-surfaces on both run surfaces.
+ */
+export type ModelAccessReason = "oss" | "byok_no_key" | "router";
+export type ModelAccessDecision = {
+    kind: "ok";
+}
+/** route through the Router/OSS proxy, re-targeted to the requested model. */
+ | {
+    kind: "proxy";
+    target: string;
+}
+/** run BYOK with the requested model — clear the minted proxy target. */
+ | {
+    kind: "byok";
+} | {
+    kind: "error";
+    reason: ModelAccessReason;
+};
+/**
+ * decide whether an (already-resolved) requested model can run, and how.
+ *
+ * - non-explicit / no model → `ok` (caller's missing-key validation applies).
+ * - proxy active + OSS → only the funded subsidy target routes; a different
+ *   model needs the repo's own key (`byok`) else `error("oss")`.
+ * - proxy active + Router → honor any Router-servable model (`proxy`); fall to
+ *   BYOK when locally authorized, else `error("router")`.
+ * - no proxy → the resolved model must be locally authorized, else
+ *   `error("byok_no_key")`.
+ */
+export declare function decideModelAccess(input: {
+    modelExplicit: boolean;
+    model: string | undefined;
+    oss: boolean;
+    proxyActive: boolean;
+    subsidyTarget: string | undefined;
+    resolvedModel: string | undefined;
+    authorized: Set<string>;
+}): ModelAccessDecision;
+/** marker on the throw message so `runErrorRenderer` can reclassify it. */
+export declare const MODEL_ACCESS_MARKER = "requested model is not available";
+/**
+ * render the model-access failure body (used for both the thrown error and the
+ * PR comment / job summary). one shape, reason-branched why → CTA.
+ */
+export declare function buildModelAccessError(input: {
+    reason: ModelAccessReason;
+    model: string;
+    owner: string;
+    name: string;
+}): string;

package/dist/utils/openCodeModels.d.ts

@@ -6,6 +6,6 @@ export declare function captureBaselineModels(cliPath: string): void;
  * `» BYOK auth enabled N model(s): …`. */
 export declare function captureAuthorizedModels(cliPath: string): void;
 /** Authorized set captured after Pullfrog-stored auth is applied. Throws if
- * called before `captureAuthorizedModels` — the call sites (fallback gate,
- * api-key validation, auto-select) all run strictly after capture. */
+ * called before `captureAuthorizedModels` — the call sites (api-key
+ * validation, auto-select) all run strictly after capture. */
 export declare function getAuthorizedModels(): Set<string>;

package/dist/utils/payload.d.ts

@@ -5,10 +5,18 @@ export declare const JsonPayload: import("arktype/internal/variants/object.ts").
     version: string;
     prompt: string;
     model?: string | undefined;
+    modelExplicit?: boolean | undefined;
     triggerer?: string | undefined;
+    baseInstructions?: string | undefined;
     eventInstructions?: string;
     previousRunsNote?: string;
     event?: object;
+    xrepo?: {
+        mode: "all" | "explicit";
+        read: string[];
+        write: string[];
+        unavailable?: string[];
+    } | undefined;
     timeout?: string | undefined;
     progressComment?: {
         id: string;
@@ -32,11 +40,19 @@ export declare function resolvePayload(resolvedPromptInput: ResolvedPromptInput,
     "~pullfrog": true;
     version: string;
     model: string | undefined;
+    modelExplicit: boolean;
     prompt: string;
     triggerer: string | undefined;
+    baseInstructions: string | undefined;
     eventInstructions: string | undefined;
     previousRunsNote: string | undefined;
     event: PayloadEvent;
+    xrepo: {
+        mode: "all" | "explicit";
+        read: string[];
+        write: string[];
+        unavailable?: string[];
+    } | undefined;
     timeout: string | undefined;
     cwd: string | undefined;
     progressComment: {

package/dist/utils/proxy.d.ts

@@ -4,7 +4,8 @@
  * billing accounts) or OSS-grant paths.
  *
  * Authenticates one of two ways:
- *   - production: GitHub Actions OIDC token via `core.getIDToken`
+ *   - production: GitHub Actions OIDC token minted from the stashed
+ *     credentials via `fetchIdTokenFromStash` (env-free)
  *   - local dev (`API_URL` is localhost): `x-dev-repo` header bypass
  *
  * `runProxyResolution` is the entrypoint `main.ts` calls. It wraps
@@ -17,11 +18,8 @@
  *   - 503 → `TransientError` (transient sync issue — retry next dispatch)
  */
 import type { ToolState } from "../toolState.ts";
+import { type OidcCredentials } from "./github.ts";
 import type { ResolvedPayload } from "./payload.ts";
-export interface OidcCredentials {
-    requestUrl: string;
-    requestToken: string;
-}
 /**
  * Run `resolveProxyModel`; if it throws a Billing or Transient error, render
  * the user-facing summary, mirror it to the PR progress comment, and rethrow.

package/dist/utils/runContext.d.ts

@@ -31,10 +31,14 @@ export interface RepoSettings {
     push: PushPermission;
     shell: ShellPermission;
     prApproveEnabled: boolean;
+    signedCommits: boolean;
     modeInstructions: Record<string, string>;
     learnings: string | null;
     learningsHeadings: LearningsHeading[];
     envAllowlist: string | null;
+    xrepoBrief: string | null;
+    xrepoLearnings: string | null;
+    xrepoLearningsHeadings: LearningsHeading[];
 }
 /**
  * Account-level billing plan. Orthogonal to repo-level OSS status. Mirrors

package/dist/utils/runContextData.d.ts

@@ -18,6 +18,16 @@ interface ResolveRunContextDataParams {
     octokit: OctokitWithPlugins;
     token: string;
 }
+/**
+ * true when the action is pinned to a full commit SHA (vs the moving `@v0`
+ * tag or a branch). GitHub runs the action's `post:` hook (and reads
+ * `action.yml`) straight from the checked-out action ref, so a SHA pin freezes
+ * that checkout forever: the main agent still floats to the latest `^semver`
+ * via the npm bootstrap (this code is proof — it ran), but the post-run
+ * cleanup step keeps executing the pinned commit's source and never receives
+ * fixes. surfaced in the log and PR footers to nudge repos back to `@v0`.
+ */
+export declare function isActionPinnedToSha(): boolean;
 /**
  * initialize run context data: parse context, fetch repo info and settings
  */

package/dist/utils/runErrorRenderer.d.ts

@@ -24,8 +24,8 @@
  *      the underlying provider error often lands); `formatApiKeyErrorSummary`
  *      renders provider + console-link copy.
  *
- *   4. ProviderModelNotFoundError — stale free-fallback model id no longer
- *      in the OpenCode catalog; renders a nudge to add a BYOK key.
+ *   4. ProviderModelNotFoundError — configured model id no longer in the
+ *      OpenCode catalog; renders a nudge to pick a different model.
  *
  *   5. Activity-timeout hang — `errorMessage` starts with
  *      `"activity timeout"` or `"agent still pending"` AND none of the

package/dist/utils/setup.d.ts

@@ -1,5 +1,5 @@
 import type { ShellPermission } from "../external.ts";
-import type { ToolState } from "../toolState.ts";
+import { type ToolState } from "../toolState.ts";
 import type { OctokitWithPlugins } from "./github.ts";
 export interface SetupOptions {
     tempDir: string;
@@ -61,15 +61,30 @@ export interface GitContext {
     postCheckoutScript: string | null;
 }
 export type SetupGitParams = GitContext;
+/** GitContext plus an explicit working-tree directory (primary cwd or a
+ * secondary clone under ctx.tmpdir/xrepo/<name>). */
+export interface ConfigureRepoGitParams extends GitContext {
+    dir: string;
+}
 /**
- * setup git configuration and authentication for the repository.
+ * setup git configuration + authentication for the PRIMARY repo working tree
+ * (process.cwd()). thin wrapper over configureRepoGit. preserves the existing
+ * single-repo call shape in main.ts.
+ */
+export declare function setupGit(params: SetupGitParams): Promise<void>;
+/**
+ * setup git configuration and authentication for a repository working tree at
+ * `params.dir`. used for the primary repo (dir = cwd) and for secondary repos
+ * cloned on demand by checkout_repo (dir = ctx.tmpdir/xrepo/<name>).
  * - configures git identity (user.email, user.name)
  * - sets up authentication via gitToken (minimal contents:write)
+ * - records pushUrl + initialHead onto the repo's RepoToolState (must already
+ *   be registered in toolState.repos)
  *
  * gitToken is a minimal-permission token (contents + workflows) used for git operations.
  * it is assumed to be potentially exfiltratable, so it has limited scope.
  */
-export declare function setupGit(params: SetupGitParams): Promise<void>;
+export declare function configureRepoGit(params: ConfigureRepoGitParams): Promise<void>;
 /**
  * snapshot the current HEAD as either a branch name (when on a named branch)
  * or a literal SHA (when detached). used by setupGit to pin the run-entry

package/dist/utils/token.d.ts

@@ -1,7 +1,12 @@
-import type { PushPermission } from "../external.ts";
-import { acquireNewToken } from "./github.ts";
+import type { PushPermission, XrepoConfig } from "../external.ts";
+import { acquireNewToken, type OidcCredentials } from "./github.ts";
 export { acquireNewToken as acquireInstallationToken };
 export { revokeGitHubInstallationToken as revokeInstallationToken };
+/**
+ * get the refresh function for the MCP token, if re-acquisition is possible.
+ * pass to `createOctokit` so a mid-run 401 triggers a refresh + retry (#891).
+ */
+export declare function getMcpTokenRefresh(): ((stale: string) => Promise<string>) | undefined;
 /**
  * get the job-scoped token from action input.
  * this token has permissions defined by the workflow's permissions block.
@@ -15,19 +20,33 @@ export declare function getJobToken(): string;
 export type TokenRef = {
     gitToken: string;
     mcpToken: string;
+    readToken?: string | undefined;
+    refreshGitToken?: ((stale: string) => Promise<string>) | undefined;
     [Symbol.asyncDispose]: () => Promise<void>;
 };
 type ResolveTokensParams = {
     push: PushPermission;
+    xrepo?: XrepoConfig | undefined;
+    /**
+     * OIDC credentials stashed by main.ts before the restricted-mode env wipe —
+     * the mid-run MCP token refresh mints from this snapshot (#891). null when
+     * OIDC isn't available (local dev, external token).
+     */
+    oidc: OidcCredentials | null;
 };
 /**
  * resolve tokens for the action run.
  *
- * creates two separate tokens:
+ * creates two separate tokens (three on cross-repo runs):
  * - gitToken: contents permission based on `push` setting (assumed exfiltratable)
  *   - push: enabled → contents:write (can push)
  *   - push: disabled → contents:read (read-only)
  * - mcpToken: full installation token - used for GitHub API calls in MCP tools (not exfiltratable)
+ * - readToken (xrepo only): contents:read over the read set, for cloning read-tier secondaries
+ *
+ * on cross-repo runs, gitToken + mcpToken are scoped to the WRITE set (always
+ * incl. the primary), so a writable secondary can take PRs; read-only
+ * secondaries route through readToken instead.
  *
  * security-conscious users can pass their own token via GH_TOKEN env var or inputs.token.
  */

package/dist/yes/index.d.ts

@@ -0,0 +1,32 @@
+import type { StandardSchemaV1 } from "./standard-schema.ts";
+export type { StandardSchemaV1 } from "./standard-schema.ts";
+export declare function range(n: number): number[];
+export declare function range(start: number, end: number): number[];
+export declare function range(n: number, fn: (i: number) => number): number[];
+export declare function schedule(fn: (i: number) => number, count: number): number[];
+type InferInput<S> = S extends StandardSchemaV1<infer I, any> ? I : never;
+type InferOutput<S> = S extends StandardSchemaV1<any, infer O> ? O : never;
+export interface OpOptions<TReturn = any> {
+    name?: string;
+    ttl?: number;
+    maxItems?: number;
+    retries?: number[];
+    cacheHit?: ((key: string) => void) | null;
+    cacheMiss?: ((key: string) => void) | null;
+    skipCache?: (result: TReturn) => boolean;
+    bail?: (error: unknown) => boolean;
+}
+export interface OpObjectOptions<TInputSchema extends StandardSchemaV1 | undefined = undefined, TOutputSchema extends StandardSchemaV1 | undefined = undefined, TRun extends (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any> = (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any>> extends OpOptions<TOutputSchema extends StandardSchemaV1 ? InferOutput<TOutputSchema> : Awaited<ReturnType<TRun>>> {
+    input?: TInputSchema;
+    output?: TOutputSchema;
+    run: TRun;
+}
+type AnyAsyncFn = (...args: any[]) => Promise<any>;
+type Input<F extends AnyAsyncFn> = Parameters<F>[0];
+export type OpFunction<F extends AnyAsyncFn> = F & {
+    clear: (key?: Input<F>) => void;
+    has: (key: Input<F>) => boolean;
+    invalidate: (predicate: (key: Input<F>) => boolean) => number;
+};
+export declare function op<F extends AnyAsyncFn>(fn: F, options?: OpOptions<Awaited<ReturnType<F>>>): OpFunction<F>;
+export declare function op<TInputSchema extends StandardSchemaV1 | undefined = undefined, TOutputSchema extends StandardSchemaV1 | undefined = undefined, TRun extends (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any> = (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any>>(options: OpObjectOptions<TInputSchema, TOutputSchema, TRun>): OpFunction<(input: TInputSchema extends StandardSchemaV1 ? InferInput<TInputSchema> : Parameters<TRun>[0], ctx?: TRun extends (input: any, ctx: infer C, ...rest: any[]) => any ? C : never) => Promise<TOutputSchema extends StandardSchemaV1 ? InferOutput<TOutputSchema> : Awaited<ReturnType<TRun>>>>;

package/dist/yes/standard-schema.d.ts

@@ -0,0 +1,117 @@
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    /** The Standard properties. */
+    readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+export declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Typed. */
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+    /** The options for the input/output methods. */
+    interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}