@lunora/codegen 1.0.0-alpha.32 → 1.0.0-alpha.320

package/dist/sdk/index.d.mts

@@ -0,0 +1,288 @@
+import { LanguageName } from 'quicktype-core';
+/**
+ * Language-agnostic half of SDK generation: turn an OpenRPC document
+ * (`_generated/openrpc.json`, see {@link file://../openrpc.ts}) into the parsed
+ * shape every per-language target renders from.
+ *
+ * Nothing here knows about a target language. A target supplies its own member
+ * naming and templates (see {@link file://./targets}); everything that would
+ * otherwise be re-derived per language — how a `functionPath` splits, which
+ * runtime verb a kind maps to, whether a schema is real or the untyped
+ * placeholder, how namespaces group and sort — lives here exactly once.
+ *
+ * That single-source rule is not stylistic. `paths.ts` documents the same
+ * discipline for namespaces ("if these ever disagree, runtime dispatch silently
+ * misses functions"), and the failure mode here is the same in a new costume: a
+ * target that re-derives a model name renders an import pointing at a class
+ * quicktype never emitted.
+ *
+ * Deriving names in one place is necessary but NOT sufficient, because only
+ * half the decision is ours: quicktype chooses whether a predicted name becomes
+ * a declared type, and different backends answer differently for the same
+ * schema. {@link withDeclaredModels} reconciles the two halves before a target
+ * renders anything.
+ */
+/** One OpenRPC method as {@link file://../openrpc.ts} emits it. */
+interface OpenRpcMethod {
+  name: string;
+  params?: ReadonlyArray<{
+    name: string;
+    schema?: Record<string, unknown>;
+  }>;
+  result?: {
+    name: string;
+    schema?: Record<string, unknown>;
+  };
+  summary?: string;
+  "x-lunora-function-kind"?: string;
+}
+/** The `_generated/openrpc.json` document. */
+interface OpenRpcDocument {
+  info?: {
+    title?: string;
+    version?: string;
+  };
+  methods: ReadonlyArray<OpenRpcMethod>;
+}
+/** The runtime verbs a generated SDK can call. Mirrors the client transports. */
+type RuntimeVerb = "action" | "mutation" | "query";
+/** One RPC function, parsed and language-neutral. */
+interface SdkMethod {
+  /**
+   * Where this function's ARGUMENT nulls mean "unset" and where they mean
+   * "null" — see {@link ModelNullPaths}.
+   *
+   * On the method rather than on a shared render input because it is a
+   * per-method fact and the parser already holds the schema it comes from. Read
+   * by the three targets whose rendered models cannot tell the two apart
+   * (ruby, rust, swift); the other five have a marker of their own and ignore
+   * it.
+   */
+  argsNullPaths: ModelNullPaths;
+  /**
+   * Generated args model name, or `undefined` when NO model could be named for
+   * this function's arguments.
+   *
+   * `undefined` does NOT mean "takes no arguments" — see {@link SdkMethod.takesArgs}.
+   * A schema carrying a `v.bigint()` or `v.bytes()` gets no model deliberately
+   * (`hasUnrepresentableWireType`), and a backend that cannot name a shape leaves
+   * it undeclared. Both still take arguments, just untyped ones.
+   */
+  argsType: string | undefined;
+  /** Raw exported function name (`"list"`), before any naming convention. */
+  functionName: string;
+  /** The wire identifier (`"messages:list"`), emitted verbatim into calls. */
+  functionPath: string;
+  /** Raw file namespace (`"messages"`), before any naming convention. */
+  namespace: string;
+  /** Generated result model name, or `undefined` while the result is untyped. */
+  resultType: string | undefined;
+  /** Human summary for the doc comment. */
+  summary: string;
+  /**
+   * Whether this function declares arguments at all, independent of whether a
+   * model could be named for them.
+   *
+   * A target emits three shapes from this: a TYPED parameter when `argsType` is
+   * set, an UNTYPED wire-shaped parameter when it is not but this is true, and no
+   * parameter at all when this is false. Collapsing the middle case into the last
+   * is what made `v.bigint()` functions uncallable with arguments.
+   */
+  takesArgs: boolean;
+  /** Which runtime verb this dispatches to. */
+  verb: RuntimeVerb;
+}
+/** One namespace's functions, sorted. */
+interface SdkNamespace {
+  methods: ReadonlyArray<SdkMethod>;
+  /** Raw namespace (`"messages"`); a target applies its own casing. */
+  name: string;
+}
+/**
+ * True when a schema actually describes a shape.
+ *
+ * `openrpc.ts` emits a description-only placeholder for any function without a
+ * declared `.output()` (the return type is TS-inferred and absent from the IR).
+ * A placeholder must never become a generated model: quicktype would render an
+ * empty type, and the surface would decode every response into it — silently
+ * discarding the real payload rather than leaving it untyped.
+ */
+declare const isTypedSchema: (schema: Record<string, unknown> | undefined) => boolean;
+/**
+ * A path from a model's root to one property. `*` stands for every element of an
+ * array or every value of a record, neither of which has named positions.
+ */
+type SchemaPath = ReadonlyArray<string>;
+/**
+ * Where a model's nulls mean different things — the one fact a generated model
+ * flattens away, and the reason three ports could not send a `v.nullable()`
+ * argument at all.
+ *
+ * An unset `v.optional()` and a `v.nullable()` set to null are the SAME value in
+ * every generated model (a nil field), and opposite things on the wire: the
+ * validator rejects an explicit null for the first and requires the key present
+ * for the second. Neither Ruby, Rust nor Swift renders a marker telling them
+ * apart, so the distinction is computed here, from the schema, where `required`
+ * still exists — and handed to the targets that need it.
+ *
+ * Two lists rather than one because the ports need opposite operations. Ruby and
+ * Rust project a whole value tree and prune nulls, so they prune at
+ * {@link ModelNullPaths.optional} and nowhere else — which also stops them
+ * dropping a legitimate null inside a record or an array, as a blanket prune
+ * does. Swift's `JSONEncoder` has already dropped every struct-property nil
+ * before the transport sees a tree, so it restores nulls at
+ * {@link ModelNullPaths.nullable} instead: an absent key at a required path can
+ * only have been a nil, so putting the null back is exact.
+ *
+ * A `$ref` is NOT resolved. `openrpc.ts` inlines everything it emits, so this
+ * never comes up for a generated document — but `--spec` accepts a hand-written
+ * one, and there a `$ref`'d sub-object contributes no paths at all: the ports
+ * that prune would send its unset optionals as null, and Swift would not restore
+ * its nullables. Inline the schema, or teach this to follow the pointer.
+ *
+ * Both lists name PROPERTIES only. A record's values and an array's elements can
+ * be null too, but no port drops one: the pruning ports prune at `optional`
+ * paths, which a `*` position can never be, and `JSONEncoder` drops a nil only
+ * from a struct property — a nil inside a dictionary or array encodes as null.
+ * Listing a `*` leaf would also make Swift's restore INVENT record keys that
+ * were never there, which is why the walk records the path it descends through
+ * but never the `*` position itself.
+ */
+interface ModelNullPaths {
+  /** Required properties that permit null — a null there is a VALUE and must survive. */
+  nullable: ReadonlyArray<SchemaPath>;
+  /** Properties absent from their object's `required` — a null there means UNSET. */
+  optional: ReadonlyArray<SchemaPath>;
+}
+/** What a target renders from. */
+interface SdkRenderInput {
+  /**
+   * The rendered model source, to be written as the target's model file.
+   *
+   * Empty for a target that emits its own model FILES via
+   * {@link SdkTarget.renderModels} — those are already written, and this string
+   * exists only so the declared-model reconciliation reads one shape.
+   */
+  models: string;
+  /** Namespaces and their functions, already sorted. */
+  namespaces: ReadonlyArray<SdkNamespace>;
+}
+/**
+ * One directory or file of the hand-written transport, and where it lands in the
+ * output.
+ *
+ * `from` is relative to `sdks/<target id>/` and `to` is relative to `--out`. The
+ * two differ because a repo layout and a consumable layout are not the same
+ * shape: the Ruby transport lives under `lib/` so `ruby -Ilib` works in the
+ * repo, while a vendored copy has no `lib` to point at, and the Rust transport
+ * is the repo's root crate but a nested one in the output.
+ *
+ * Only the runtime is listed. A transport's own conformance suite and its
+ * `generated_check/` sample are deliberately absent — they assert against
+ * `protocol/fixtures/`, which is not copied, so vendoring them would ship a user
+ * a test suite that cannot run.
+ */
+interface SdkVendorEntry {
+  /** Path under `sdks/<id>/`. A directory is copied recursively. */
+  from: string;
+  /** Destination path under `--out`. */
+  to: string;
+}
+/** A language target. One per `--lang` value. */
+interface SdkTarget {
+  /** The `--lang` value (`"python"`, `"go"`, …). */
+  id: string;
+  /**
+   * The quicktype backend + renderer options that produce this target's
+   * models, or absent when the target emits its own (see
+   * {@link SdkTarget.renderModels}) or none at all.
+   *
+   * `LanguageName` is quicktype's own union, so a target naming a backend
+   * quicktype does not ship fails to compile rather than at run time.
+   */
+  quicktype?: {
+    lang: LanguageName;
+    rendererOptions?: Record<string, string>;
+  };
+  /**
+   * Render the SDK. Returns file contents keyed by path relative to the
+   * output directory (nested paths are created as needed).
+   *
+   * This includes the BUILD MANIFEST the layout needs — `go.mod`, `Cargo.toml`,
+   * `Package.swift`, a crate root — because those name the vendored transport
+   * and are therefore part of "how this language resolves the copy", not
+   * something a consumer should have to write. Languages that resolve by
+   * directory (Python, Ruby, Java, Kotlin) emit no manifest.
+   */
+  render: (input: SdkRenderInput) => Record<string, string>;
+  /**
+   * Emit this target's models from the schema directly, INSTEAD of quicktype,
+   * as file contents keyed by path relative to the output directory.
+   *
+   * Present only for the two JVM targets, and the exception is earned rather
+   * than a preference: quicktype's Java and Kotlin backends rename properties
+   * and, under `just-types`, emit no mapping metadata, so a model they render
+   * cannot be projected back onto the wire — and the only complete mapping
+   * they offer requires a Jackson / Klaxon / kotlinx dependency, which is the
+   * one thing these JDK-only transports are defined not to have.
+   * `targets/java.ts` records every option that was measured.
+   *
+   * A MAP rather than the single string quicktype returns, because Java takes
+   * one file per class: its single-file render is not compilable Java at all.
+   * The values are still joined for {@link SdkRenderInput.models}, so the
+   * declared-model reconciliation is the same code for every target.
+   */
+  renderModels?: (document: OpenRpcDocument) => Record<string, string>;
+  /**
+   * THIRD-PARTY packages a consuming project must still install, reported by
+   * the CLI. Empty for six of the eight — the transport is vendored and those
+   * six reach the wire with only their standard library.
+   *
+   * A list, and not derivable from the transport, because a target's MODELS can
+   * carry a dependency the transport does not: quicktype's Ruby backend emits
+   * `Dry::Struct` types with no renderer option to avoid them, so a Ruby SDK
+   * needs the gems even though `sdks/ruby` itself is dependency-free.
+   */
+  requires: ReadonlyArray<string>;
+  /**
+   * Which parts of `sdks/<id>/` are the transport, and where they land under
+   * `--out`. See {@link SdkVendorEntry}.
+   */
+  vendor: ReadonlyArray<SdkVendorEntry>;
+}
+/** Every language `lunora sdk generate --lang` accepts, keyed by id. */
+declare const SDK_TARGETS: Readonly<Record<string, SdkTarget>>;
+/** The accepted `--lang` values, sorted — for help text and error messages. */
+declare const SDK_LANGUAGES: ReadonlyArray<string>;
+/** The files a generation run writes, keyed by path relative to the output directory. */
+type SdkFiles = Record<string, string>;
+/** What a generation run produced, plus what it had to weaken and why. */
+interface SdkResult {
+  files: SdkFiles;
+  /**
+   * Model names predicted from the schema that the chosen backend did not
+   * declare, so their call sites fell back to an untyped return. Surfaced
+   * rather than swallowed — silently weaker types are how an SDK looks
+   * finished while returning `Any` everywhere.
+   */
+  undeclared: ReadonlyArray<string>;
+  /**
+   * Functions whose args or result carry a `v.bigint()` or `v.bytes()`. No
+   * typed model can represent those — the wire needs a tagged value that no
+   * generated field produces — so their parameters stay untyped and the
+   * caller passes wire values directly.
+   */
+  unrepresentable: ReadonlyArray<string>;
+}
+/**
+ * Generate the SDK for `document` in `target`'s language.
+ *
+ * Async only because the model layer is: quicktype's renderer is promise-based.
+ * The surface itself is pure, so a target's `render` stays synchronous and
+ * unit-testable without touching quicktype.
+ *
+ * Models are rendered BEFORE the surface because the surface's model references
+ * depend on what the backend actually declared — see {@link withDeclaredModels}.
+ */
+declare const generateSdk: (document: OpenRpcDocument, target: SdkTarget) => Promise<SdkResult>;
+export { type OpenRpcDocument, type OpenRpcMethod, type RuntimeVerb, SDK_LANGUAGES, SDK_TARGETS, type SdkFiles, type SdkMethod, type SdkNamespace, type SdkRenderInput, type SdkResult, type SdkTarget, generateSdk, isTypedSchema };

package/dist/sdk/index.d.ts

@@ -0,0 +1,288 @@
+import { LanguageName } from 'quicktype-core';
+/**
+ * Language-agnostic half of SDK generation: turn an OpenRPC document
+ * (`_generated/openrpc.json`, see {@link file://../openrpc.ts}) into the parsed
+ * shape every per-language target renders from.
+ *
+ * Nothing here knows about a target language. A target supplies its own member
+ * naming and templates (see {@link file://./targets}); everything that would
+ * otherwise be re-derived per language — how a `functionPath` splits, which
+ * runtime verb a kind maps to, whether a schema is real or the untyped
+ * placeholder, how namespaces group and sort — lives here exactly once.
+ *
+ * That single-source rule is not stylistic. `paths.ts` documents the same
+ * discipline for namespaces ("if these ever disagree, runtime dispatch silently
+ * misses functions"), and the failure mode here is the same in a new costume: a
+ * target that re-derives a model name renders an import pointing at a class
+ * quicktype never emitted.
+ *
+ * Deriving names in one place is necessary but NOT sufficient, because only
+ * half the decision is ours: quicktype chooses whether a predicted name becomes
+ * a declared type, and different backends answer differently for the same
+ * schema. {@link withDeclaredModels} reconciles the two halves before a target
+ * renders anything.
+ */
+/** One OpenRPC method as {@link file://../openrpc.ts} emits it. */
+interface OpenRpcMethod {
+  name: string;
+  params?: ReadonlyArray<{
+    name: string;
+    schema?: Record<string, unknown>;
+  }>;
+  result?: {
+    name: string;
+    schema?: Record<string, unknown>;
+  };
+  summary?: string;
+  "x-lunora-function-kind"?: string;
+}
+/** The `_generated/openrpc.json` document. */
+interface OpenRpcDocument {
+  info?: {
+    title?: string;
+    version?: string;
+  };
+  methods: ReadonlyArray<OpenRpcMethod>;
+}
+/** The runtime verbs a generated SDK can call. Mirrors the client transports. */
+type RuntimeVerb = "action" | "mutation" | "query";
+/** One RPC function, parsed and language-neutral. */
+interface SdkMethod {
+  /**
+   * Where this function's ARGUMENT nulls mean "unset" and where they mean
+   * "null" — see {@link ModelNullPaths}.
+   *
+   * On the method rather than on a shared render input because it is a
+   * per-method fact and the parser already holds the schema it comes from. Read
+   * by the three targets whose rendered models cannot tell the two apart
+   * (ruby, rust, swift); the other five have a marker of their own and ignore
+   * it.
+   */
+  argsNullPaths: ModelNullPaths;
+  /**
+   * Generated args model name, or `undefined` when NO model could be named for
+   * this function's arguments.
+   *
+   * `undefined` does NOT mean "takes no arguments" — see {@link SdkMethod.takesArgs}.
+   * A schema carrying a `v.bigint()` or `v.bytes()` gets no model deliberately
+   * (`hasUnrepresentableWireType`), and a backend that cannot name a shape leaves
+   * it undeclared. Both still take arguments, just untyped ones.
+   */
+  argsType: string | undefined;
+  /** Raw exported function name (`"list"`), before any naming convention. */
+  functionName: string;
+  /** The wire identifier (`"messages:list"`), emitted verbatim into calls. */
+  functionPath: string;
+  /** Raw file namespace (`"messages"`), before any naming convention. */
+  namespace: string;
+  /** Generated result model name, or `undefined` while the result is untyped. */
+  resultType: string | undefined;
+  /** Human summary for the doc comment. */
+  summary: string;
+  /**
+   * Whether this function declares arguments at all, independent of whether a
+   * model could be named for them.
+   *
+   * A target emits three shapes from this: a TYPED parameter when `argsType` is
+   * set, an UNTYPED wire-shaped parameter when it is not but this is true, and no
+   * parameter at all when this is false. Collapsing the middle case into the last
+   * is what made `v.bigint()` functions uncallable with arguments.
+   */
+  takesArgs: boolean;
+  /** Which runtime verb this dispatches to. */
+  verb: RuntimeVerb;
+}
+/** One namespace's functions, sorted. */
+interface SdkNamespace {
+  methods: ReadonlyArray<SdkMethod>;
+  /** Raw namespace (`"messages"`); a target applies its own casing. */
+  name: string;
+}
+/**
+ * True when a schema actually describes a shape.
+ *
+ * `openrpc.ts` emits a description-only placeholder for any function without a
+ * declared `.output()` (the return type is TS-inferred and absent from the IR).
+ * A placeholder must never become a generated model: quicktype would render an
+ * empty type, and the surface would decode every response into it — silently
+ * discarding the real payload rather than leaving it untyped.
+ */
+declare const isTypedSchema: (schema: Record<string, unknown> | undefined) => boolean;
+/**
+ * A path from a model's root to one property. `*` stands for every element of an
+ * array or every value of a record, neither of which has named positions.
+ */
+type SchemaPath = ReadonlyArray<string>;
+/**
+ * Where a model's nulls mean different things — the one fact a generated model
+ * flattens away, and the reason three ports could not send a `v.nullable()`
+ * argument at all.
+ *
+ * An unset `v.optional()` and a `v.nullable()` set to null are the SAME value in
+ * every generated model (a nil field), and opposite things on the wire: the
+ * validator rejects an explicit null for the first and requires the key present
+ * for the second. Neither Ruby, Rust nor Swift renders a marker telling them
+ * apart, so the distinction is computed here, from the schema, where `required`
+ * still exists — and handed to the targets that need it.
+ *
+ * Two lists rather than one because the ports need opposite operations. Ruby and
+ * Rust project a whole value tree and prune nulls, so they prune at
+ * {@link ModelNullPaths.optional} and nowhere else — which also stops them
+ * dropping a legitimate null inside a record or an array, as a blanket prune
+ * does. Swift's `JSONEncoder` has already dropped every struct-property nil
+ * before the transport sees a tree, so it restores nulls at
+ * {@link ModelNullPaths.nullable} instead: an absent key at a required path can
+ * only have been a nil, so putting the null back is exact.
+ *
+ * A `$ref` is NOT resolved. `openrpc.ts` inlines everything it emits, so this
+ * never comes up for a generated document — but `--spec` accepts a hand-written
+ * one, and there a `$ref`'d sub-object contributes no paths at all: the ports
+ * that prune would send its unset optionals as null, and Swift would not restore
+ * its nullables. Inline the schema, or teach this to follow the pointer.
+ *
+ * Both lists name PROPERTIES only. A record's values and an array's elements can
+ * be null too, but no port drops one: the pruning ports prune at `optional`
+ * paths, which a `*` position can never be, and `JSONEncoder` drops a nil only
+ * from a struct property — a nil inside a dictionary or array encodes as null.
+ * Listing a `*` leaf would also make Swift's restore INVENT record keys that
+ * were never there, which is why the walk records the path it descends through
+ * but never the `*` position itself.
+ */
+interface ModelNullPaths {
+  /** Required properties that permit null — a null there is a VALUE and must survive. */
+  nullable: ReadonlyArray<SchemaPath>;
+  /** Properties absent from their object's `required` — a null there means UNSET. */
+  optional: ReadonlyArray<SchemaPath>;
+}
+/** What a target renders from. */
+interface SdkRenderInput {
+  /**
+   * The rendered model source, to be written as the target's model file.
+   *
+   * Empty for a target that emits its own model FILES via
+   * {@link SdkTarget.renderModels} — those are already written, and this string
+   * exists only so the declared-model reconciliation reads one shape.
+   */
+  models: string;
+  /** Namespaces and their functions, already sorted. */
+  namespaces: ReadonlyArray<SdkNamespace>;
+}
+/**
+ * One directory or file of the hand-written transport, and where it lands in the
+ * output.
+ *
+ * `from` is relative to `sdks/<target id>/` and `to` is relative to `--out`. The
+ * two differ because a repo layout and a consumable layout are not the same
+ * shape: the Ruby transport lives under `lib/` so `ruby -Ilib` works in the
+ * repo, while a vendored copy has no `lib` to point at, and the Rust transport
+ * is the repo's root crate but a nested one in the output.
+ *
+ * Only the runtime is listed. A transport's own conformance suite and its
+ * `generated_check/` sample are deliberately absent — they assert against
+ * `protocol/fixtures/`, which is not copied, so vendoring them would ship a user
+ * a test suite that cannot run.
+ */
+interface SdkVendorEntry {
+  /** Path under `sdks/<id>/`. A directory is copied recursively. */
+  from: string;
+  /** Destination path under `--out`. */
+  to: string;
+}
+/** A language target. One per `--lang` value. */
+interface SdkTarget {
+  /** The `--lang` value (`"python"`, `"go"`, …). */
+  id: string;
+  /**
+   * The quicktype backend + renderer options that produce this target's
+   * models, or absent when the target emits its own (see
+   * {@link SdkTarget.renderModels}) or none at all.
+   *
+   * `LanguageName` is quicktype's own union, so a target naming a backend
+   * quicktype does not ship fails to compile rather than at run time.
+   */
+  quicktype?: {
+    lang: LanguageName;
+    rendererOptions?: Record<string, string>;
+  };
+  /**
+   * Render the SDK. Returns file contents keyed by path relative to the
+   * output directory (nested paths are created as needed).
+   *
+   * This includes the BUILD MANIFEST the layout needs — `go.mod`, `Cargo.toml`,
+   * `Package.swift`, a crate root — because those name the vendored transport
+   * and are therefore part of "how this language resolves the copy", not
+   * something a consumer should have to write. Languages that resolve by
+   * directory (Python, Ruby, Java, Kotlin) emit no manifest.
+   */
+  render: (input: SdkRenderInput) => Record<string, string>;
+  /**
+   * Emit this target's models from the schema directly, INSTEAD of quicktype,
+   * as file contents keyed by path relative to the output directory.
+   *
+   * Present only for the two JVM targets, and the exception is earned rather
+   * than a preference: quicktype's Java and Kotlin backends rename properties
+   * and, under `just-types`, emit no mapping metadata, so a model they render
+   * cannot be projected back onto the wire — and the only complete mapping
+   * they offer requires a Jackson / Klaxon / kotlinx dependency, which is the
+   * one thing these JDK-only transports are defined not to have.
+   * `targets/java.ts` records every option that was measured.
+   *
+   * A MAP rather than the single string quicktype returns, because Java takes
+   * one file per class: its single-file render is not compilable Java at all.
+   * The values are still joined for {@link SdkRenderInput.models}, so the
+   * declared-model reconciliation is the same code for every target.
+   */
+  renderModels?: (document: OpenRpcDocument) => Record<string, string>;
+  /**
+   * THIRD-PARTY packages a consuming project must still install, reported by
+   * the CLI. Empty for six of the eight — the transport is vendored and those
+   * six reach the wire with only their standard library.
+   *
+   * A list, and not derivable from the transport, because a target's MODELS can
+   * carry a dependency the transport does not: quicktype's Ruby backend emits
+   * `Dry::Struct` types with no renderer option to avoid them, so a Ruby SDK
+   * needs the gems even though `sdks/ruby` itself is dependency-free.
+   */
+  requires: ReadonlyArray<string>;
+  /**
+   * Which parts of `sdks/<id>/` are the transport, and where they land under
+   * `--out`. See {@link SdkVendorEntry}.
+   */
+  vendor: ReadonlyArray<SdkVendorEntry>;
+}
+/** Every language `lunora sdk generate --lang` accepts, keyed by id. */
+declare const SDK_TARGETS: Readonly<Record<string, SdkTarget>>;
+/** The accepted `--lang` values, sorted — for help text and error messages. */
+declare const SDK_LANGUAGES: ReadonlyArray<string>;
+/** The files a generation run writes, keyed by path relative to the output directory. */
+type SdkFiles = Record<string, string>;
+/** What a generation run produced, plus what it had to weaken and why. */
+interface SdkResult {
+  files: SdkFiles;
+  /**
+   * Model names predicted from the schema that the chosen backend did not
+   * declare, so their call sites fell back to an untyped return. Surfaced
+   * rather than swallowed — silently weaker types are how an SDK looks
+   * finished while returning `Any` everywhere.
+   */
+  undeclared: ReadonlyArray<string>;
+  /**
+   * Functions whose args or result carry a `v.bigint()` or `v.bytes()`. No
+   * typed model can represent those — the wire needs a tagged value that no
+   * generated field produces — so their parameters stay untyped and the
+   * caller passes wire values directly.
+   */
+  unrepresentable: ReadonlyArray<string>;
+}
+/**
+ * Generate the SDK for `document` in `target`'s language.
+ *
+ * Async only because the model layer is: quicktype's renderer is promise-based.
+ * The surface itself is pure, so a target's `render` stays synchronous and
+ * unit-testable without touching quicktype.
+ *
+ * Models are rendered BEFORE the surface because the surface's model references
+ * depend on what the backend actually declared — see {@link withDeclaredModels}.
+ */
+declare const generateSdk: (document: OpenRpcDocument, target: SdkTarget) => Promise<SdkResult>;
+export { type OpenRpcDocument, type OpenRpcMethod, type RuntimeVerb, SDK_LANGUAGES, SDK_TARGETS, type SdkFiles, type SdkMethod, type SdkNamespace, type SdkRenderInput, type SdkResult, type SdkTarget, generateSdk, isTypedSchema };