@parity/truapi 0.1.0 → 0.3.0

package/dist/playground/codegen/truapi-dts.js

@@ -0,0 +1,4302 @@
+// Auto-generated by scripts/bundle-truapi-dts.mjs. Do not edit.
+export const truapiDts = `// neverthrow (inlined)
+
+interface ErrorConfig {
+    withStackTrace: boolean;
+}
+
+declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    private _promise;
+    constructor(res: Promise<Result<T, E>>);
+    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+    static fromThrowable<A extends readonly any[], R, E>(fn: (...args: A) => Promise<R>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<R, E>;
+    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    map<A>(f: (t: T) => A | Promise<A>): ResultAsync<A, E>;
+    andThrough<F>(f: (t: T) => Result<unknown, F> | ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+    andTee(f: (t: T) => unknown): ResultAsync<T, E>;
+    orTee(f: (t: E) => unknown): ResultAsync<T, E>;
+    mapErr<U>(f: (e: E) => U | Promise<U>): ResultAsync<T, U>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
+    match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): Promise<A | B>;
+    unwrapOr<A>(t: A): Promise<T | A>;
+    /**
+     * @deprecated will be removed in 9.0.0.
+     *
+     * You can use \`safeTry\` without this method.
+     * @example
+     * \`\`\`typescript
+     * safeTry(async function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * \`\`\`
+     * Emulates Rust's \`?\` operator in \`safeTry\`'s body. See also \`safeTry\`.
+     */
+    safeUnwrap(): AsyncGenerator<Err<never, E>, T>;
+    then<A, B>(successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+    [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
+}
+declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+declare function okAsync<T extends void = void, E = never>(value: void): ResultAsync<void, E>;
+declare function errAsync<T = never, E = unknown>(err: E): ResultAsync<T, E>;
+declare function errAsync<T = never, E extends void = void>(err: void): ResultAsync<T, void>;
+declare const fromPromise: typeof ResultAsync.fromPromise;
+declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
+declare const fromAsyncThrowable: typeof ResultAsync.fromThrowable;
+declare type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+declare type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
+declare type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Ok<L, R>[] : never : never : never;
+declare type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
+declare type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
+declare type Writable<T> = T extends ReadonlyArray<unknown> ? [...T] : T;
+
+declare type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never;
+};
+declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never;
+};
+declare type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never;
+};
+declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
+    [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never;
+};
+declare type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
+declare type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
+declare type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
+declare type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
+
+declare namespace Result {
+    /**
+     * Wraps a function with a try catch, creating a new function with the same
+     * arguments but returning \`Ok\` if successful, \`Err\` if the function throws
+     *
+     * @param fn function to wrap with ok on success or err on failure
+     * @param errorFn when an error is thrown, this will wrap the error result if provided
+     */
+    function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+    function combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResults<T>;
+    function combine<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResults<T>;
+    function combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+    function combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+}
+declare type Result<T, E> = Ok<T, E> | Err<T, E>;
+declare function ok<T, E = never>(value: T): Ok<T, E>;
+declare function ok<T extends void = void, E = never>(value: void): Ok<void, E>;
+declare function err<T = never, E extends string = string>(err: E): Err<T, E>;
+declare function err<T = never, E = unknown>(err: E): Err<T, E>;
+declare function err<T = never, E extends void = void>(err: void): Err<T, void>;
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function is intended to emulate Rust's ? operator.
+ * See \`/tests/safeTry.test.ts\` for examples.
+ *
+ * @param body - What is evaluated. In body, \`yield* result\` works as
+ * Rust's \`result?\` expression.
+ * @returns The first occurrence of either an yielded Err or a returned Result.
+ */
+declare function safeTry<T, E>(body: () => Generator<Err<never, E>, Result<T, E>>): Result<T, E>;
+declare function safeTry<YieldErr extends Err<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(body: () => Generator<YieldErr, GeneratorReturnResult>): Result<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function is intended to emulate Rust's ? operator.
+ * See \`/tests/safeTry.test.ts\` for examples.
+ *
+ * @param body - What is evaluated. In body, \`yield* result\` and
+ * \`yield* resultAsync\` work as Rust's \`result?\` expression.
+ * @returns The first occurrence of either an yielded Err or a returned Result.
+ */
+declare function safeTry<T, E>(body: () => AsyncGenerator<Err<never, E>, Result<T, E>>): ResultAsync<T, E>;
+declare function safeTry<YieldErr extends Err<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>): ResultAsync<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
+interface IResult<T, E> {
+    /**
+     * Used to check if a \`Result\` is an \`OK\`
+     *
+     * @returns \`true\` if the result is an \`OK\` variant of Result
+     */
+    isOk(): this is Ok<T, E>;
+    /**
+     * Used to check if a \`Result\` is an \`Err\`
+     *
+     * @returns \`true\` if the result is an \`Err\` variant of Result
+     */
+    isErr(): this is Err<T, E>;
+    /**
+     * Maps a \`Result<T, E>\` to \`Result<U, E>\`
+     * by applying a function to a contained \`Ok\` value, leaving an \`Err\` value
+     * untouched.
+     *
+     * @param f The function to apply an \`OK\` value
+     * @returns the result of applying \`f\` or an \`Err\` untouched
+     */
+    map<A>(f: (t: T) => A): Result<A, E>;
+    /**
+     * Maps a \`Result<T, E>\` to \`Result<T, F>\` by applying a function to a
+     * contained \`Err\` value, leaving an \`Ok\` value untouched.
+     *
+     * This function can be used to pass through a successful result while
+     * handling an error.
+     *
+     * @param f a function to apply to the error \`Err\` value
+     */
+    mapErr<U>(f: (e: E) => U): Result<T, U>;
+    /**
+     * Similar to \`map\` Except you must return a new \`Result\`.
+     *
+     * This is useful for when you need to do a subsequent computation using the
+     * inner \`T\` value, but that computation might fail.
+     * Additionally, \`andThen\` is really useful as a tool to flatten a
+     * \`Result<Result<A, E2>, E1>\` into a \`Result<A, E2>\` (see example below).
+     *
+     * @param f The function to apply to the current value
+     */
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+    /**
+     * This "tee"s the current value to an passed-in computation such as side
+     * effect functions but still returns the same current value as the result.
+     *
+     * This is useful when you want to pass the current result to your side-track
+     * work such as logging but want to continue main-track work after that.
+     * This method does not care about the result of the passed in computation.
+     *
+     * @param f The function to apply to the current value
+     */
+    andTee(f: (t: T) => unknown): Result<T, E>;
+    /**
+     * This "tee"s the current \`Err\` value to an passed-in computation such as side
+     * effect functions but still returns the same \`Err\` value as the result.
+     *
+     * This is useful when you want to pass the current \`Err\` value to your side-track
+     * work such as logging but want to continue error-track work after that.
+     * This method does not care about the result of the passed in computation.
+     *
+     * @param f The function to apply to the current \`Err\` value
+     */
+    orTee(f: (t: E) => unknown): Result<T, E>;
+    /**
+     * Similar to \`andTee\` except error result of the computation will be passed
+     * to the downstream in case of an error.
+     *
+     * This version is useful when you want to make side-effects but in case of an
+     * error, you want to pass the error to the downstream.
+     *
+     * @param f The function to apply to the current value
+     */
+    andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
+    andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+    /**
+     * Takes an \`Err\` value and maps it to a \`Result<T, SomeNewType>\`.
+     *
+     * This is useful for error recovery.
+     *
+     *
+     * @param f  A function to apply to an \`Err\` value, leaving \`Ok\` values
+     * untouched.
+     */
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
+    /**
+     * Similar to \`map\` Except you must return a new \`Result\`.
+     *
+     * This is useful for when you need to do a subsequent async computation using
+     * the inner \`T\` value, but that computation might fail. Must return a ResultAsync
+     *
+     * @param f The function that returns a \`ResultAsync\` to apply to the current
+     * value
+     */
+    asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+    /**
+     * Maps a \`Result<T, E>\` to \`ResultAsync<U, E>\`
+     * by applying an async function to a contained \`Ok\` value, leaving an \`Err\`
+     * value untouched.
+     *
+     * @param f An async function to apply an \`OK\` value
+     */
+    asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+    /**
+     * Unwrap the \`Ok\` value, or return the default if there is an \`Err\`
+     *
+     * @param v the default value to return if there is an \`Err\`
+     */
+    unwrapOr<A>(v: A): T | A;
+    /**
+     *
+     * Given 2 functions (one for the \`Ok\` variant and one for the \`Err\` variant)
+     * execute the function that matches the \`Result\` variant.
+     *
+     * Match callbacks do not necessitate to return a \`Result\`, however you can
+     * return a \`Result\` if you want to.
+     *
+     * \`match\` is like chaining \`map\` and \`mapErr\`, with the distinction that
+     * with \`match\` both functions must have the same return type.
+     *
+     * @param ok
+     * @param err
+     */
+    match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B;
+    /**
+     * @deprecated will be removed in 9.0.0.
+     *
+     * You can use \`safeTry\` without this method.
+     * @example
+     * \`\`\`typescript
+     * safeTry(function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * \`\`\`
+     * Emulates Rust's \`?\` operator in \`safeTry\`'s body. See also \`safeTry\`.
+     */
+    safeUnwrap(): Generator<Err<never, E>, T>;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * Takes a \`Result<T, E>\` and returns a \`T\` when the result is an \`Ok\`, otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * takes a \`Result<T, E>\` and returns a \`E\` when the result is an \`Err\`,
+     * otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+}
+declare class Ok<T, E> implements IResult<T, E> {
+    readonly value: T;
+    constructor(value: T);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+    map<A>(f: (t: T) => A): Result<A, E>;
+    mapErr<U>(_f: (e: E) => U): Result<T, U>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
+    andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
+    andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+    andTee(f: (t: T) => unknown): Result<T, E>;
+    orTee(_f: (t: E) => unknown): Result<T, E>;
+    orElse<R extends Result<unknown, unknown>>(_f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<U, A>(_f: (e: E) => Result<U, A>): Result<U | T, A>;
+    asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+    asyncAndThrough<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<T, InferAsyncErrTypes<R> | E>;
+    asyncAndThrough<F>(f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+    asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
+    unwrapOr<A>(_v: A): T | A;
+    match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
+    safeUnwrap(): Generator<Err<never, E>, T>;
+    _unsafeUnwrap(_?: ErrorConfig): T;
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+    [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+declare class Err<T, E> implements IResult<T, E> {
+    readonly error: E;
+    constructor(error: E);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+    map<A>(_f: (t: T) => A): Result<A, E>;
+    mapErr<U>(f: (e: E) => U): Result<T, U>;
+    andThrough<F>(_f: (t: T) => Result<unknown, F>): Result<T, E | F>;
+    andTee(_f: (t: T) => unknown): Result<T, E>;
+    orTee(f: (t: E) => unknown): Result<T, E>;
+    andThen<R extends Result<unknown, unknown>>(_f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<U, F>(_f: (t: T) => Result<U, F>): Result<U, E | F>;
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
+    asyncAndThen<U, F>(_f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
+    asyncAndThrough<F>(_f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
+    asyncMap<U>(_f: (t: T) => Promise<U>): ResultAsync<U, E>;
+    unwrapOr<A>(v: A): T | A;
+    match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B;
+    safeUnwrap(): Generator<Err<never, E>, T>;
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    _unsafeUnwrapErr(_?: ErrorConfig): E;
+    [Symbol.iterator](): Generator<Err<never, E>, T>;
+}
+declare const fromThrowable: typeof Result.fromThrowable;
+declare type Prev = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    ...0[]
+];
+declare type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [
+    Depth
+] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [
+    ...Collected,
+    [L, R]
+], Prev[Depth]> : never : Collected;
+declare type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
+declare type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [
+    infer L,
+    infer R
+] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
+declare type Dedup<T> = T extends Result<infer RL, infer RR> ? [unknown] extends [RL] ? Err<RL, RR> : Ok<RL, RR> : T;
+declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V : never : never) extends (_: unknown) => infer W ? [...MemberListOf<Exclude<T, W>>, W] : [];
+declare type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
+declare type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
+declare type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
+declare type IsLiteralArray<T> = T extends {
+    length: infer L;
+} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
+declare type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
+declare type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never;
+declare type CombineResults<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
+declare type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
+
+
+
+// scale.d.ts (module-scope)
+
+/** SCALE codec primitives used by the generated client.
+ *
+ * Thin wrapper over \`scale-ts\`: re-exports its primitives and combinators,
+ * plus the Polkadot-flavour helpers it does not ship (hex-encoded bytes,
+ * lazy recursive codecs, and \`V<N>\`-indexed tagged unions).
+ */
+import { type Codec } from "scale-ts";
+export type { Codec };
+export type { ResultPayload } from "scale-ts";
+export { Enum, Option, Result, Struct, Tuple, Vector, _void, bool, compact, i8, i16, i32, i64, i128, str, u8, u16, u32, u64, u128, } from "scale-ts";
+/**
+ * Substrate \`OptionBool\`: a one-byte \`Option<bool>\`.
+ *
+ * Canonical SCALE encoding (matches \`parity_scale_codec::OptionBool\`):
+ * \`undefined\` → \`0\`, \`true\` → \`1\`, \`false\` → \`2\`.
+ */
+export declare const OptionBool: Codec<boolean | undefined>;
+/** Hex-encoded byte string, e.g. \`"0xdeadbeef"\`. */
+export type HexString = \`0x\${string}\`;
+/** Assert that a string is a valid hex string (\`0x...\`). */
+export declare function toHexString(value: string): HexString;
+/** Encode a byte array as a lower-case hex string with a \`0x\` prefix. */
+export declare function bytesToHex(bytes: Uint8Array): HexString;
+/** Decode a hex string into a byte array. Tolerates a missing \`0x\` prefix. */
+export declare function hexToBytes(hex: string): Uint8Array;
+/**
+ * SCALE codec for hex-encoded byte strings.
+ *
+ * Encode accepts a \`0x\`-prefixed hex string and emits SCALE bytes; decode
+ * returns the bytes as a hex string. Pass \`length\` for fixed-size byte arrays
+ * (\`[u8; N]\`); omit it for variable-length byte vectors (\`Vec<u8>\`).
+ */
+export declare function Hex(length?: number): Codec<HexString>;
+/**
+ * Same wire format as \`scale-ts\`'s \`Enum\`, but exposes \`value\` as optional in
+ * the public TS type when the variant codec is \`Codec<undefined>\`. Lets unit
+ * variants of mixed enums round-trip as \`{ tag: "X" }\` (no \`value\` key).
+ */
+export declare function TaggedUnion<O extends TaggedUnionCodecs>(inner: O): Codec<TaggedUnionValue<O>>;
+type TaggedUnionCodecs = {
+    [Sym: symbol]: never;
+    [Num: number]: never;
+    [Str: string]: Codec<any>;
+};
+type TaggedUnionValue<O extends TaggedUnionCodecs> = {
+    [K in keyof O & string]: O[K] extends Codec<infer T> ? [T] extends [undefined] ? {
+        tag: K;
+        value?: undefined;
+    } : {
+        tag: K;
+        value: T;
+    } : never;
+}[keyof O & string];
+/**
+ * Enum without payloads — maps string labels to SCALE discriminant bytes.
+ *
+ * \`scale-ts\` models \`Enum({ Foo: _void, Bar: _void })\` as tagged objects. For
+ * user-facing TrUAPI enums with only unit variants, we keep the public TS shape
+ * as a plain string union instead.
+ */
+export declare function Status<const T extends string>(...variants: readonly T[]): Codec<T>;
+/**
+ * Defers codec construction until first use so recursive generated codecs can
+ * reference each other safely.
+ */
+export declare function lazy<T>(factory: () => Codec<T>): Codec<T>;
+type IndexedVariantCodec<T> = readonly [index: number, codec: Codec<T>];
+type IndexedVariantValue<Variants extends Record<string, IndexedVariantCodec<any>>, K extends keyof Variants & string> = Variants[K] extends IndexedVariantCodec<infer T> ? [T] extends [undefined] ? {
+    tag: K;
+    value?: undefined;
+} : {
+    tag: K;
+    value: T;
+} : never;
+/**
+ * Builds a tagged union codec with explicit SCALE discriminants.
+ *
+ * \`scale-ts\` assigns enum indexes by object key order. TrUAPI versioned enums pin
+ * \`V<N>\` to index \`N - 1\`, including V2-only enums, so generated codecs use this
+ * helper for versioned wire wrappers.
+ */
+export declare function indexedTaggedUnion<Variants extends Record<string, IndexedVariantCodec<any>>>(variants: Variants): Codec<{
+    [K in keyof Variants & string]: IndexedVariantValue<Variants, K>;
+}[keyof Variants & string]>;
+
+
+// generated/types.d.ts (namespace T)
+
+declare namespace T {
+/** A 32-byte raw account identifier used for legacy (non-product) accounts. */
+export type AccountId = HexString;
+export const AccountId: Codec<AccountId>;
+/** Payload when a user clicks an action button. */
+export interface ActionTrigger {
+    /** Message containing the action. */
+    messageId: string;
+    /** Which action was triggered. */
+    actionId: string;
+    /** Optional additional data. */
+    payload?: HexString;
+}
+export const ActionTrigger: Codec<ActionTrigger>;
+/**
+ * A resource the host can pre-allocate on behalf of the product (RFC 0010).
+ *
+ * For the slot-table allowances (\`StatementStoreAllowance\`,
+ * \`BulletinAllowance\`, \`SmartContractAllowance\`), pre-allocation is
+ * opportunistic and the host may also fulfil the allowance implicitly on the
+ * first submission. \`AutoSigning\` must be requested explicitly through this
+ * call.
+ */
+export type AllocatableResource = 
+/** Statement Store slot allowance for the product's own allowance account. */
+{
+    tag: "StatementStoreAllowance";
+    value?: undefined;
+}
+/** Bulletin chain slot allowance for the product's own allowance account. */
+ | {
+    tag: "BulletinAllowance";
+    value?: undefined;
+}
+/**
+ * Pre-warmed PGAS balance for the smart-contract account at the given
+ * derivation index.
+ */
+ | {
+    tag: "SmartContractAllowance";
+    value: number;
+}
+/** Permission to sign on the product's behalf without per-call user prompts. */
+ | {
+    tag: "AutoSigning";
+    value?: undefined;
+};
+export const AllocatableResource: Codec<AllocatableResource>;
+/** Outcome of allocating a single resource (RFC 0010). */
+export type AllocationOutcome = "Allocated" | "Rejected" | "NotAvailable";
+export const AllocationOutcome: Codec<AllocationOutcome>;
+/** Layout arrangement (like CSS flexbox \`justify-content\`). */
+export type Arrangement = "Start" | "End" | "Center" | "SpaceBetween" | "SpaceAround" | "SpaceEvenly";
+export const Arrangement: Codec<Arrangement>;
+/** Background styling. */
+export interface Background {
+    /** Background color. */
+    color: ColorToken;
+    /** Background shape. */
+    shape?: Shape;
+}
+export const Background: Codec<Background>;
+/**
+ * Balance amount for payment operations. Interpreted according to the host's
+ * single fixed payment asset (e.g. pUSD).
+ */
+export type Balance = bigint;
+export const Balance: Codec<Balance>;
+/** Border styling. */
+export interface BorderStyle {
+    /** Border width. */
+    width: Size;
+    /** Border color. */
+    color: ColorToken;
+    /** Border shape. */
+    shape?: Shape;
+}
+export const BorderStyle: Codec<BorderStyle>;
+/** Properties for a [\`CustomRendererNode::Box\`] container. */
+export interface BoxProps {
+    /** Content alignment within the box. */
+    contentAlignment?: ContentAlignment;
+}
+export const BoxProps: Codec<BoxProps>;
+/** Properties for a [\`CustomRendererNode::Button\`]. */
+export interface ButtonProps {
+    /** Button label text. */
+    text: string;
+    /** Button style variant. */
+    variant?: ButtonVariant;
+    /** Whether the button is enabled. Absent leaves the default to the host. */
+    enabled: boolean | undefined;
+    /** Whether the button shows a loading state. Absent leaves the default to the host. */
+    loading: boolean | undefined;
+    /** Action identifier triggered on click. */
+    clickAction?: string;
+}
+export const ButtonProps: Codec<ButtonProps>;
+/** Button style variants. */
+export type ButtonVariant = "Primary" | "Secondary" | "Text";
+export const ButtonVariant: Codec<ButtonVariant>;
+/** A clickable action button in a chat message. */
+export interface ChatAction {
+    /** Action identifier. */
+    actionId: string;
+    /** Button label. */
+    title: string;
+}
+export const ChatAction: Codec<ChatAction>;
+/** Layout for action buttons. */
+export type ChatActionLayout = "Column" | "Grid";
+export const ChatActionLayout: Codec<ChatActionLayout>;
+/** Payload of a received chat action. */
+export type ChatActionPayload = 
+/** A peer posted a message. */
+{
+    tag: "MessagePosted";
+    value: ChatMessageContent;
+}
+/** A user triggered an action button. */
+ | {
+    tag: "ActionTriggered";
+    value: ActionTrigger;
+}
+/** A user issued a command. */
+ | {
+    tag: "Command";
+    value: ChatCommand;
+};
+export const ChatActionPayload: Codec<ChatActionPayload>;
+/** A set of action buttons with optional text. */
+export interface ChatActions {
+    /** Optional message text. */
+    text?: string;
+    /** List of action buttons. */
+    actions: Array<ChatAction>;
+    /** \`Column\` or \`Grid\` layout. */
+    layout: ChatActionLayout;
+}
+export const ChatActions: Codec<ChatActions>;
+/** Whether the bot was newly registered or already existed. */
+export type ChatBotRegistrationStatus = "New" | "Exists";
+export const ChatBotRegistrationStatus: Codec<ChatBotRegistrationStatus>;
+/** A slash command from a chat user. */
+export interface ChatCommand {
+    /** Command name. */
+    command: string;
+    /** Command arguments. */
+    payload: string;
+}
+export const ChatCommand: Codec<ChatCommand>;
+/** A custom message with application-defined type and binary payload. */
+export interface ChatCustomMessage {
+    /** Application-defined type key. */
+    messageType: string;
+    /** Binary payload. */
+    payload: HexString;
+}
+export const ChatCustomMessage: Codec<ChatCustomMessage>;
+/** A file attachment in a chat message. */
+export interface ChatFile {
+    /** File download URL. */
+    url: string;
+    /** File name. */
+    fileName: string;
+    /** MIME type. */
+    mimeType: string;
+    /** File size in bytes. */
+    sizeBytes: bigint;
+    /** Optional caption text. */
+    text?: string;
+}
+export const ChatFile: Codec<ChatFile>;
+/** A media attachment. */
+export interface ChatMedia {
+    /** Media URL. */
+    url: string;
+}
+export const ChatMedia: Codec<ChatMedia>;
+/** Content of a chat message -- one of several types. */
+export type ChatMessageContent = 
+/** Plain text message. */
+{
+    tag: "Text";
+    value: {
+        text: string;
+    };
+}
+/** Rich text with media. */
+ | {
+    tag: "RichText";
+    value: ChatRichText;
+}
+/** Action button set. */
+ | {
+    tag: "Actions";
+    value: ChatActions;
+}
+/** File attachment. */
+ | {
+    tag: "File";
+    value: ChatFile;
+}
+/** Emoji reaction. */
+ | {
+    tag: "Reaction";
+    value: ChatReaction;
+}
+/** Reaction removal. */
+ | {
+    tag: "ReactionRemoved";
+    value: ChatReaction;
+}
+/** Custom message. */
+ | {
+    tag: "Custom";
+    value: ChatCustomMessage;
+};
+export const ChatMessageContent: Codec<ChatMessageContent>;
+/** A reaction to a chat message. */
+export interface ChatReaction {
+    /** Message being reacted to. */
+    messageId: string;
+    /** Emoji reaction. */
+    emoji: string;
+}
+export const ChatReaction: Codec<ChatReaction>;
+/** Rich text message with optional media. */
+export interface ChatRichText {
+    /** Optional text content. */
+    text?: string;
+    /** Attached media items. */
+    media: Array<ChatMedia>;
+}
+export const ChatRichText: Codec<ChatRichText>;
+/** A chat room the product participates in. */
+export interface ChatRoom {
+    /** Room identifier. */
+    roomId: string;
+    /** \`RoomHost\` or \`Bot\`. */
+    participatingAs: ChatRoomParticipation;
+}
+export const ChatRoom: Codec<ChatRoom>;
+/** How the product participates in a chat room. */
+export type ChatRoomParticipation = "RoomHost" | "Bot";
+export const ChatRoomParticipation: Codec<ChatRoomParticipation>;
+/** Whether the room was newly created or already existed. */
+export type ChatRoomRegistrationStatus = "New" | "Exists";
+export const ChatRoomRegistrationStatus: Codec<ChatRoomRegistrationStatus>;
+/** Semantic color tokens for theming. */
+export type ColorToken = "FgPrimary" | "FgSecondary" | "FgTertiary" | "BgSurfaceMain" | "BgSurfaceContainer" | "BgSurfaceNested" | "FgSuccess" | "FgError" | "FgWarning";
+export const ColorToken: Codec<ColorToken>;
+/** Properties for a [\`CustomRendererNode::Column\`] layout. */
+export interface ColumnProps {
+    /** Horizontal alignment of children. */
+    horizontalAlignment?: HorizontalAlignment;
+    /** Vertical arrangement of children. */
+    verticalArrangement?: Arrangement;
+}
+export const ColumnProps: Codec<ColumnProps>;
+/**
+ * A component in the custom renderer UI tree, combining modifiers, typed props,
+ * and recursive children.
+ */
+export interface Component<P> {
+    /** Layout and styling modifiers. */
+    modifiers: Array<Modifier>;
+    /** Component-specific properties. */
+    props: P;
+    /** Child nodes. */
+    children: Array<CustomRendererNode>;
+}
+/** Builds a codec for renderer components parameterized by the codec of their
+ * \`props\` payload. */
+export function Component<P>(pCodec: Codec<P>): Codec<Component<P>>;
+/** 2D content alignment. */
+export type ContentAlignment = "TopStart" | "TopCenter" | "TopEnd" | "CenterStart" | "Center" | "CenterEnd" | "BottomStart" | "BottomCenter" | "BottomEnd";
+export const ContentAlignment: Codec<ContentAlignment>;
+/**
+ * A node in the custom renderer UI tree. Can be nested recursively via the
+ * \`children\` field of each [\`Component\`].
+ */
+export type CustomRendererNode = 
+/** Empty node. */
+{
+    tag: "Nil";
+    value?: undefined;
+}
+/** Raw text string. */
+ | {
+    tag: "String";
+    value: {
+        text: string;
+    };
+}
+/** Generic container. */
+ | {
+    tag: "Box";
+    value: Component<BoxProps>;
+}
+/** Vertical layout. */
+ | {
+    tag: "Column";
+    value: Component<ColumnProps>;
+}
+/** Horizontal layout. */
+ | {
+    tag: "Row";
+    value: Component<RowProps>;
+}
+/** Flexible space. */
+ | {
+    tag: "Spacer";
+    value: Component<undefined>;
+}
+/** Text display. */
+ | {
+    tag: "Text";
+    value: Component<TextProps>;
+}
+/** Interactive button. */
+ | {
+    tag: "Button";
+    value: Component<ButtonProps>;
+}
+/** Text input. */
+ | {
+    tag: "TextField";
+    value: Component<TextFieldProps>;
+};
+export const CustomRendererNode: Codec<CustomRendererNode>;
+/**
+ * CSS-like dimensions: (top, end, bottom, start).
+ * Bottom defaults to top, start defaults to end when \`None\`.
+ */
+export interface Dimensions {
+    /** Top dimension. */
+    top: Size;
+    /** End dimension. */
+    end: Size;
+    /** Bottom dimension. Defaults to top when absent. */
+    bottom?: Size;
+    /** Start dimension. Defaults to end when absent. */
+    start?: Size;
+}
+export const Dimensions: Codec<Dimensions>;
+/**
+ * Generic error payload carrying a human-readable reason string. Used by many
+ * methods as a catch-all error type.
+ */
+export interface GenericError {
+    reason: string;
+}
+export const GenericError: Codec<GenericError>;
+/** A 32-byte chain genesis hash used to identify the target chain. */
+export type GenesisHash = HexString;
+export const GenesisHash: Codec<GenesisHash>;
+/** Horizontal alignment options. */
+export type HorizontalAlignment = "Start" | "Center" | "End";
+export const HorizontalAlignment: Codec<HorizontalAlignment>;
+/** Versioned envelope for [\`HostAccountConnectionStatusSubscribeItem\`]. */
+export type VersionedHostAccountConnectionStatusSubscribeItem = {
+    tag: "V1";
+    value: HostAccountConnectionStatusSubscribeItem;
+};
+export const VersionedHostAccountConnectionStatusSubscribeItem: Codec<VersionedHostAccountConnectionStatusSubscribeItem>;
+/** Versioned envelope for [\`HostAccountCreateProofError\`]. */
+export type VersionedHostAccountCreateProofError = {
+    tag: "V1";
+    value: HostAccountCreateProofError;
+};
+export const VersionedHostAccountCreateProofError: Codec<VersionedHostAccountCreateProofError>;
+/** Versioned envelope for [\`HostAccountCreateProofRequest\`]. */
+export type VersionedHostAccountCreateProofRequest = {
+    tag: "V1";
+    value: HostAccountCreateProofRequest;
+};
+export const VersionedHostAccountCreateProofRequest: Codec<VersionedHostAccountCreateProofRequest>;
+/** Versioned envelope for [\`HostAccountCreateProofResponse\`]. */
+export type VersionedHostAccountCreateProofResponse = {
+    tag: "V1";
+    value: HostAccountCreateProofResponse;
+};
+export const VersionedHostAccountCreateProofResponse: Codec<VersionedHostAccountCreateProofResponse>;
+/** Versioned envelope for [\`HostAccountGetAliasError\`]. */
+export type VersionedHostAccountGetAliasError = {
+    tag: "V1";
+    value: HostAccountGetError;
+};
+export const VersionedHostAccountGetAliasError: Codec<VersionedHostAccountGetAliasError>;
+/** Versioned envelope for [\`HostAccountGetAliasRequest\`]. */
+export type VersionedHostAccountGetAliasRequest = {
+    tag: "V1";
+    value: HostAccountGetAliasRequest;
+};
+export const VersionedHostAccountGetAliasRequest: Codec<VersionedHostAccountGetAliasRequest>;
+/** Versioned envelope for [\`HostAccountGetAliasResponse\`]. */
+export type VersionedHostAccountGetAliasResponse = {
+    tag: "V1";
+    value: HostAccountGetAliasResponse;
+};
+export const VersionedHostAccountGetAliasResponse: Codec<VersionedHostAccountGetAliasResponse>;
+/** Versioned envelope for [\`HostAccountGetError\`]. */
+export type VersionedHostAccountGetError = {
+    tag: "V1";
+    value: HostAccountGetError;
+};
+export const VersionedHostAccountGetError: Codec<VersionedHostAccountGetError>;
+/** Versioned envelope for [\`HostAccountGetRequest\`]. */
+export type VersionedHostAccountGetRequest = {
+    tag: "V1";
+    value: HostAccountGetRequest;
+};
+export const VersionedHostAccountGetRequest: Codec<VersionedHostAccountGetRequest>;
+/** Versioned envelope for [\`HostAccountGetResponse\`]. */
+export type VersionedHostAccountGetResponse = {
+    tag: "V1";
+    value: HostAccountGetResponse;
+};
+export const VersionedHostAccountGetResponse: Codec<VersionedHostAccountGetResponse>;
+/** Versioned envelope for [\`HostChatActionSubscribeItem\`]. */
+export type VersionedHostChatActionSubscribeItem = {
+    tag: "V1";
+    value: HostChatActionSubscribeItem;
+};
+export const VersionedHostChatActionSubscribeItem: Codec<VersionedHostChatActionSubscribeItem>;
+/** Versioned envelope for [\`HostChatCreateRoomError\`]. */
+export type VersionedHostChatCreateRoomError = {
+    tag: "V1";
+    value: HostChatCreateRoomError;
+};
+export const VersionedHostChatCreateRoomError: Codec<VersionedHostChatCreateRoomError>;
+/** Versioned envelope for [\`HostChatCreateRoomRequest\`]. */
+export type VersionedHostChatCreateRoomRequest = {
+    tag: "V1";
+    value: HostChatCreateRoomRequest;
+};
+export const VersionedHostChatCreateRoomRequest: Codec<VersionedHostChatCreateRoomRequest>;
+/** Versioned envelope for [\`HostChatCreateRoomResponse\`]. */
+export type VersionedHostChatCreateRoomResponse = {
+    tag: "V1";
+    value: HostChatCreateRoomResponse;
+};
+export const VersionedHostChatCreateRoomResponse: Codec<VersionedHostChatCreateRoomResponse>;
+/** Versioned envelope for [\`HostChatListSubscribeItem\`]. */
+export type VersionedHostChatListSubscribeItem = {
+    tag: "V1";
+    value: HostChatListSubscribeItem;
+};
+export const VersionedHostChatListSubscribeItem: Codec<VersionedHostChatListSubscribeItem>;
+/** Versioned envelope for [\`HostChatPostMessageError\`]. */
+export type VersionedHostChatPostMessageError = {
+    tag: "V1";
+    value: HostChatPostMessageError;
+};
+export const VersionedHostChatPostMessageError: Codec<VersionedHostChatPostMessageError>;
+/** Versioned envelope for [\`HostChatPostMessageRequest\`]. */
+export type VersionedHostChatPostMessageRequest = {
+    tag: "V1";
+    value: HostChatPostMessageRequest;
+};
+export const VersionedHostChatPostMessageRequest: Codec<VersionedHostChatPostMessageRequest>;
+/** Versioned envelope for [\`HostChatPostMessageResponse\`]. */
+export type VersionedHostChatPostMessageResponse = {
+    tag: "V1";
+    value: HostChatPostMessageResponse;
+};
+export const VersionedHostChatPostMessageResponse: Codec<VersionedHostChatPostMessageResponse>;
+/** Versioned envelope for [\`HostChatRegisterBotError\`]. */
+export type VersionedHostChatRegisterBotError = {
+    tag: "V1";
+    value: HostChatRegisterBotError;
+};
+export const VersionedHostChatRegisterBotError: Codec<VersionedHostChatRegisterBotError>;
+/** Versioned envelope for [\`HostChatRegisterBotRequest\`]. */
+export type VersionedHostChatRegisterBotRequest = {
+    tag: "V1";
+    value: HostChatRegisterBotRequest;
+};
+export const VersionedHostChatRegisterBotRequest: Codec<VersionedHostChatRegisterBotRequest>;
+/** Versioned envelope for [\`HostChatRegisterBotResponse\`]. */
+export type VersionedHostChatRegisterBotResponse = {
+    tag: "V1";
+    value: HostChatRegisterBotResponse;
+};
+export const VersionedHostChatRegisterBotResponse: Codec<VersionedHostChatRegisterBotResponse>;
+/** Versioned envelope for [\`HostCreateTransactionError\`]. */
+export type VersionedHostCreateTransactionError = {
+    tag: "V1";
+    value: HostCreateTransactionError;
+};
+export const VersionedHostCreateTransactionError: Codec<VersionedHostCreateTransactionError>;
+/** Versioned envelope for [\`HostCreateTransactionRequest\`]. */
+export type VersionedHostCreateTransactionRequest = {
+    tag: "V1";
+    value: ProductAccountTxPayload;
+};
+export const VersionedHostCreateTransactionRequest: Codec<VersionedHostCreateTransactionRequest>;
+/** Versioned envelope for [\`HostCreateTransactionResponse\`]. */
+export type VersionedHostCreateTransactionResponse = {
+    tag: "V1";
+    value: HostCreateTransactionResponse;
+};
+export const VersionedHostCreateTransactionResponse: Codec<VersionedHostCreateTransactionResponse>;
+/** Versioned envelope for [\`HostCreateTransactionWithLegacyAccountError\`]. */
+export type VersionedHostCreateTransactionWithLegacyAccountError = {
+    tag: "V1";
+    value: HostCreateTransactionError;
+};
+export const VersionedHostCreateTransactionWithLegacyAccountError: Codec<VersionedHostCreateTransactionWithLegacyAccountError>;
+/** Versioned envelope for [\`HostCreateTransactionWithLegacyAccountRequest\`]. */
+export type VersionedHostCreateTransactionWithLegacyAccountRequest = {
+    tag: "V1";
+    value: LegacyAccountTxPayload;
+};
+export const VersionedHostCreateTransactionWithLegacyAccountRequest: Codec<VersionedHostCreateTransactionWithLegacyAccountRequest>;
+/** Versioned envelope for [\`HostCreateTransactionWithLegacyAccountResponse\`]. */
+export type VersionedHostCreateTransactionWithLegacyAccountResponse = {
+    tag: "V1";
+    value: HostCreateTransactionWithLegacyAccountResponse;
+};
+export const VersionedHostCreateTransactionWithLegacyAccountResponse: Codec<VersionedHostCreateTransactionWithLegacyAccountResponse>;
+/** Versioned envelope for [\`HostDeriveEntropyError\`]. */
+export type VersionedHostDeriveEntropyError = {
+    tag: "V1";
+    value: HostDeriveEntropyError;
+};
+export const VersionedHostDeriveEntropyError: Codec<VersionedHostDeriveEntropyError>;
+/** Versioned envelope for [\`HostDeriveEntropyRequest\`]. */
+export type VersionedHostDeriveEntropyRequest = {
+    tag: "V1";
+    value: HostDeriveEntropyRequest;
+};
+export const VersionedHostDeriveEntropyRequest: Codec<VersionedHostDeriveEntropyRequest>;
+/** Versioned envelope for [\`HostDeriveEntropyResponse\`]. */
+export type VersionedHostDeriveEntropyResponse = {
+    tag: "V1";
+    value: HostDeriveEntropyResponse;
+};
+export const VersionedHostDeriveEntropyResponse: Codec<VersionedHostDeriveEntropyResponse>;
+/** Versioned envelope for [\`HostDevicePermissionError\`]. */
+export type VersionedHostDevicePermissionError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedHostDevicePermissionError: Codec<VersionedHostDevicePermissionError>;
+/** Versioned envelope for [\`HostDevicePermissionRequest\`]. */
+export type VersionedHostDevicePermissionRequest = {
+    tag: "V1";
+    value: HostDevicePermissionRequest;
+};
+export const VersionedHostDevicePermissionRequest: Codec<VersionedHostDevicePermissionRequest>;
+/** Versioned envelope for [\`HostDevicePermissionResponse\`]. */
+export type VersionedHostDevicePermissionResponse = {
+    tag: "V1";
+    value: HostDevicePermissionResponse;
+};
+export const VersionedHostDevicePermissionResponse: Codec<VersionedHostDevicePermissionResponse>;
+/** Versioned envelope for [\`HostFeatureSupportedError\`]. */
+export type VersionedHostFeatureSupportedError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedHostFeatureSupportedError: Codec<VersionedHostFeatureSupportedError>;
+/** Versioned envelope for [\`HostFeatureSupportedRequest\`]. */
+export type VersionedHostFeatureSupportedRequest = {
+    tag: "V1";
+    value: HostFeatureSupportedRequest;
+};
+export const VersionedHostFeatureSupportedRequest: Codec<VersionedHostFeatureSupportedRequest>;
+/** Versioned envelope for [\`HostFeatureSupportedResponse\`]. */
+export type VersionedHostFeatureSupportedResponse = {
+    tag: "V1";
+    value: HostFeatureSupportedResponse;
+};
+export const VersionedHostFeatureSupportedResponse: Codec<VersionedHostFeatureSupportedResponse>;
+/** Versioned envelope for [\`HostGetLegacyAccountsError\`]. */
+export type VersionedHostGetLegacyAccountsError = {
+    tag: "V1";
+    value: HostAccountGetError;
+};
+export const VersionedHostGetLegacyAccountsError: Codec<VersionedHostGetLegacyAccountsError>;
+/** Versioned envelope for [\`HostGetLegacyAccountsRequest\`]. */
+export type VersionedHostGetLegacyAccountsRequest = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostGetLegacyAccountsRequest: Codec<VersionedHostGetLegacyAccountsRequest>;
+/** Versioned envelope for [\`HostGetLegacyAccountsResponse\`]. */
+export type VersionedHostGetLegacyAccountsResponse = {
+    tag: "V1";
+    value: HostGetLegacyAccountsResponse;
+};
+export const VersionedHostGetLegacyAccountsResponse: Codec<VersionedHostGetLegacyAccountsResponse>;
+/** Versioned envelope for [\`HostGetUserIdError\`]. */
+export type VersionedHostGetUserIdError = {
+    tag: "V1";
+    value: HostGetUserIdError;
+};
+export const VersionedHostGetUserIdError: Codec<VersionedHostGetUserIdError>;
+/** Versioned envelope for [\`HostGetUserIdRequest\`]. */
+export type VersionedHostGetUserIdRequest = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostGetUserIdRequest: Codec<VersionedHostGetUserIdRequest>;
+/** Versioned envelope for [\`HostGetUserIdResponse\`]. */
+export type VersionedHostGetUserIdResponse = {
+    tag: "V1";
+    value: HostGetUserIdResponse;
+};
+export const VersionedHostGetUserIdResponse: Codec<VersionedHostGetUserIdResponse>;
+/** Versioned envelope for [\`HostHandshakeError\`]. */
+export type VersionedHostHandshakeError = {
+    tag: "V1";
+    value: HostHandshakeError;
+};
+export const VersionedHostHandshakeError: Codec<VersionedHostHandshakeError>;
+/** Versioned envelope for [\`HostHandshakeRequest\`]. */
+export type VersionedHostHandshakeRequest = {
+    tag: "V1";
+    value: HostHandshakeRequest;
+};
+export const VersionedHostHandshakeRequest: Codec<VersionedHostHandshakeRequest>;
+/** Versioned envelope for [\`HostHandshakeResponse\`]. */
+export type VersionedHostHandshakeResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostHandshakeResponse: Codec<VersionedHostHandshakeResponse>;
+/** Versioned envelope for [\`HostLocalStorageClearError\`]. */
+export type VersionedHostLocalStorageClearError = {
+    tag: "V1";
+    value: HostLocalStorageReadError;
+};
+export const VersionedHostLocalStorageClearError: Codec<VersionedHostLocalStorageClearError>;
+/** Versioned envelope for [\`HostLocalStorageClearRequest\`]. */
+export type VersionedHostLocalStorageClearRequest = {
+    tag: "V1";
+    value: HostLocalStorageClearRequest;
+};
+export const VersionedHostLocalStorageClearRequest: Codec<VersionedHostLocalStorageClearRequest>;
+/** Versioned envelope for [\`HostLocalStorageClearResponse\`]. */
+export type VersionedHostLocalStorageClearResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostLocalStorageClearResponse: Codec<VersionedHostLocalStorageClearResponse>;
+/** Versioned envelope for [\`HostLocalStorageReadError\`]. */
+export type VersionedHostLocalStorageReadError = {
+    tag: "V1";
+    value: HostLocalStorageReadError;
+};
+export const VersionedHostLocalStorageReadError: Codec<VersionedHostLocalStorageReadError>;
+/** Versioned envelope for [\`HostLocalStorageReadRequest\`]. */
+export type VersionedHostLocalStorageReadRequest = {
+    tag: "V1";
+    value: HostLocalStorageReadRequest;
+};
+export const VersionedHostLocalStorageReadRequest: Codec<VersionedHostLocalStorageReadRequest>;
+/** Versioned envelope for [\`HostLocalStorageReadResponse\`]. */
+export type VersionedHostLocalStorageReadResponse = {
+    tag: "V1";
+    value: HostLocalStorageReadResponse;
+};
+export const VersionedHostLocalStorageReadResponse: Codec<VersionedHostLocalStorageReadResponse>;
+/** Versioned envelope for [\`HostLocalStorageWriteError\`]. */
+export type VersionedHostLocalStorageWriteError = {
+    tag: "V1";
+    value: HostLocalStorageReadError;
+};
+export const VersionedHostLocalStorageWriteError: Codec<VersionedHostLocalStorageWriteError>;
+/** Versioned envelope for [\`HostLocalStorageWriteRequest\`]. */
+export type VersionedHostLocalStorageWriteRequest = {
+    tag: "V1";
+    value: HostLocalStorageWriteRequest;
+};
+export const VersionedHostLocalStorageWriteRequest: Codec<VersionedHostLocalStorageWriteRequest>;
+/** Versioned envelope for [\`HostLocalStorageWriteResponse\`]. */
+export type VersionedHostLocalStorageWriteResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostLocalStorageWriteResponse: Codec<VersionedHostLocalStorageWriteResponse>;
+/** Versioned envelope for [\`HostNavigateToError\`]. */
+export type VersionedHostNavigateToError = {
+    tag: "V1";
+    value: HostNavigateToError;
+};
+export const VersionedHostNavigateToError: Codec<VersionedHostNavigateToError>;
+/** Versioned envelope for [\`HostNavigateToRequest\`]. */
+export type VersionedHostNavigateToRequest = {
+    tag: "V1";
+    value: HostNavigateToRequest;
+};
+export const VersionedHostNavigateToRequest: Codec<VersionedHostNavigateToRequest>;
+/** Versioned envelope for [\`HostNavigateToResponse\`]. */
+export type VersionedHostNavigateToResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostNavigateToResponse: Codec<VersionedHostNavigateToResponse>;
+/** Versioned envelope for [\`HostPaymentBalanceSubscribeError\`]. */
+export type VersionedHostPaymentBalanceSubscribeError = {
+    tag: "V1";
+    value: HostPaymentBalanceSubscribeError;
+};
+export const VersionedHostPaymentBalanceSubscribeError: Codec<VersionedHostPaymentBalanceSubscribeError>;
+/** Versioned envelope for [\`HostPaymentBalanceSubscribeItem\`]. */
+export type VersionedHostPaymentBalanceSubscribeItem = {
+    tag: "V1";
+    value: HostPaymentBalanceSubscribeItem;
+};
+export const VersionedHostPaymentBalanceSubscribeItem: Codec<VersionedHostPaymentBalanceSubscribeItem>;
+/** Versioned envelope for [\`HostPaymentBalanceSubscribeRequest\`]. */
+export type VersionedHostPaymentBalanceSubscribeRequest = {
+    tag: "V1";
+    value: HostPaymentBalanceSubscribeRequest;
+};
+export const VersionedHostPaymentBalanceSubscribeRequest: Codec<VersionedHostPaymentBalanceSubscribeRequest>;
+/** Versioned envelope for [\`HostPaymentError\`]. */
+export type VersionedHostPaymentError = {
+    tag: "V1";
+    value: HostPaymentError;
+};
+export const VersionedHostPaymentError: Codec<VersionedHostPaymentError>;
+/** Versioned envelope for [\`HostPaymentRequest\`]. */
+export type VersionedHostPaymentRequest = {
+    tag: "V1";
+    value: HostPaymentRequest;
+};
+export const VersionedHostPaymentRequest: Codec<VersionedHostPaymentRequest>;
+/** Versioned envelope for [\`HostPaymentResponse\`]. */
+export type VersionedHostPaymentResponse = {
+    tag: "V1";
+    value: HostPaymentResponse;
+};
+export const VersionedHostPaymentResponse: Codec<VersionedHostPaymentResponse>;
+/** Versioned envelope for [\`HostPaymentStatusSubscribeError\`]. */
+export type VersionedHostPaymentStatusSubscribeError = {
+    tag: "V1";
+    value: HostPaymentStatusSubscribeError;
+};
+export const VersionedHostPaymentStatusSubscribeError: Codec<VersionedHostPaymentStatusSubscribeError>;
+/** Versioned envelope for [\`HostPaymentStatusSubscribeItem\`]. */
+export type VersionedHostPaymentStatusSubscribeItem = {
+    tag: "V1";
+    value: HostPaymentStatusSubscribeItem;
+};
+export const VersionedHostPaymentStatusSubscribeItem: Codec<VersionedHostPaymentStatusSubscribeItem>;
+/** Versioned envelope for [\`HostPaymentStatusSubscribeRequest\`]. */
+export type VersionedHostPaymentStatusSubscribeRequest = {
+    tag: "V1";
+    value: HostPaymentStatusSubscribeRequest;
+};
+export const VersionedHostPaymentStatusSubscribeRequest: Codec<VersionedHostPaymentStatusSubscribeRequest>;
+/** Versioned envelope for [\`HostPaymentTopUpError\`]. */
+export type VersionedHostPaymentTopUpError = {
+    tag: "V1";
+    value: HostPaymentTopUpError;
+};
+export const VersionedHostPaymentTopUpError: Codec<VersionedHostPaymentTopUpError>;
+/** Versioned envelope for [\`HostPaymentTopUpRequest\`]. */
+export type VersionedHostPaymentTopUpRequest = {
+    tag: "V1";
+    value: HostPaymentTopUpRequest;
+};
+export const VersionedHostPaymentTopUpRequest: Codec<VersionedHostPaymentTopUpRequest>;
+/** Versioned envelope for [\`HostPaymentTopUpResponse\`]. */
+export type VersionedHostPaymentTopUpResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostPaymentTopUpResponse: Codec<VersionedHostPaymentTopUpResponse>;
+/** Versioned envelope for [\`HostPushNotificationCancelError\`]. */
+export type VersionedHostPushNotificationCancelError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedHostPushNotificationCancelError: Codec<VersionedHostPushNotificationCancelError>;
+/** Versioned envelope for [\`HostPushNotificationCancelRequest\`]. */
+export type VersionedHostPushNotificationCancelRequest = {
+    tag: "V1";
+    value: HostPushNotificationCancelRequest;
+};
+export const VersionedHostPushNotificationCancelRequest: Codec<VersionedHostPushNotificationCancelRequest>;
+/** Versioned envelope for [\`HostPushNotificationCancelResponse\`]. */
+export type VersionedHostPushNotificationCancelResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedHostPushNotificationCancelResponse: Codec<VersionedHostPushNotificationCancelResponse>;
+/** Versioned envelope for [\`HostPushNotificationError\`]. */
+export type VersionedHostPushNotificationError = {
+    tag: "V1";
+    value: HostPushNotificationError;
+};
+export const VersionedHostPushNotificationError: Codec<VersionedHostPushNotificationError>;
+/** Versioned envelope for [\`HostPushNotificationRequest\`]. */
+export type VersionedHostPushNotificationRequest = {
+    tag: "V1";
+    value: HostPushNotificationRequest;
+};
+export const VersionedHostPushNotificationRequest: Codec<VersionedHostPushNotificationRequest>;
+/** Versioned envelope for [\`HostPushNotificationResponse\`]. */
+export type VersionedHostPushNotificationResponse = {
+    tag: "V1";
+    value: HostPushNotificationResponse;
+};
+export const VersionedHostPushNotificationResponse: Codec<VersionedHostPushNotificationResponse>;
+/** Versioned envelope for [\`HostRequestLoginError\`]. */
+export type VersionedHostRequestLoginError = {
+    tag: "V1";
+    value: HostRequestLoginError;
+};
+export const VersionedHostRequestLoginError: Codec<VersionedHostRequestLoginError>;
+/** Versioned envelope for [\`HostRequestLoginRequest\`]. */
+export type VersionedHostRequestLoginRequest = {
+    tag: "V1";
+    value: HostRequestLoginRequest;
+};
+export const VersionedHostRequestLoginRequest: Codec<VersionedHostRequestLoginRequest>;
+/** Versioned envelope for [\`HostRequestLoginResponse\`]. */
+export type VersionedHostRequestLoginResponse = {
+    tag: "V1";
+    value: HostRequestLoginResponse;
+};
+export const VersionedHostRequestLoginResponse: Codec<VersionedHostRequestLoginResponse>;
+/** Versioned envelope for [\`HostRequestResourceAllocationError\`]. */
+export type VersionedHostRequestResourceAllocationError = {
+    tag: "V1";
+    value: ResourceAllocationError;
+};
+export const VersionedHostRequestResourceAllocationError: Codec<VersionedHostRequestResourceAllocationError>;
+/** Versioned envelope for [\`HostRequestResourceAllocationRequest\`]. */
+export type VersionedHostRequestResourceAllocationRequest = {
+    tag: "V1";
+    value: HostRequestResourceAllocationRequest;
+};
+export const VersionedHostRequestResourceAllocationRequest: Codec<VersionedHostRequestResourceAllocationRequest>;
+/** Versioned envelope for [\`HostRequestResourceAllocationResponse\`]. */
+export type VersionedHostRequestResourceAllocationResponse = {
+    tag: "V1";
+    value: HostRequestResourceAllocationResponse;
+};
+export const VersionedHostRequestResourceAllocationResponse: Codec<VersionedHostRequestResourceAllocationResponse>;
+/**
+ * Full Substrate extrinsic signing payload with all fields needed for signature
+ * generation.
+ */
+export interface HostSignPayloadData {
+    /** Reference block hash. */
+    blockHash: HexString;
+    /** Reference block number. */
+    blockNumber: HexString;
+    /** Mortality era encoding. */
+    era: HexString;
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** SCALE-encoded call data. */
+    method: HexString;
+    /** Account nonce. */
+    nonce: HexString;
+    /** Runtime spec version. */
+    specVersion: HexString;
+    /** Transaction tip. */
+    tip: HexString;
+    /** Transaction format version. */
+    transactionVersion: HexString;
+    /** Extension identifiers. */
+    signedExtensions: Array<string>;
+    /** Extrinsic version. */
+    version: number;
+    /** For multi-asset tips. */
+    assetId?: HexString;
+    /** CheckMetadataHash extension. */
+    metadataHash?: HexString;
+    /** Metadata mode. */
+    mode?: number;
+    /** Request signed transaction back. */
+    withSignedTransaction?: boolean;
+}
+export const HostSignPayloadData: Codec<HostSignPayloadData>;
+/** Versioned envelope for [\`HostSignPayloadError\`]. */
+export type VersionedHostSignPayloadError = {
+    tag: "V1";
+    value: HostSignPayloadError;
+};
+export const VersionedHostSignPayloadError: Codec<VersionedHostSignPayloadError>;
+/** Versioned envelope for [\`HostSignPayloadRequest\`]. */
+export type VersionedHostSignPayloadRequest = {
+    tag: "V1";
+    value: HostSignPayloadRequest;
+};
+export const VersionedHostSignPayloadRequest: Codec<VersionedHostSignPayloadRequest>;
+/** Versioned envelope for [\`HostSignPayloadResponse\`]. */
+export type VersionedHostSignPayloadResponse = {
+    tag: "V1";
+    value: HostSignPayloadResponse;
+};
+export const VersionedHostSignPayloadResponse: Codec<VersionedHostSignPayloadResponse>;
+/** Versioned envelope for [\`HostSignPayloadWithLegacyAccountError\`]. */
+export type VersionedHostSignPayloadWithLegacyAccountError = {
+    tag: "V1";
+    value: HostSignPayloadError;
+};
+export const VersionedHostSignPayloadWithLegacyAccountError: Codec<VersionedHostSignPayloadWithLegacyAccountError>;
+/** Versioned envelope for [\`HostSignPayloadWithLegacyAccountRequest\`]. */
+export type VersionedHostSignPayloadWithLegacyAccountRequest = {
+    tag: "V1";
+    value: HostSignPayloadWithLegacyAccountRequest;
+};
+export const VersionedHostSignPayloadWithLegacyAccountRequest: Codec<VersionedHostSignPayloadWithLegacyAccountRequest>;
+/** Versioned envelope for [\`HostSignPayloadWithLegacyAccountResponse\`]. */
+export type VersionedHostSignPayloadWithLegacyAccountResponse = {
+    tag: "V1";
+    value: HostSignPayloadResponse;
+};
+export const VersionedHostSignPayloadWithLegacyAccountResponse: Codec<VersionedHostSignPayloadWithLegacyAccountResponse>;
+/** Versioned envelope for [\`HostSignRawError\`]. */
+export type VersionedHostSignRawError = {
+    tag: "V1";
+    value: HostSignPayloadError;
+};
+export const VersionedHostSignRawError: Codec<VersionedHostSignRawError>;
+/** Versioned envelope for [\`HostSignRawRequest\`]. */
+export type VersionedHostSignRawRequest = {
+    tag: "V1";
+    value: HostSignRawRequest;
+};
+export const VersionedHostSignRawRequest: Codec<VersionedHostSignRawRequest>;
+/** Versioned envelope for [\`HostSignRawResponse\`]. */
+export type VersionedHostSignRawResponse = {
+    tag: "V1";
+    value: HostSignPayloadResponse;
+};
+export const VersionedHostSignRawResponse: Codec<VersionedHostSignRawResponse>;
+/** Versioned envelope for [\`HostSignRawWithLegacyAccountError\`]. */
+export type VersionedHostSignRawWithLegacyAccountError = {
+    tag: "V1";
+    value: HostSignPayloadError;
+};
+export const VersionedHostSignRawWithLegacyAccountError: Codec<VersionedHostSignRawWithLegacyAccountError>;
+/** Versioned envelope for [\`HostSignRawWithLegacyAccountRequest\`]. */
+export type VersionedHostSignRawWithLegacyAccountRequest = {
+    tag: "V1";
+    value: HostSignRawWithLegacyAccountRequest;
+};
+export const VersionedHostSignRawWithLegacyAccountRequest: Codec<VersionedHostSignRawWithLegacyAccountRequest>;
+/** Versioned envelope for [\`HostSignRawWithLegacyAccountResponse\`]. */
+export type VersionedHostSignRawWithLegacyAccountResponse = {
+    tag: "V1";
+    value: HostSignPayloadResponse;
+};
+export const VersionedHostSignRawWithLegacyAccountResponse: Codec<VersionedHostSignRawWithLegacyAccountResponse>;
+/** Versioned envelope for [\`HostThemeSubscribeItem\`]. */
+export type VersionedHostThemeSubscribeItem = {
+    tag: "V1";
+    value: HostThemeSubscribeItem;
+};
+export const VersionedHostThemeSubscribeItem: Codec<VersionedHostThemeSubscribeItem>;
+/**
+ * A user-imported (legacy) account: public key plus an optional user-chosen
+ * display name.
+ *
+ * Returned by [\`HostGetLegacyAccountsResponse\`]. Distinct from
+ * [\`ProductAccount\`], which is protocol-derived and never carries a label.
+ */
+export interface LegacyAccount {
+    /** The account public key (variable-length bytes). */
+    publicKey: HexString;
+    /** Optional user-chosen display name. */
+    name?: string;
+}
+export const LegacyAccount: Codec<LegacyAccount>;
+/**
+ * Transaction payload for a legacy (non-product) account.
+ *
+ * Identical to [\`ProductAccountTxPayload\`] except the signer is a raw
+ * 32-byte [\`AccountId\`].
+ */
+export interface LegacyAccountTxPayload {
+    /** Raw 32-byte public key of the legacy account. */
+    signer: AccountId;
+    /** Chain where the transaction will execute. */
+    genesisHash: GenesisHash;
+    /** SCALE-encoded Call data. */
+    callData: HexString;
+    /** Transaction extensions supplied by the caller. */
+    extensions: Array<TxPayloadExtension>;
+    /** 0 for Extrinsic V4, runtime-supported value for V5. */
+    txExtVersion: number;
+}
+export const LegacyAccountTxPayload: Codec<LegacyAccountTxPayload>;
+/** Layout and styling modifiers applied to custom renderer components. */
+export type Modifier = 
+/** Outer spacing. */
+{
+    tag: "Margin";
+    value: Dimensions;
+}
+/** Inner spacing. */
+ | {
+    tag: "Padding";
+    value: Dimensions;
+}
+/** Background fill. */
+ | {
+    tag: "Background";
+    value: Background;
+}
+/** Border style. */
+ | {
+    tag: "Border";
+    value: BorderStyle;
+}
+/** Fixed height. */
+ | {
+    tag: "Height";
+    value: {
+        height: Size;
+    };
+}
+/** Fixed width. */
+ | {
+    tag: "Width";
+    value: {
+        width: Size;
+    };
+}
+/** Minimum width. */
+ | {
+    tag: "MinWidth";
+    value: {
+        width: Size;
+    };
+}
+/** Minimum height. */
+ | {
+    tag: "MinHeight";
+    value: {
+        height: Size;
+    };
+}
+/** Fill available width. */
+ | {
+    tag: "FillWidth";
+    value: {
+        enabled: boolean;
+    };
+}
+/** Fill available height. */
+ | {
+    tag: "FillHeight";
+    value: {
+        enabled: boolean;
+    };
+};
+export const Modifier: Codec<Modifier>;
+/** Opaque identifier for a push notification, unique per product. */
+export type NotificationId = number;
+export const NotificationId: Codec<NotificationId>;
+export type OperationStartedResult = {
+    tag: "Started";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "LimitReached";
+    value?: undefined;
+};
+export const OperationStartedResult: Codec<OperationStartedResult>;
+/** Identifier selecting a product payment purse. */
+export type PaymentPurseId = number;
+export const PaymentPurseId: Codec<PaymentPurseId>;
+/**
+ * Source for a payment top-up operation.
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export type PaymentTopUpSource = 
+/** Fund from one of the calling product's scoped accounts. */
+{
+    tag: "ProductAccount";
+    value: {
+        derivationIndex: number;
+    };
+}
+/**
+ * Fund from a one-time account represented by its private key. This is a
+ * standard account holding public funds, not a coin key.
+ */
+ | {
+    tag: "PrivateKey";
+    value: {
+        sr25519SecretKey: HexString;
+    };
+}
+/**
+ * Fund directly from coin secret keys. Each key is an sr25519 secret
+ * controlling a single coin.
+ */
+ | {
+    tag: "Coins";
+    value: {
+        sr25519SecretKeys: Array<HexString>;
+    };
+};
+export const PaymentTopUpSource: Codec<PaymentTopUpSource>;
+/** Preimage submission error. */
+export type PreimageSubmitError = 
+/** Catch-all. */
+{
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const PreimageSubmitError: Codec<PreimageSubmitError>;
+/** A product account: public key only, no display name. */
+export interface ProductAccount {
+    /** The account public key (variable-length bytes). */
+    publicKey: HexString;
+}
+export const ProductAccount: Codec<ProductAccount>;
+/**
+ * Identifies a product-specific account by combining a dotNS domain name with a
+ * derivation index.
+ */
+export interface ProductAccountId {
+    /** A dotNS domain name identifier (e.g., \`"my-product.dot"\`). */
+    dotNsIdentifier: string;
+    /** Key derivation index for generating product-specific accounts. */
+    derivationIndex: number;
+}
+export const ProductAccountId: Codec<ProductAccountId>;
+/**
+ * Transaction payload for a product account.
+ *
+ * Contains everything the host needs to construct a signed extrinsic.
+ * The signer is a [\`ProductAccountId\`]; the host resolves the
+ * corresponding key pair through its account management layer.
+ */
+export interface ProductAccountTxPayload {
+    /** Product account that will sign the transaction. */
+    signer: ProductAccountId;
+    /** Chain where the transaction will execute. */
+    genesisHash: GenesisHash;
+    /** SCALE-encoded Call data. */
+    callData: HexString;
+    /** Transaction extensions supplied by the caller. */
+    extensions: Array<TxPayloadExtension>;
+    /** 0 for Extrinsic V4, runtime-supported value for V5. */
+    txExtVersion: number;
+}
+export const ProductAccountTxPayload: Codec<ProductAccountTxPayload>;
+/** Versioned envelope for [\`ProductChatCustomMessageRenderSubscribeItem\`]. */
+export type VersionedProductChatCustomMessageRenderSubscribeItem = {
+    tag: "V1";
+    value: CustomRendererNode;
+};
+export const VersionedProductChatCustomMessageRenderSubscribeItem: Codec<VersionedProductChatCustomMessageRenderSubscribeItem>;
+/** Versioned envelope for [\`ProductChatCustomMessageRenderSubscribeRequest\`]. */
+export type VersionedProductChatCustomMessageRenderSubscribeRequest = {
+    tag: "V1";
+    value: ProductChatCustomMessageRenderSubscribeRequest;
+};
+export const VersionedProductChatCustomMessageRenderSubscribeRequest: Codec<VersionedProductChatCustomMessageRenderSubscribeRequest>;
+/** Raw data to sign -- either binary bytes or a string message. */
+export type RawPayload = 
+/** Raw binary data to sign. */
+{
+    tag: "Bytes";
+    value: {
+        bytes: HexString;
+    };
+}
+/** String message to sign. */
+ | {
+    tag: "Payload";
+    value: {
+        payload: string;
+    };
+};
+export const RawPayload: Codec<RawPayload>;
+/** Versioned envelope for [\`RemoteChainHeadBodyError\`]. */
+export type VersionedRemoteChainHeadBodyError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainHeadBodyError: Codec<VersionedRemoteChainHeadBodyError>;
+/** Versioned envelope for [\`RemoteChainHeadBodyRequest\`]. */
+export type VersionedRemoteChainHeadBodyRequest = {
+    tag: "V1";
+    value: RemoteChainHeadBodyRequest;
+};
+export const VersionedRemoteChainHeadBodyRequest: Codec<VersionedRemoteChainHeadBodyRequest>;
+/** Versioned envelope for [\`RemoteChainHeadBodyResponse\`]. */
+export type VersionedRemoteChainHeadBodyResponse = {
+    tag: "V1";
+    value: RemoteChainHeadBodyResponse;
+};
+export const VersionedRemoteChainHeadBodyResponse: Codec<VersionedRemoteChainHeadBodyResponse>;
+/** Versioned envelope for [\`RemoteChainHeadCallError\`]. */
+export type VersionedRemoteChainHeadCallError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainHeadCallError: Codec<VersionedRemoteChainHeadCallError>;
+/** Versioned envelope for [\`RemoteChainHeadCallRequest\`]. */
+export type VersionedRemoteChainHeadCallRequest = {
+    tag: "V1";
+    value: RemoteChainHeadCallRequest;
+};
+export const VersionedRemoteChainHeadCallRequest: Codec<VersionedRemoteChainHeadCallRequest>;
+/** Versioned envelope for [\`RemoteChainHeadCallResponse\`]. */
+export type VersionedRemoteChainHeadCallResponse = {
+    tag: "V1";
+    value: RemoteChainHeadCallResponse;
+};
+export const VersionedRemoteChainHeadCallResponse: Codec<VersionedRemoteChainHeadCallResponse>;
+/** Versioned envelope for [\`RemoteChainHeadContinueError\`]. */
+export type VersionedRemoteChainHeadContinueError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainHeadContinueError: Codec<VersionedRemoteChainHeadContinueError>;
+/** Versioned envelope for [\`RemoteChainHeadContinueRequest\`]. */
+export type VersionedRemoteChainHeadContinueRequest = {
+    tag: "V1";
+    value: RemoteChainHeadContinueRequest;
+};
+export const VersionedRemoteChainHeadContinueRequest: Codec<VersionedRemoteChainHeadContinueRequest>;
+/** Versioned envelope for [\`RemoteChainHeadContinueResponse\`]. */
+export type VersionedRemoteChainHeadContinueResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedRemoteChainHeadContinueResponse: Codec<VersionedRemoteChainHeadContinueResponse>;
+/** Versioned envelope for [\`RemoteChainHeadFollowItem\`]. */
+export type VersionedRemoteChainHeadFollowItem = {
+    tag: "V1";
+    value: RemoteChainHeadFollowItem;
+};
+export const VersionedRemoteChainHeadFollowItem: Codec<VersionedRemoteChainHeadFollowItem>;
+/** Versioned envelope for [\`RemoteChainHeadFollowRequest\`]. */
+export type VersionedRemoteChainHeadFollowRequest = {
+    tag: "V1";
+    value: RemoteChainHeadFollowRequest;
+};
+export const VersionedRemoteChainHeadFollowRequest: Codec<VersionedRemoteChainHeadFollowRequest>;
+/** Versioned envelope for [\`RemoteChainHeadHeaderError\`]. */
+export type VersionedRemoteChainHeadHeaderError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainHeadHeaderError: Codec<VersionedRemoteChainHeadHeaderError>;
+/** Versioned envelope for [\`RemoteChainHeadHeaderRequest\`]. */
+export type VersionedRemoteChainHeadHeaderRequest = {
+    tag: "V1";
+    value: RemoteChainHeadHeaderRequest;
+};
+export const VersionedRemoteChainHeadHeaderRequest: Codec<VersionedRemoteChainHeadHeaderRequest>;
+/** Versioned envelope for [\`RemoteChainHeadHeaderResponse\`]. */
+export type VersionedRemoteChainHeadHeaderResponse = {
+    tag: "V1";
+    value: RemoteChainHeadHeaderResponse;
+};
+export const VersionedRemoteChainHeadHeaderResponse: Codec<VersionedRemoteChainHeadHeaderResponse>;
+/** Versioned envelope for [\`RemoteChainHeadStopOperationError\`]. */
+export type VersionedRemoteChainHeadStopOperationError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainHeadStopOperationError: Codec<VersionedRemoteChainHeadStopOperationError>;
+/** Versioned envelope for [\`RemoteChainHeadStopOperationRequest\`]. */
+export type VersionedRemoteChainHeadStopOperationRequest = {
+    tag: "V1";
+    value: RemoteChainHeadStopOperationRequest;
+};
+export const VersionedRemoteChainHeadStopOperationRequest: Codec<VersionedRemoteChainHeadStopOperationRequest>;
+/** Versioned envelope for [\`RemoteChainHeadStopOperationResponse\`]. */
+export type VersionedRemoteChainHeadStopOperationResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedRemoteChainHeadStopOperationResponse: Codec<VersionedRemoteChainHeadStopOperationResponse>;
+/** Versioned envelope for [\`RemoteChainHeadStorageError\`]. */
+export type VersionedRemoteChainHeadStorageError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainHeadStorageError: Codec<VersionedRemoteChainHeadStorageError>;
+/** Versioned envelope for [\`RemoteChainHeadStorageRequest\`]. */
+export type VersionedRemoteChainHeadStorageRequest = {
+    tag: "V1";
+    value: RemoteChainHeadStorageRequest;
+};
+export const VersionedRemoteChainHeadStorageRequest: Codec<VersionedRemoteChainHeadStorageRequest>;
+/** Versioned envelope for [\`RemoteChainHeadStorageResponse\`]. */
+export type VersionedRemoteChainHeadStorageResponse = {
+    tag: "V1";
+    value: RemoteChainHeadStorageResponse;
+};
+export const VersionedRemoteChainHeadStorageResponse: Codec<VersionedRemoteChainHeadStorageResponse>;
+/** Versioned envelope for [\`RemoteChainHeadUnpinError\`]. */
+export type VersionedRemoteChainHeadUnpinError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainHeadUnpinError: Codec<VersionedRemoteChainHeadUnpinError>;
+/** Versioned envelope for [\`RemoteChainHeadUnpinRequest\`]. */
+export type VersionedRemoteChainHeadUnpinRequest = {
+    tag: "V1";
+    value: RemoteChainHeadUnpinRequest;
+};
+export const VersionedRemoteChainHeadUnpinRequest: Codec<VersionedRemoteChainHeadUnpinRequest>;
+/** Versioned envelope for [\`RemoteChainHeadUnpinResponse\`]. */
+export type VersionedRemoteChainHeadUnpinResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedRemoteChainHeadUnpinResponse: Codec<VersionedRemoteChainHeadUnpinResponse>;
+/** Versioned envelope for [\`RemoteChainSpecChainNameError\`]. */
+export type VersionedRemoteChainSpecChainNameError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainSpecChainNameError: Codec<VersionedRemoteChainSpecChainNameError>;
+/** Versioned envelope for [\`RemoteChainSpecChainNameRequest\`]. */
+export type VersionedRemoteChainSpecChainNameRequest = {
+    tag: "V1";
+    value: RemoteChainSpecChainNameRequest;
+};
+export const VersionedRemoteChainSpecChainNameRequest: Codec<VersionedRemoteChainSpecChainNameRequest>;
+/** Versioned envelope for [\`RemoteChainSpecChainNameResponse\`]. */
+export type VersionedRemoteChainSpecChainNameResponse = {
+    tag: "V1";
+    value: RemoteChainSpecChainNameResponse;
+};
+export const VersionedRemoteChainSpecChainNameResponse: Codec<VersionedRemoteChainSpecChainNameResponse>;
+/** Versioned envelope for [\`RemoteChainSpecGenesisHashError\`]. */
+export type VersionedRemoteChainSpecGenesisHashError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainSpecGenesisHashError: Codec<VersionedRemoteChainSpecGenesisHashError>;
+/** Versioned envelope for [\`RemoteChainSpecGenesisHashRequest\`]. */
+export type VersionedRemoteChainSpecGenesisHashRequest = {
+    tag: "V1";
+    value: RemoteChainSpecGenesisHashRequest;
+};
+export const VersionedRemoteChainSpecGenesisHashRequest: Codec<VersionedRemoteChainSpecGenesisHashRequest>;
+/** Versioned envelope for [\`RemoteChainSpecGenesisHashResponse\`]. */
+export type VersionedRemoteChainSpecGenesisHashResponse = {
+    tag: "V1";
+    value: RemoteChainSpecGenesisHashResponse;
+};
+export const VersionedRemoteChainSpecGenesisHashResponse: Codec<VersionedRemoteChainSpecGenesisHashResponse>;
+/** Versioned envelope for [\`RemoteChainSpecPropertiesError\`]. */
+export type VersionedRemoteChainSpecPropertiesError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainSpecPropertiesError: Codec<VersionedRemoteChainSpecPropertiesError>;
+/** Versioned envelope for [\`RemoteChainSpecPropertiesRequest\`]. */
+export type VersionedRemoteChainSpecPropertiesRequest = {
+    tag: "V1";
+    value: RemoteChainSpecPropertiesRequest;
+};
+export const VersionedRemoteChainSpecPropertiesRequest: Codec<VersionedRemoteChainSpecPropertiesRequest>;
+/** Versioned envelope for [\`RemoteChainSpecPropertiesResponse\`]. */
+export type VersionedRemoteChainSpecPropertiesResponse = {
+    tag: "V1";
+    value: RemoteChainSpecPropertiesResponse;
+};
+export const VersionedRemoteChainSpecPropertiesResponse: Codec<VersionedRemoteChainSpecPropertiesResponse>;
+/** Versioned envelope for [\`RemoteChainTransactionBroadcastError\`]. */
+export type VersionedRemoteChainTransactionBroadcastError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainTransactionBroadcastError: Codec<VersionedRemoteChainTransactionBroadcastError>;
+/** Versioned envelope for [\`RemoteChainTransactionBroadcastRequest\`]. */
+export type VersionedRemoteChainTransactionBroadcastRequest = {
+    tag: "V1";
+    value: RemoteChainTransactionBroadcastRequest;
+};
+export const VersionedRemoteChainTransactionBroadcastRequest: Codec<VersionedRemoteChainTransactionBroadcastRequest>;
+/** Versioned envelope for [\`RemoteChainTransactionBroadcastResponse\`]. */
+export type VersionedRemoteChainTransactionBroadcastResponse = {
+    tag: "V1";
+    value: RemoteChainTransactionBroadcastResponse;
+};
+export const VersionedRemoteChainTransactionBroadcastResponse: Codec<VersionedRemoteChainTransactionBroadcastResponse>;
+/** Versioned envelope for [\`RemoteChainTransactionStopError\`]. */
+export type VersionedRemoteChainTransactionStopError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteChainTransactionStopError: Codec<VersionedRemoteChainTransactionStopError>;
+/** Versioned envelope for [\`RemoteChainTransactionStopRequest\`]. */
+export type VersionedRemoteChainTransactionStopRequest = {
+    tag: "V1";
+    value: RemoteChainTransactionStopRequest;
+};
+export const VersionedRemoteChainTransactionStopRequest: Codec<VersionedRemoteChainTransactionStopRequest>;
+/** Versioned envelope for [\`RemoteChainTransactionStopResponse\`]. */
+export type VersionedRemoteChainTransactionStopResponse = {
+    tag: "V1";
+    value?: undefined;
+};
+export const VersionedRemoteChainTransactionStopResponse: Codec<VersionedRemoteChainTransactionStopResponse>;
+/**
+ * One remote-operation permission requested by the product (RFC 0002).
+ *
+ * \`ChainSubmit\`, \`PreimageSubmit\`, and \`StatementSubmit\` are also triggered
+ * implicitly by the corresponding business calls when not yet granted.
+ */
+export type RemotePermission = 
+/** Outbound HTTP/WebSocket access to a set of domains. */
+{
+    tag: "Remote";
+    value: {
+        domains: Array<string>;
+    };
+}
+/** WebRTC media access. */
+ | {
+    tag: "WebRtc";
+    value?: undefined;
+}
+/** Submitting transactions on behalf of the user via \`remote_chain_transaction_broadcast\`. */
+ | {
+    tag: "ChainSubmit";
+    value?: undefined;
+}
+/** Submitting preimages on behalf of the user via \`remote_preimage_submit\`. */
+ | {
+    tag: "PreimageSubmit";
+    value?: undefined;
+}
+/** Submitting statements on behalf of the user via \`remote_statement_store_submit\`. */
+ | {
+    tag: "StatementSubmit";
+    value?: undefined;
+};
+export const RemotePermission: Codec<RemotePermission>;
+/** Versioned envelope for [\`RemotePermissionError\`]. */
+export type VersionedRemotePermissionError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemotePermissionError: Codec<VersionedRemotePermissionError>;
+/** Versioned envelope for [\`RemotePermissionRequest\`]. */
+export type VersionedRemotePermissionRequest = {
+    tag: "V1";
+    value: RemotePermissionRequest;
+};
+export const VersionedRemotePermissionRequest: Codec<VersionedRemotePermissionRequest>;
+/** Versioned envelope for [\`RemotePermissionResponse\`]. */
+export type VersionedRemotePermissionResponse = {
+    tag: "V1";
+    value: RemotePermissionResponse;
+};
+export const VersionedRemotePermissionResponse: Codec<VersionedRemotePermissionResponse>;
+/** Versioned envelope for [\`RemotePreimageLookupSubscribeItem\`]. */
+export type VersionedRemotePreimageLookupSubscribeItem = {
+    tag: "V1";
+    value: RemotePreimageLookupSubscribeItem;
+};
+export const VersionedRemotePreimageLookupSubscribeItem: Codec<VersionedRemotePreimageLookupSubscribeItem>;
+/** Versioned envelope for [\`RemotePreimageLookupSubscribeRequest\`]. */
+export type VersionedRemotePreimageLookupSubscribeRequest = {
+    tag: "V1";
+    value: RemotePreimageLookupSubscribeRequest;
+};
+export const VersionedRemotePreimageLookupSubscribeRequest: Codec<VersionedRemotePreimageLookupSubscribeRequest>;
+/** Versioned envelope for [\`RemotePreimageSubmitError\`]. */
+export type VersionedRemotePreimageSubmitError = {
+    tag: "V1";
+    value: PreimageSubmitError;
+};
+export const VersionedRemotePreimageSubmitError: Codec<VersionedRemotePreimageSubmitError>;
+/** Versioned envelope for [\`RemotePreimageSubmitRequest\`]. */
+export type VersionedRemotePreimageSubmitRequest = {
+    tag: "V1";
+    value: HexString;
+};
+export const VersionedRemotePreimageSubmitRequest: Codec<VersionedRemotePreimageSubmitRequest>;
+/** Versioned envelope for [\`RemotePreimageSubmitResponse\`]. */
+export type VersionedRemotePreimageSubmitResponse = {
+    tag: "V1";
+    value: HexString;
+};
+export const VersionedRemotePreimageSubmitResponse: Codec<VersionedRemotePreimageSubmitResponse>;
+/** Versioned envelope for [\`RemoteStatementStoreCreateProofAuthorizedError\`]. */
+export type VersionedRemoteStatementStoreCreateProofAuthorizedError = {
+    tag: "V1";
+    value: RemoteStatementStoreCreateProofError;
+};
+export const VersionedRemoteStatementStoreCreateProofAuthorizedError: Codec<VersionedRemoteStatementStoreCreateProofAuthorizedError>;
+/** Versioned envelope for [\`RemoteStatementStoreCreateProofAuthorizedRequest\`]. */
+export type VersionedRemoteStatementStoreCreateProofAuthorizedRequest = {
+    tag: "V1";
+    value: Statement;
+};
+export const VersionedRemoteStatementStoreCreateProofAuthorizedRequest: Codec<VersionedRemoteStatementStoreCreateProofAuthorizedRequest>;
+/** Versioned envelope for [\`RemoteStatementStoreCreateProofAuthorizedResponse\`]. */
+export type VersionedRemoteStatementStoreCreateProofAuthorizedResponse = {
+    tag: "V1";
+    value: RemoteStatementStoreCreateProofResponse;
+};
+export const VersionedRemoteStatementStoreCreateProofAuthorizedResponse: Codec<VersionedRemoteStatementStoreCreateProofAuthorizedResponse>;
+/** Versioned envelope for [\`RemoteStatementStoreCreateProofError\`]. */
+export type VersionedRemoteStatementStoreCreateProofError = {
+    tag: "V1";
+    value: RemoteStatementStoreCreateProofError;
+};
+export const VersionedRemoteStatementStoreCreateProofError: Codec<VersionedRemoteStatementStoreCreateProofError>;
+/** Versioned envelope for [\`RemoteStatementStoreCreateProofRequest\`]. */
+export type VersionedRemoteStatementStoreCreateProofRequest = {
+    tag: "V1";
+    value: RemoteStatementStoreCreateProofRequest;
+};
+export const VersionedRemoteStatementStoreCreateProofRequest: Codec<VersionedRemoteStatementStoreCreateProofRequest>;
+/** Versioned envelope for [\`RemoteStatementStoreCreateProofResponse\`]. */
+export type VersionedRemoteStatementStoreCreateProofResponse = {
+    tag: "V1";
+    value: RemoteStatementStoreCreateProofResponse;
+};
+export const VersionedRemoteStatementStoreCreateProofResponse: Codec<VersionedRemoteStatementStoreCreateProofResponse>;
+/** Versioned envelope for [\`RemoteStatementStoreSubmitError\`]. */
+export type VersionedRemoteStatementStoreSubmitError = {
+    tag: "V1";
+    value: GenericError;
+};
+export const VersionedRemoteStatementStoreSubmitError: Codec<VersionedRemoteStatementStoreSubmitError>;
+/** Versioned envelope for [\`RemoteStatementStoreSubmitRequest\`]. */
+export type VersionedRemoteStatementStoreSubmitRequest = {
+    tag: "V1";
+    value: SignedStatement;
+};
+export const VersionedRemoteStatementStoreSubmitRequest: Codec<VersionedRemoteStatementStoreSubmitRequest>;
+/** Versioned envelope for [\`RemoteStatementStoreSubscribeItem\`]. */
+export type VersionedRemoteStatementStoreSubscribeItem = {
+    tag: "V1";
+    value: RemoteStatementStoreSubscribeItem;
+};
+export const VersionedRemoteStatementStoreSubscribeItem: Codec<VersionedRemoteStatementStoreSubscribeItem>;
+/** Versioned envelope for [\`RemoteStatementStoreSubscribeRequest\`]. */
+export type VersionedRemoteStatementStoreSubscribeRequest = {
+    tag: "V1";
+    value: RemoteStatementStoreSubscribeRequest;
+};
+export const VersionedRemoteStatementStoreSubscribeRequest: Codec<VersionedRemoteStatementStoreSubscribeRequest>;
+/** Error from [\`crate::api::ResourceAllocation::request\`]. */
+export type ResourceAllocationError = 
+/** Catch-all. */
+{
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const ResourceAllocationError: Codec<ResourceAllocationError>;
+/** Locates a specific ring on a specific chain for ring VRF operations. */
+export interface RingLocation {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Root hash of the ring. */
+    ringRootHash: HexString;
+    /** Optional location hints. */
+    hints?: RingLocationHint;
+}
+export const RingLocation: Codec<RingLocation>;
+/** Hints for locating a ring on-chain. */
+export interface RingLocationHint {
+    /** Optional pallet instance index. */
+    palletInstance?: number;
+}
+export const RingLocationHint: Codec<RingLocationHint>;
+/** Properties for a [\`CustomRendererNode::Row\`] layout. */
+export interface RowProps {
+    /** Vertical alignment of children. */
+    verticalAlignment?: VerticalAlignment;
+    /** Horizontal arrangement of children. */
+    horizontalArrangement?: Arrangement;
+}
+export const RowProps: Codec<RowProps>;
+export interface RuntimeApi {
+    /** Runtime API name. */
+    name: string;
+    /** Runtime API version. */
+    version: number;
+}
+export const RuntimeApi: Codec<RuntimeApi>;
+export interface RuntimeSpec {
+    /** Specification name. */
+    specName: string;
+    /** Implementation name. */
+    implName: string;
+    /** Spec version number. */
+    specVersion: number;
+    /** Implementation version. */
+    implVersion: number;
+    /** Transaction format version. */
+    transactionVersion?: number;
+    /** Supported runtime APIs. */
+    apis: Array<RuntimeApi>;
+}
+export const RuntimeSpec: Codec<RuntimeSpec>;
+export type RuntimeType = {
+    tag: "Valid";
+    value: RuntimeSpec;
+} | {
+    tag: "Invalid";
+    value: {
+        error: string;
+    };
+};
+export const RuntimeType: Codec<RuntimeType>;
+/** Shape for borders and backgrounds. */
+export type Shape = 
+/** Border radius value. */
+{
+    tag: "Rounded";
+    value: {
+        radius: Size;
+    };
+}
+/** Circular shape. */
+ | {
+    tag: "Circle";
+    value?: undefined;
+};
+export const Shape: Codec<Shape>;
+/** A statement with a required (not optional) proof. */
+export interface SignedStatement {
+    /** Required cryptographic proof. */
+    proof: StatementProof;
+    /** Optional decryption key. */
+    decryptionKey?: HexString;
+    /** Optional Unix timestamp expiry. */
+    expiry?: bigint;
+    /** Optional channel. */
+    channel?: HexString;
+    /** [u8; 32] tags. */
+    topics: Array<HexString>;
+    /** Optional data payload. */
+    data?: HexString;
+}
+export const SignedStatement: Codec<SignedStatement>;
+/**
+ * A size/dimension value (logical pixels) used across the custom renderer.
+ *
+ * Encoded as a SCALE \`Compact<u64>\`: the common small values cost a single
+ * byte on the wire instead of eight.
+ */
+export type Size = number | bigint;
+export const Size: Codec<Size>;
+/** A statement with optional proof and metadata. */
+export interface Statement {
+    /** Optional cryptographic proof. */
+    proof?: StatementProof;
+    /** Optional decryption key. */
+    decryptionKey?: HexString;
+    /** Optional Unix timestamp expiry. */
+    expiry?: bigint;
+    /** Optional channel. */
+    channel?: HexString;
+    /** [u8; 32] tags. */
+    topics: Array<HexString>;
+    /** Optional data payload. */
+    data?: HexString;
+}
+export const Statement: Codec<Statement>;
+/** Cryptographic proof for a statement. */
+export type StatementProof = 
+/** Sr25519 signature proof. */
+{
+    tag: "Sr25519";
+    value: {
+        signature: HexString;
+        signer: HexString;
+    };
+}
+/** Ed25519 signature proof. */
+ | {
+    tag: "Ed25519";
+    value: {
+        signature: HexString;
+        signer: HexString;
+    };
+}
+/** ECDSA signature proof. */
+ | {
+    tag: "Ecdsa";
+    value: {
+        signature: HexString;
+        signer: HexString;
+    };
+}
+/** On-chain event proof. */
+ | {
+    tag: "OnChain";
+    value: {
+        who: HexString;
+        blockHash: HexString;
+        event: bigint;
+    };
+};
+export const StatementProof: Codec<StatementProof>;
+export interface StorageQueryItem {
+    /** Storage key to query. */
+    key: HexString;
+    /** What to return. */
+    queryType: StorageQueryType;
+}
+export const StorageQueryItem: Codec<StorageQueryItem>;
+export type StorageQueryType = "Value" | "Hash" | "ClosestDescendantMerkleValue" | "DescendantsValues" | "DescendantsHashes";
+export const StorageQueryType: Codec<StorageQueryType>;
+export interface StorageResultItem {
+    /** The queried key. */
+    key: HexString;
+    /** Value, if requested. */
+    value?: HexString;
+    /** Hash, if requested. */
+    hash?: HexString;
+    /** Merkle value, if requested. */
+    closestDescendantMerkleValue?: HexString;
+}
+export const StorageResultItem: Codec<StorageResultItem>;
+/** Properties for a [\`CustomRendererNode::TextField\`]. */
+export interface TextFieldProps {
+    /** Current text value. */
+    text: string;
+    /** Placeholder text. */
+    placeholder?: string;
+    /** Field label. */
+    label?: string;
+    /** Whether the field is enabled. Absent leaves the default to the host. */
+    enabled: boolean | undefined;
+    /** Action identifier triggered when the value changes. */
+    valueChangeAction?: string;
+}
+export const TextFieldProps: Codec<TextFieldProps>;
+/** Properties for a [\`CustomRendererNode::Text\`] display. */
+export interface TextProps {
+    /** Typography preset. */
+    style?: TypographyStyle;
+    /** Text color. */
+    color?: ColorToken;
+}
+export const TextProps: Codec<TextProps>;
+/** Identifies a named theme. */
+export type ThemeName = 
+/** A custom named theme. */
+{
+    tag: "Custom";
+    value: string;
+}
+/** The host's default theme. */
+ | {
+    tag: "Default";
+    value?: undefined;
+};
+export const ThemeName: Codec<ThemeName>;
+/** Light or dark variant. */
+export type ThemeVariant = "Light" | "Dark";
+export const ThemeVariant: Codec<ThemeVariant>;
+/** 32-byte statement topic. */
+export type Topic = HexString;
+export const Topic: Codec<Topic>;
+/** A signed extension for a transaction payload. */
+export interface TxPayloadExtension {
+    /** Extension name (e.g., \`"CheckSpecVersion"\`). */
+    id: string;
+    /** SCALE-encoded extra data (in extrinsic body). */
+    extra: HexString;
+    /** SCALE-encoded implicit data (signed, not in body). */
+    additionalSigned: HexString;
+}
+export const TxPayloadExtension: Codec<TxPayloadExtension>;
+/** Text typography presets. */
+export type TypographyStyle = "HeadlineLarge" | "TitleMediumRegular" | "BodyLargeRegular" | "BodyMediumRegular" | "BodySmallRegular";
+export const TypographyStyle: Codec<TypographyStyle>;
+/** User's authentication state. */
+export type HostAccountConnectionStatusSubscribeItem = "Disconnected" | "Connected";
+export const HostAccountConnectionStatusSubscribeItem: Codec<HostAccountConnectionStatusSubscribeItem>;
+/** Error returned when ring VRF proof creation fails. */
+export type HostAccountCreateProofError = 
+/** Ring not available at the specified location. */
+{
+    tag: "RingNotFound";
+    value?: undefined;
+}
+/** User or host rejected. */
+ | {
+    tag: "Rejected";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostAccountCreateProofError: Codec<HostAccountCreateProofError>;
+/** Request to create a ring VRF proof for a product account. */
+export interface HostAccountCreateProofRequest {
+    /** Product account that should create the proof. */
+    productAccountId: ProductAccountId;
+    /** Ring location to use for proof generation. */
+    ringLocation: RingLocation;
+    /** Context bytes bound to the proof. */
+    context: HexString;
+}
+export const HostAccountCreateProofRequest: Codec<HostAccountCreateProofRequest>;
+/** Response containing a ring VRF proof. */
+export interface HostAccountCreateProofResponse {
+    /** Variable-length ring VRF proof bytes. */
+    proof: HexString;
+}
+export const HostAccountCreateProofResponse: Codec<HostAccountCreateProofResponse>;
+/** Request to retrieve a contextual alias for a product account. */
+export interface HostAccountGetAliasRequest {
+    /** Product account to derive the alias for. */
+    productAccountId: ProductAccountId;
+}
+export const HostAccountGetAliasRequest: Codec<HostAccountGetAliasRequest>;
+/** A privacy-preserving alias derived via ring VRF, bound to a specific context. */
+export interface HostAccountGetAliasResponse {
+    /** 32-byte context identifier. */
+    context: HexString;
+    /** Ring VRF alias (variable length). */
+    alias: HexString;
+}
+export const HostAccountGetAliasResponse: Codec<HostAccountGetAliasResponse>;
+/** Error returned when credential/account requests fail. */
+export type HostAccountGetError = 
+/** User is not logged in. */
+{
+    tag: "NotConnected";
+    value?: undefined;
+}
+/** User or host rejected the request. */
+ | {
+    tag: "Rejected";
+    value?: undefined;
+}
+/** Domain identifier is invalid. */
+ | {
+    tag: "DomainNotValid";
+    value?: undefined;
+}
+/** Catch-all error with reason. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostAccountGetError: Codec<HostAccountGetError>;
+/** Request to retrieve a product-scoped account. */
+export interface HostAccountGetRequest {
+    /** Product account to retrieve. */
+    productAccountId: ProductAccountId;
+}
+export const HostAccountGetRequest: Codec<HostAccountGetRequest>;
+/** Response containing a product-scoped account. */
+export interface HostAccountGetResponse {
+    /** Retrieved product account. */
+    account: ProductAccount;
+}
+export const HostAccountGetResponse: Codec<HostAccountGetResponse>;
+/** A chat action received from the host. */
+export interface HostChatActionSubscribeItem {
+    /** Room where the action occurred. */
+    roomId: string;
+    /** Peer who initiated the action. */
+    peer: string;
+    /** The action payload. */
+    payload: ChatActionPayload;
+}
+export const HostChatActionSubscribeItem: Codec<HostChatActionSubscribeItem>;
+/** Chat room registration error. */
+export type HostChatCreateRoomError = 
+/** Not allowed. */
+{
+    tag: "PermissionDenied";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostChatCreateRoomError: Codec<HostChatCreateRoomError>;
+/** Request to create a chat room. */
+export interface HostChatCreateRoomRequest {
+    /** Unique room identifier. */
+    roomId: string;
+    /** Room display name. */
+    name: string;
+    /** URL or base64 image. */
+    icon: string;
+}
+export const HostChatCreateRoomRequest: Codec<HostChatCreateRoomRequest>;
+/** Result of a room registration. */
+export interface HostChatCreateRoomResponse {
+    /** \`New\` or \`Exists\`. */
+    status: ChatRoomRegistrationStatus;
+}
+export const HostChatCreateRoomResponse: Codec<HostChatCreateRoomResponse>;
+/** Item containing the current chat rooms. */
+export interface HostChatListSubscribeItem {
+    /** Chat rooms the product participates in. */
+    rooms: Array<ChatRoom>;
+}
+export const HostChatListSubscribeItem: Codec<HostChatListSubscribeItem>;
+/** Chat message posting error. */
+export type HostChatPostMessageError = 
+/** Message exceeded size limit. */
+{
+    tag: "MessageTooLarge";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostChatPostMessageError: Codec<HostChatPostMessageError>;
+/** Request to post a message to a chat room. */
+export interface HostChatPostMessageRequest {
+    /** Room to post to. */
+    roomId: string;
+    /** Message content. */
+    payload: ChatMessageContent;
+}
+export const HostChatPostMessageRequest: Codec<HostChatPostMessageRequest>;
+/** Result of posting a message. */
+export interface HostChatPostMessageResponse {
+    /** Assigned message ID. */
+    messageId: string;
+}
+export const HostChatPostMessageResponse: Codec<HostChatPostMessageResponse>;
+/** Chat bot registration error. */
+export type HostChatRegisterBotError = 
+/** Not allowed. */
+{
+    tag: "PermissionDenied";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostChatRegisterBotError: Codec<HostChatRegisterBotError>;
+/** Request to register a chat bot. */
+export interface HostChatRegisterBotRequest {
+    /** Unique bot identifier. */
+    botId: string;
+    /** Bot display name. */
+    name: string;
+    /** URL or base64 image. */
+    icon: string;
+}
+export const HostChatRegisterBotRequest: Codec<HostChatRegisterBotRequest>;
+/** Result of a bot registration. */
+export interface HostChatRegisterBotResponse {
+    /** \`New\` or \`Exists\`. */
+    status: ChatBotRegistrationStatus;
+}
+export const HostChatRegisterBotResponse: Codec<HostChatRegisterBotResponse>;
+/** Transaction creation error. */
+export type HostCreateTransactionError = 
+/** Payload could not be deserialized. */
+{
+    tag: "FailedToDecode";
+    value?: undefined;
+}
+/** User rejected. */
+ | {
+    tag: "Rejected";
+    value?: undefined;
+}
+/** Unsupported payload version or extension. */
+ | {
+    tag: "NotSupported";
+    value: {
+        reason: string;
+    };
+}
+/** Not authenticated. */
+ | {
+    tag: "PermissionDenied";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostCreateTransactionError: Codec<HostCreateTransactionError>;
+/** Response containing a created transaction. */
+export interface HostCreateTransactionResponse {
+    /** SCALE-encoded signed transaction. */
+    transaction: HexString;
+}
+export const HostCreateTransactionResponse: Codec<HostCreateTransactionResponse>;
+/** Response containing a transaction created with a non-product account. */
+export interface HostCreateTransactionWithLegacyAccountResponse {
+    /** SCALE-encoded signed transaction. */
+    transaction: HexString;
+}
+export const HostCreateTransactionWithLegacyAccountResponse: Codec<HostCreateTransactionWithLegacyAccountResponse>;
+/** Error from [\`crate::api::Entropy::derive\`] (RFC 0007). */
+export type HostDeriveEntropyError = 
+/** Catch-all. */
+{
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostDeriveEntropyError: Codec<HostDeriveEntropyError>;
+/**
+ * Request to derive deterministic per-product entropy (RFC 0007).
+ *
+ * The host derives 32 bytes from product-scoped seed material and \`context\`.
+ * Repeated calls with the same \`context\` for the same product yield the same
+ * entropy.
+ */
+export interface HostDeriveEntropyRequest {
+    /** Domain-separated derivation context. */
+    context: HexString;
+}
+export const HostDeriveEntropyRequest: Codec<HostDeriveEntropyRequest>;
+/** Response carrying 32 bytes of deterministically derived entropy. */
+export interface HostDeriveEntropyResponse {
+    /** 32 bytes of derived entropy. */
+    entropy: HexString;
+}
+export const HostDeriveEntropyResponse: Codec<HostDeriveEntropyResponse>;
+/**
+ * Device-capability permission requested from the host (RFC 0002).
+ *
+ * The user's decision is persisted indefinitely after the first prompt and
+ * survives app restarts, whether the decision was grant or deny; the host
+ * does not re-prompt on subsequent requests for the same capability.
+ */
+export type HostDevicePermissionRequest = "Notifications" | "Camera" | "Microphone" | "Bluetooth" | "NFC" | "Location" | "Clipboard" | "OpenUrl" | "Biometrics";
+export const HostDevicePermissionRequest: Codec<HostDevicePermissionRequest>;
+/** Outcome of a device-permission request. */
+export interface HostDevicePermissionResponse {
+    /** Whether the permission was granted. */
+    granted: boolean;
+}
+export const HostDevicePermissionResponse: Codec<HostDevicePermissionResponse>;
+/** Request to query whether a feature is supported by the host. */
+export type HostFeatureSupportedRequest = 
+/** Ask whether the host can interact with the chain identified by genesis hash. */
+{
+    tag: "Chain";
+    value: {
+        genesisHash: HexString;
+    };
+};
+export const HostFeatureSupportedRequest: Codec<HostFeatureSupportedRequest>;
+/** Response to a feature-support query. */
+export interface HostFeatureSupportedResponse {
+    /** Whether the feature is supported. */
+    supported: boolean;
+}
+export const HostFeatureSupportedResponse: Codec<HostFeatureSupportedResponse>;
+/** Response containing all legacy (user-imported) accounts owned by the user. */
+export interface HostGetLegacyAccountsResponse {
+    /** Legacy accounts. */
+    accounts: Array<LegacyAccount>;
+}
+export const HostGetLegacyAccountsResponse: Codec<HostGetLegacyAccountsResponse>;
+/** Error from [\`crate::api::Account::get_user_id\`]. */
+export type HostGetUserIdError = 
+/** User denied the identity disclosure request. */
+{
+    tag: "PermissionDenied";
+    value?: undefined;
+}
+/** User is not logged in. */
+ | {
+    tag: "NotConnected";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostGetUserIdError: Codec<HostGetUserIdError>;
+/** The user's primary DotNS account identity. */
+export interface HostGetUserIdResponse {
+    /** The user's primary DotNS username. */
+    primaryUsername: string;
+}
+export const HostGetUserIdResponse: Codec<HostGetUserIdResponse>;
+/**
+ * Error from [\`crate::api::System::handshake\`] (RFC 0009).
+ *
+ * The handshake is the first call on a fresh connection; it does not require
+ * user authentication and is used to negotiate the wire codec version.
+ */
+export type HostHandshakeError = 
+/** Host did not complete the handshake in time. */
+{
+    tag: "Timeout";
+    value?: undefined;
+}
+/** Host does not speak the codec version requested by the product. */
+ | {
+    tag: "UnsupportedProtocolVersion";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: GenericError;
+};
+export const HostHandshakeError: Codec<HostHandshakeError>;
+/** Wire-codec negotiation payload sent by the product (RFC 0009). */
+export interface HostHandshakeRequest {
+    /** Wire codec version requested by the product. */
+    codecVersion: number;
+}
+export const HostHandshakeRequest: Codec<HostHandshakeRequest>;
+/** Request to clear a local storage key. */
+export interface HostLocalStorageClearRequest {
+    /** Storage key to clear. */
+    key: string;
+}
+export const HostLocalStorageClearRequest: Codec<HostLocalStorageClearRequest>;
+/** Local storage operation error. */
+export type HostLocalStorageReadError = 
+/** Storage quota exceeded. */
+{
+    tag: "Full";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostLocalStorageReadError: Codec<HostLocalStorageReadError>;
+/** Request to read a local storage value. */
+export interface HostLocalStorageReadRequest {
+    /** Storage key to read. */
+    key: string;
+}
+export const HostLocalStorageReadRequest: Codec<HostLocalStorageReadRequest>;
+/** Response containing an optional local storage value. */
+export interface HostLocalStorageReadResponse {
+    /** Stored value, if present. */
+    value?: HexString;
+}
+export const HostLocalStorageReadResponse: Codec<HostLocalStorageReadResponse>;
+/** Request to write a value into local storage. */
+export interface HostLocalStorageWriteRequest {
+    /** Storage key to write. */
+    key: string;
+    /** Value to store at the key. */
+    value: HexString;
+}
+export const HostLocalStorageWriteRequest: Codec<HostLocalStorageWriteRequest>;
+/** Error from [\`crate::api::System::navigate_to\`]. */
+export type HostNavigateToError = 
+/** User denied the navigation prompt. */
+{
+    tag: "PermissionDenied";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostNavigateToError: Codec<HostNavigateToError>;
+/** Request to navigate the host to an external URL. */
+export interface HostNavigateToRequest {
+    /** URL to open. */
+    url: string;
+}
+export const HostNavigateToRequest: Codec<HostNavigateToRequest>;
+/**
+ * Error from [\`crate::api::Payment::balance_subscribe\`].
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export type HostPaymentBalanceSubscribeError = 
+/** User denied the balance disclosure request. */
+{
+    tag: "PermissionDenied";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostPaymentBalanceSubscribeError: Codec<HostPaymentBalanceSubscribeError>;
+/**
+ * Current payment balance state pushed to subscribers.
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export interface HostPaymentBalanceSubscribeItem {
+    /** Balance that can be spent right now. */
+    available: Balance;
+}
+export const HostPaymentBalanceSubscribeItem: Codec<HostPaymentBalanceSubscribeItem>;
+/** Request to subscribe to payment balance updates. */
+export interface HostPaymentBalanceSubscribeRequest {
+    /** Optional purse selector. \`None\` means MAIN_PURSE. */
+    purse?: PaymentPurseId;
+}
+export const HostPaymentBalanceSubscribeRequest: Codec<HostPaymentBalanceSubscribeRequest>;
+/**
+ * Error from [\`crate::api::Payment::request\`].
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export type HostPaymentError = 
+/** User rejected the payment request. */
+{
+    tag: "Rejected";
+    value?: undefined;
+}
+/** User's available balance is not sufficient for the requested amount. */
+ | {
+    tag: "InsufficientBalance";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostPaymentError: Codec<HostPaymentError>;
+/** Request to initiate a payment to another account. */
+export interface HostPaymentRequest {
+    /** Optional purse selector. \`None\` means MAIN_PURSE. */
+    from?: PaymentPurseId;
+    /** Amount to pay. */
+    amount: Balance;
+    /** Destination account. */
+    destination: HexString;
+}
+export const HostPaymentRequest: Codec<HostPaymentRequest>;
+/**
+ * Receipt returned after a successful payment request.
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export interface HostPaymentResponse {
+    /** The assigned payment identifier. */
+    id: string;
+}
+export const HostPaymentResponse: Codec<HostPaymentResponse>;
+/**
+ * Error from [\`crate::api::Payment::status_subscribe\`].
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export type HostPaymentStatusSubscribeError = 
+/** Payment ID was not found or does not belong to the current product. */
+{
+    tag: "PaymentNotFound";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostPaymentStatusSubscribeError: Codec<HostPaymentStatusSubscribeError>;
+/**
+ * Payment lifecycle status pushed to subscribers.
+ *
+ * Once a terminal state (\`Completed\` or \`Failed\`) is reached, the host
+ * delivers it and may close the subscription.
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export type HostPaymentStatusSubscribeItem = 
+/** Payment is being processed. */
+{
+    tag: "Processing";
+    value?: undefined;
+}
+/** Payment has been settled successfully. */
+ | {
+    tag: "Completed";
+    value?: undefined;
+}
+/** Payment has failed. */
+ | {
+    tag: "Failed";
+    value: {
+        reason: string;
+    };
+};
+export const HostPaymentStatusSubscribeItem: Codec<HostPaymentStatusSubscribeItem>;
+/** Request to subscribe to a payment status. */
+export interface HostPaymentStatusSubscribeRequest {
+    /** Payment identifier to watch. */
+    paymentId: string;
+}
+export const HostPaymentStatusSubscribeRequest: Codec<HostPaymentStatusSubscribeRequest>;
+/**
+ * Error from [\`crate::api::Payment::top_up\`].
+ *
+ * See [RFC 0006].
+ *
+ * [RFC 0006]: https://github.com/paritytech/triangle-js-sdks/pull/94
+ */
+export type HostPaymentTopUpError = 
+/** The source account does not hold sufficient funds. */
+{
+    tag: "InsufficientFunds";
+    value?: undefined;
+}
+/** The source account was not found or is invalid. */
+ | {
+    tag: "InvalidSource";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+}
+/** Some coins were claimed but the total fell short of the requested amount. */
+ | {
+    tag: "PartialPayment";
+    value: {
+        credited: Balance;
+    };
+};
+export const HostPaymentTopUpError: Codec<HostPaymentTopUpError>;
+/** Request to top up the product payment balance. */
+export interface HostPaymentTopUpRequest {
+    /** Optional purse selector. \`None\` means MAIN_PURSE. */
+    into?: PaymentPurseId;
+    /** Amount to top up. */
+    amount: Balance;
+    /** Funding source for the top-up. */
+    source: PaymentTopUpSource;
+}
+export const HostPaymentTopUpRequest: Codec<HostPaymentTopUpRequest>;
+/** Request to cancel a previously scheduled notification. */
+export interface HostPushNotificationCancelRequest {
+    /** The notification identifier returned by [\`HostPushNotificationResponse\`]. */
+    id: NotificationId;
+}
+export const HostPushNotificationCancelRequest: Codec<HostPushNotificationCancelRequest>;
+/** Push notification error. */
+export type HostPushNotificationError = 
+/** The host-wide queue of pending scheduled notifications is full. */
+{
+    tag: "ScheduleLimitReached";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostPushNotificationError: Codec<HostPushNotificationError>;
+/**
+ * Push notification payload.
+ *
+ * When \`scheduled_at\` is \`Some\`, the notification is deferred to the given
+ * wall-clock instant (Unix milliseconds UTC). \`None\` fires immediately,
+ * preserving prior behaviour. See [RFC 0019].
+ *
+ * [RFC 0019]: https://github.com/paritytech/truapi/blob/main/docs/rfcs/0019-scheduled-notifications.md
+ */
+export interface HostPushNotificationRequest {
+    /** Notification text. */
+    text: string;
+    /** Optional URL to open on tap. */
+    deeplink?: string;
+    /**
+     * Optional Unix timestamp in milliseconds (UTC) at which the notification
+     * should fire. \`None\` fires immediately.
+     */
+    scheduledAt?: bigint;
+}
+export const HostPushNotificationRequest: Codec<HostPushNotificationRequest>;
+/** Successful push notification response carrying the assigned id. */
+export interface HostPushNotificationResponse {
+    /** Host-assigned notification identifier. */
+    id: NotificationId;
+}
+export const HostPushNotificationResponse: Codec<HostPushNotificationResponse>;
+/** Login request error. */
+export type HostRequestLoginError = 
+/** Catch-all. */
+{
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostRequestLoginError: Codec<HostRequestLoginError>;
+/** Request to present the host login flow. */
+export interface HostRequestLoginRequest {
+    /** Optional human-readable reason shown in the login UI. */
+    reason?: string;
+}
+export const HostRequestLoginRequest: Codec<HostRequestLoginRequest>;
+/** Result of a login request. */
+export type HostRequestLoginResponse = "Success" | "AlreadyConnected" | "Rejected";
+export const HostRequestLoginResponse: Codec<HostRequestLoginResponse>;
+/** Batched resource pre-allocation request (RFC 0010). */
+export interface HostRequestResourceAllocationRequest {
+    /** Resources to allocate. */
+    resources: Array<AllocatableResource>;
+}
+export const HostRequestResourceAllocationRequest: Codec<HostRequestResourceAllocationRequest>;
+/** Per-resource outcomes for a batched allocation request (RFC 0010). */
+export interface HostRequestResourceAllocationResponse {
+    /** Per-resource allocation outcomes, in the same order as the request. */
+    outcomes: Array<AllocationOutcome>;
+}
+export const HostRequestResourceAllocationResponse: Codec<HostRequestResourceAllocationResponse>;
+/** Signing operation error. */
+export type HostSignPayloadError = 
+/** Payload could not be deserialized. */
+{
+    tag: "FailedToDecode";
+    value?: undefined;
+}
+/** User rejected signing. */
+ | {
+    tag: "Rejected";
+    value?: undefined;
+}
+/** Not authenticated. */
+ | {
+    tag: "PermissionDenied";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const HostSignPayloadError: Codec<HostSignPayloadError>;
+/** Request to sign an extrinsic payload with a product account. */
+export interface HostSignPayloadRequest {
+    /** Product account that will sign this payload. */
+    account: ProductAccountId;
+    /** The extrinsic payload to sign. */
+    payload: HostSignPayloadData;
+}
+export const HostSignPayloadRequest: Codec<HostSignPayloadRequest>;
+/** Result of a signing operation. */
+export interface HostSignPayloadResponse {
+    /** The cryptographic signature. */
+    signature: HexString;
+    /** Full signed transaction, if requested. */
+    signedTransaction?: HexString;
+}
+export const HostSignPayloadResponse: Codec<HostSignPayloadResponse>;
+/**
+ * Sign a Substrate extrinsic payload with a non-product (legacy) account.
+ * Contains the same fields as [\`HostSignPayloadRequest\`] minus \`address\`
+ * (replaced by \`signer\`).
+ */
+export interface HostSignPayloadWithLegacyAccountRequest {
+    /** Signer address (SS58 or hex) of the legacy account. */
+    signer: string;
+    /** The extrinsic payload to sign. */
+    payload: HostSignPayloadData;
+}
+export const HostSignPayloadWithLegacyAccountRequest: Codec<HostSignPayloadWithLegacyAccountRequest>;
+/** A raw signing request pairing an account with the payload to sign. */
+export interface HostSignRawRequest {
+    /** Product account that will sign this payload. */
+    account: ProductAccountId;
+    /** The payload to sign. */
+    payload: RawPayload;
+}
+export const HostSignRawRequest: Codec<HostSignRawRequest>;
+/**
+ * Sign raw bytes with a non-product (legacy) account. The signer field
+ * identifies which legacy account to use.
+ */
+export interface HostSignRawWithLegacyAccountRequest {
+    /** Signer address (SS58 or hex) of the legacy account. */
+    signer: string;
+    /** The data to sign. */
+    payload: RawPayload;
+}
+export const HostSignRawWithLegacyAccountRequest: Codec<HostSignRawWithLegacyAccountRequest>;
+/** Current theme state pushed to subscribers. */
+export interface HostThemeSubscribeItem {
+    /** Theme name. */
+    name: ThemeName;
+    /** Light or dark variant. */
+    variant: ThemeVariant;
+}
+export const HostThemeSubscribeItem: Codec<HostThemeSubscribeItem>;
+/**
+ * Subscribe payload identifying the chat message to render. The host responds
+ * with a stream of [\`CustomRendererNode\`] trees describing the rendered UI.
+ */
+export interface ProductChatCustomMessageRenderSubscribeRequest {
+    /** Message identifier. */
+    messageId: string;
+    /** Application-defined message type. */
+    messageType: string;
+    /** Binary payload. */
+    payload: HexString;
+}
+export const ProductChatCustomMessageRenderSubscribeRequest: Codec<ProductChatCustomMessageRenderSubscribeRequest>;
+export interface RemoteChainHeadBodyRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Follow subscription identifier. */
+    followSubscriptionId: string;
+    /** Block hash. */
+    hash: HexString;
+}
+export const RemoteChainHeadBodyRequest: Codec<RemoteChainHeadBodyRequest>;
+export interface RemoteChainHeadBodyResponse {
+    /** Started operation result. */
+    operation: OperationStartedResult;
+}
+export const RemoteChainHeadBodyResponse: Codec<RemoteChainHeadBodyResponse>;
+export interface RemoteChainHeadCallRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Follow subscription identifier. */
+    followSubscriptionId: string;
+    /** Block hash. */
+    hash: HexString;
+    /** Runtime API function name. */
+    function: string;
+    /** SCALE-encoded call parameters. */
+    callParameters: HexString;
+}
+export const RemoteChainHeadCallRequest: Codec<RemoteChainHeadCallRequest>;
+export interface RemoteChainHeadCallResponse {
+    /** Started operation result. */
+    operation: OperationStartedResult;
+}
+export const RemoteChainHeadCallResponse: Codec<RemoteChainHeadCallResponse>;
+export interface RemoteChainHeadContinueRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Follow subscription identifier. */
+    followSubscriptionId: string;
+    /** Operation identifier. */
+    operationId: string;
+}
+export const RemoteChainHeadContinueRequest: Codec<RemoteChainHeadContinueRequest>;
+export type RemoteChainHeadFollowItem = {
+    tag: "Initialized";
+    value: {
+        finalizedBlockHashes: Array<HexString>;
+        finalizedBlockRuntime?: RuntimeType;
+    };
+} | {
+    tag: "NewBlock";
+    value: {
+        blockHash: HexString;
+        parentBlockHash: HexString;
+        newRuntime?: RuntimeType;
+    };
+} | {
+    tag: "BestBlockChanged";
+    value: {
+        bestBlockHash: HexString;
+    };
+} | {
+    tag: "Finalized";
+    value: {
+        finalizedBlockHashes: Array<HexString>;
+        prunedBlockHashes: Array<HexString>;
+    };
+} | {
+    tag: "OperationBodyDone";
+    value: {
+        operationId: string;
+        value: Array<HexString>;
+    };
+} | {
+    tag: "OperationCallDone";
+    value: {
+        operationId: string;
+        output: HexString;
+    };
+} | {
+    tag: "OperationStorageItems";
+    value: {
+        operationId: string;
+        items: Array<StorageResultItem>;
+    };
+} | {
+    tag: "OperationStorageDone";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationWaitingForContinue";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationInaccessible";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationError";
+    value: {
+        operationId: string;
+        error: string;
+    };
+} | {
+    tag: "Stop";
+    value?: undefined;
+};
+export const RemoteChainHeadFollowItem: Codec<RemoteChainHeadFollowItem>;
+export interface RemoteChainHeadFollowRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Whether to include runtime information in events. */
+    withRuntime: boolean;
+}
+export const RemoteChainHeadFollowRequest: Codec<RemoteChainHeadFollowRequest>;
+export interface RemoteChainHeadHeaderRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Follow subscription identifier. */
+    followSubscriptionId: string;
+    /** Block hash. */
+    hash: HexString;
+}
+export const RemoteChainHeadHeaderRequest: Codec<RemoteChainHeadHeaderRequest>;
+export interface RemoteChainHeadHeaderResponse {
+    /** SCALE-encoded block header. */
+    header?: HexString;
+}
+export const RemoteChainHeadHeaderResponse: Codec<RemoteChainHeadHeaderResponse>;
+export interface RemoteChainHeadStopOperationRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Follow subscription identifier. */
+    followSubscriptionId: string;
+    /** Operation identifier. */
+    operationId: string;
+}
+export const RemoteChainHeadStopOperationRequest: Codec<RemoteChainHeadStopOperationRequest>;
+export interface RemoteChainHeadStorageRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Follow subscription identifier. */
+    followSubscriptionId: string;
+    /** Block hash. */
+    hash: HexString;
+    /** Storage items to query. */
+    items: Array<StorageQueryItem>;
+    /** Optional child trie. */
+    childTrie?: HexString;
+}
+export const RemoteChainHeadStorageRequest: Codec<RemoteChainHeadStorageRequest>;
+export interface RemoteChainHeadStorageResponse {
+    /** Started operation result. */
+    operation: OperationStartedResult;
+}
+export const RemoteChainHeadStorageResponse: Codec<RemoteChainHeadStorageResponse>;
+export interface RemoteChainHeadUnpinRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Follow subscription identifier. */
+    followSubscriptionId: string;
+    /** Block hashes to unpin. */
+    hashes: Array<HexString>;
+}
+export const RemoteChainHeadUnpinRequest: Codec<RemoteChainHeadUnpinRequest>;
+export interface RemoteChainSpecChainNameRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+}
+export const RemoteChainSpecChainNameRequest: Codec<RemoteChainSpecChainNameRequest>;
+export interface RemoteChainSpecChainNameResponse {
+    /** Chain display name. */
+    chainName: string;
+}
+export const RemoteChainSpecChainNameResponse: Codec<RemoteChainSpecChainNameResponse>;
+export interface RemoteChainSpecGenesisHashRequest {
+    /** Chain genesis hash requested by the product. */
+    genesisHash: HexString;
+}
+export const RemoteChainSpecGenesisHashRequest: Codec<RemoteChainSpecGenesisHashRequest>;
+export interface RemoteChainSpecGenesisHashResponse {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+}
+export const RemoteChainSpecGenesisHashResponse: Codec<RemoteChainSpecGenesisHashResponse>;
+export interface RemoteChainSpecPropertiesRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+}
+export const RemoteChainSpecPropertiesRequest: Codec<RemoteChainSpecPropertiesRequest>;
+export interface RemoteChainSpecPropertiesResponse {
+    /** JSON-encoded properties. */
+    properties: string;
+}
+export const RemoteChainSpecPropertiesResponse: Codec<RemoteChainSpecPropertiesResponse>;
+export interface RemoteChainTransactionBroadcastRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Signed transaction bytes. */
+    transaction: HexString;
+}
+export const RemoteChainTransactionBroadcastRequest: Codec<RemoteChainTransactionBroadcastRequest>;
+export interface RemoteChainTransactionBroadcastResponse {
+    /** Broadcast operation identifier, if available. */
+    operationId?: string;
+}
+export const RemoteChainTransactionBroadcastResponse: Codec<RemoteChainTransactionBroadcastResponse>;
+export interface RemoteChainTransactionStopRequest {
+    /** Chain genesis hash. */
+    genesisHash: HexString;
+    /** Operation identifier of the broadcast to stop. */
+    operationId: string;
+}
+export const RemoteChainTransactionStopRequest: Codec<RemoteChainTransactionStopRequest>;
+/** remote-permission request (RFC 0002). */
+export interface RemotePermissionRequest {
+    /** Permission requested by the product. */
+    permission: RemotePermission;
+}
+export const RemotePermissionRequest: Codec<RemotePermissionRequest>;
+/** Outcome of a remote-permission request. */
+export interface RemotePermissionResponse {
+    /** Whether the permission was granted. */
+    granted: boolean;
+}
+export const RemotePermissionResponse: Codec<RemotePermissionResponse>;
+/** Item containing an optional preimage lookup result. */
+export interface RemotePreimageLookupSubscribeItem {
+    /** Preimage data, if found. */
+    value?: HexString;
+}
+export const RemotePreimageLookupSubscribeItem: Codec<RemotePreimageLookupSubscribeItem>;
+/** Request to subscribe to preimage lookup results. */
+export interface RemotePreimageLookupSubscribeRequest {
+    /** Hash of the preimage. */
+    key: HexString;
+}
+export const RemotePreimageLookupSubscribeRequest: Codec<RemotePreimageLookupSubscribeRequest>;
+/** Statement proof creation error. */
+export type RemoteStatementStoreCreateProofError = 
+/** Signing operation failed. */
+{
+    tag: "UnableToSign";
+    value?: undefined;
+}
+/** Account not recognized. */
+ | {
+    tag: "UnknownAccount";
+    value?: undefined;
+}
+/** Catch-all. */
+ | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+};
+export const RemoteStatementStoreCreateProofError: Codec<RemoteStatementStoreCreateProofError>;
+/** Request to create a cryptographic proof for a statement. */
+export interface RemoteStatementStoreCreateProofRequest {
+    /** Product account that should create the proof. */
+    productAccountId: ProductAccountId;
+    /** Statement to prove. */
+    statement: Statement;
+}
+export const RemoteStatementStoreCreateProofRequest: Codec<RemoteStatementStoreCreateProofRequest>;
+/** Response containing a statement proof. */
+export interface RemoteStatementStoreCreateProofResponse {
+    /** Created statement proof. */
+    proof: StatementProof;
+}
+export const RemoteStatementStoreCreateProofResponse: Codec<RemoteStatementStoreCreateProofResponse>;
+/**
+ * Page of signed statements delivered by the statement store subscription
+ * (RFC 0008). The \`is_complete\` flag distinguishes the historical-dump phase
+ * (\`false\`) from the live-update phase (\`true\`).
+ */
+export interface RemoteStatementStoreSubscribeItem {
+    /** Signed statements matching the subscription. */
+    statements: Array<SignedStatement>;
+    /**
+     * \`false\` while the host is still streaming the historical dump (more
+     * pages to follow). \`true\` once the dump is complete; all subsequent
+     * pages are also \`true\` and carry only newly-arrived statements.
+     */
+    isComplete: boolean;
+}
+export const RemoteStatementStoreSubscribeItem: Codec<RemoteStatementStoreSubscribeItem>;
+/** Request to subscribe to statements via a topic filter (RFC 0008). */
+export type RemoteStatementStoreSubscribeRequest = 
+/** AND: statement must contain every listed topic. */
+{
+    tag: "MatchAll";
+    value: Array<Topic>;
+}
+/** OR: statement must contain at least one listed topic. */
+ | {
+    tag: "MatchAny";
+    value: Array<Topic>;
+};
+export const RemoteStatementStoreSubscribeRequest: Codec<RemoteStatementStoreSubscribeRequest>;
+/** Vertical alignment options. */
+export type VerticalAlignment = "Top" | "Center" | "Bottom";
+export const VerticalAlignment: Codec<VerticalAlignment>;
+
+}
+
+
+// client.d.ts
+export type { Subscription, TrUApiTransport };
+/**
+ * Version overrides used when constructing a transport.
+ */
+export interface CreateTransportOptions {
+    /**
+     * Highest TrUAPI protocol version exposed by the transport.
+     */
+    truapiVersion?: number;
+    /**
+     * SCALE codec version advertised during host handshake negotiation.
+     */
+    codecVersion?: number;
+}
+/**
+ * Build a \`TrUApiTransport\` on top of a \`Provider\`, adding request/response
+ * correlation and subscription start/receive/stop lifecycle handling.
+ */
+export declare function createTransport(provider: Provider, options?: CreateTransportOptions): TrUApiTransport;
+
+
+// explorer/codegen/types.d.ts
+export declare const types: DataType[];
+
+
+// explorer/codegen/versions/0.2.0/services.d.ts
+export declare const services: ServiceInfo[];
+
+
+// explorer/codegen/versions/0.2.0/types.d.ts
+export declare const types: DataType[];
+
+
+// explorer/codegen/versions/0.3.0/services.d.ts
+export declare const services: ServiceInfo[];
+
+
+// explorer/codegen/versions/0.3.0/types.d.ts
+export declare const types: DataType[];
+
+
+// explorer/data-types.d.ts
+/** One named field or enum variant rendered on a \`DataType\`. */
+export interface DataTypeField {
+    /** Field or variant name as it appears in the generated TS source. */
+    name: string;
+    /** Rendered TypeScript type expression. */
+    type: string;
+    /** First paragraph of the field/variant doc comment, when present. */
+    description?: string;
+}
+/**
+ * A type surfaced by the TrUAPI explorer. One entry per public type in the
+ * generated client surface (versioned wrapper enums are not surfaced, the
+ * explorer routes around them via \`MethodInfo.requestType\`/\`responseType\`).
+ */
+export interface DataType {
+    /**
+     * Kebab-case identifier (e.g. \`host-account-get-request\`). Matches the
+     * \`requestType\`/\`responseType\`/\`errorType\` ids emitted on \`MethodInfo\`.
+     */
+    id: string;
+    /** Public TS type name (e.g. \`HostAccountGetRequest\`). */
+    name: string;
+    /**
+     * Rustdoc module bucket (\`account\`, \`chat\`, ...) or \`shared\` when the type
+     * lives outside \`api::<service>\`.
+     */
+    category: string;
+    /** TypeScript source for the type, ready to render in a code block. */
+    definition: string;
+    /**
+     * Free-form doc comment, with the optional \`\`\`ts ... \`\`\` example block
+     * stripped.
+     */
+    description?: string;
+    /** Named fields, populated for \`struct\`-shaped types. */
+    fields?: DataTypeField[];
+    /** Variants, populated for \`enum\`-shaped types. */
+    variants?: DataTypeField[];
+}
+/**
+ * One snapshot of the API surface. \`id\` is \`"main"\` for the live codegen
+ * output, or a semver string (e.g. \`"0.1.0"\`) for an archived snapshot.
+ */
+export interface VersionEntry {
+    id: string;
+    services: ServiceInfo[];
+    types: DataType[];
+}
+
+
+// explorer/versions.d.ts
+/**
+ * Version string declared in \`js/packages/truapi/package.json\` at codegen
+ * time. Mirrors the \`truapi\` crate version. Used by the explorer to render
+ * the \`main\` selector label as \`main (x.y.z)\`.
+ */
+export declare const packageVersion = "0.3.0";
+export declare const versions: VersionEntry[];
+
+
+// generated/client.d.ts
+export { ResultAsync, SubscriptionError };
+export type { ObservableLike, Observer, Result, Subscription, TrUApiTransport };
+export declare const TRUAPI_VERSION: 1;
+export declare const TRUAPI_CODEC_VERSION: 1;
+/** Account lookup, aliasing, and proof generation. */
+export declare class AccountClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to account connection status changes. */
+    connectionStatusSubscribe(): ObservableLike<T.HostAccountConnectionStatusSubscribeItem>;
+    /** Retrieve a product-scoped account. */
+    getAccount(request: T.HostAccountGetRequest): ResultAsync<T.HostAccountGetResponse, T.HostAccountGetError>;
+    /** Retrieve a contextual alias for a product account. */
+    getAccountAlias(request: T.HostAccountGetAliasRequest): ResultAsync<T.HostAccountGetAliasResponse, T.HostAccountGetError>;
+    /** Generate a ring VRF proof for a product account. */
+    createAccountProof(request: T.HostAccountCreateProofRequest): ResultAsync<T.HostAccountCreateProofResponse, T.HostAccountCreateProofError>;
+    /** List non-product accounts the user owns. */
+    getLegacyAccounts(): ResultAsync<T.HostGetLegacyAccountsResponse, T.HostAccountGetError>;
+    /** Fetch the user's primary identity. */
+    getUserId(): ResultAsync<T.HostGetUserIdResponse, T.HostGetUserIdError>;
+    /**
+     * Request the host to present the login flow to the user.
+     *
+     * Products should call this in response to a user action (e.g. tapping a
+     * "Sign in" button), not automatically on load.
+     */
+    requestLogin(request: T.HostRequestLoginRequest): ResultAsync<T.HostRequestLoginResponse, T.HostRequestLoginError>;
+}
+/** Chain interaction methods. */
+export declare class ChainClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Follow the chain head and receive block events. */
+    followHeadSubscribe({ request, }: {
+        request: T.RemoteChainHeadFollowRequest;
+    }): ObservableLike<T.RemoteChainHeadFollowItem>;
+    /** Fetch a block header. */
+    getHeadHeader(request: T.RemoteChainHeadHeaderRequest): ResultAsync<T.RemoteChainHeadHeaderResponse, T.GenericError>;
+    /** Fetch a block body. */
+    getHeadBody(request: T.RemoteChainHeadBodyRequest): ResultAsync<T.RemoteChainHeadBodyResponse, T.GenericError>;
+    /** Query runtime storage at a specific block. */
+    getHeadStorage(request: T.RemoteChainHeadStorageRequest): ResultAsync<T.RemoteChainHeadStorageResponse, T.GenericError>;
+    /** Invoke a runtime call at a specific block. */
+    callHead(request: T.RemoteChainHeadCallRequest): ResultAsync<T.RemoteChainHeadCallResponse, T.GenericError>;
+    /** Release pinned blocks. */
+    unpinHead(request: T.RemoteChainHeadUnpinRequest): ResultAsync<undefined, T.GenericError>;
+    /** Continue a paused chain-head operation. */
+    continueHead(request: T.RemoteChainHeadContinueRequest): ResultAsync<undefined, T.GenericError>;
+    /** Stop a chain-head operation. */
+    stopHeadOperation(request: T.RemoteChainHeadStopOperationRequest): ResultAsync<undefined, T.GenericError>;
+    /** Fetch the canonical genesis hash for a chain. */
+    getSpecGenesisHash(request: T.RemoteChainSpecGenesisHashRequest): ResultAsync<T.RemoteChainSpecGenesisHashResponse, T.GenericError>;
+    /** Fetch the display name of a chain. */
+    getSpecChainName(request: T.RemoteChainSpecChainNameRequest): ResultAsync<T.RemoteChainSpecChainNameResponse, T.GenericError>;
+    /** Fetch the JSON-encoded properties of a chain. */
+    getSpecProperties(request: T.RemoteChainSpecPropertiesRequest): ResultAsync<T.RemoteChainSpecPropertiesResponse, T.GenericError>;
+    /** Broadcast a signed transaction. */
+    broadcastTransaction(request: T.RemoteChainTransactionBroadcastRequest): ResultAsync<T.RemoteChainTransactionBroadcastResponse, T.GenericError>;
+    /** Stop a transaction broadcast. */
+    stopTransaction(request: T.RemoteChainTransactionStopRequest): ResultAsync<undefined, T.GenericError>;
+}
+/** Chat room, bot, and message APIs. */
+export declare class ChatClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Create a chat room. */
+    createRoom(request: T.HostChatCreateRoomRequest): ResultAsync<T.HostChatCreateRoomResponse, T.HostChatCreateRoomError>;
+    /** Register a chat bot. */
+    registerBot(request: T.HostChatRegisterBotRequest): ResultAsync<T.HostChatRegisterBotResponse, T.HostChatRegisterBotError>;
+    /** Subscribe to the list of chat rooms. */
+    listSubscribe(): ObservableLike<T.HostChatListSubscribeItem>;
+    /** Post a message to a chat room. */
+    postMessage(request: T.HostChatPostMessageRequest): ResultAsync<T.HostChatPostMessageResponse, T.HostChatPostMessageError>;
+    /** Subscribe to received chat actions. */
+    actionSubscribe(): ObservableLike<T.HostChatActionSubscribeItem>;
+    /**
+     * Subscribe to custom message render requests from the host. Each
+     * emitted item is a [\`CustomRendererNode\`](crate::v01::CustomRendererNode)
+     * tree describing the rendered UI.
+     */
+    customMessageRenderSubscribe({ request, }: {
+        request: T.ProductChatCustomMessageRenderSubscribeRequest;
+    }): ObservableLike<T.CustomRendererNode>;
+}
+/** Deterministic entropy derivation. */
+export declare class EntropyClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Derive deterministic entropy. */
+    derive(request: T.HostDeriveEntropyRequest): ResultAsync<T.HostDeriveEntropyResponse, T.HostDeriveEntropyError>;
+}
+/** Local key/value storage scoped to the calling product. */
+export declare class LocalStorageClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Read a value by key. */
+    read(request: T.HostLocalStorageReadRequest): ResultAsync<T.HostLocalStorageReadResponse, T.HostLocalStorageReadError>;
+    /** Write a value to a key. */
+    write(request: T.HostLocalStorageWriteRequest): ResultAsync<undefined, T.HostLocalStorageReadError>;
+    /** Clear a value by key. */
+    clear(request: T.HostLocalStorageClearRequest): ResultAsync<undefined, T.HostLocalStorageReadError>;
+}
+/** Notification methods for locally-rendered push notifications. */
+export declare class NotificationsClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /**
+     * Send a push notification to the user.
+     *
+     * Returns a [\`NotificationId\`](crate::v01::NotificationId) that can be
+     * passed to [\`cancel_push_notification\`](Self::cancel_push_notification)
+     * to retract a scheduled notification. When \`scheduled_at\` is set the host
+     * persists the notification across restarts and fires it through the
+     * platform-native scheduler. See [RFC 0019].
+     *
+     * [RFC 0019]: https://github.com/paritytech/truapi/blob/main/docs/rfcs/0019-scheduled-notifications.md
+     */
+    sendPushNotification(request: T.HostPushNotificationRequest): ResultAsync<T.HostPushNotificationResponse, T.HostPushNotificationError>;
+    /**
+     * Cancels a previously issued push notification.
+     *
+     * Cancellation is idempotent: returns \`Ok(())\` whether the notification is
+     * still pending, already fired, or was never issued. See [RFC 0019].
+     *
+     * [RFC 0019]: https://github.com/paritytech/truapi/blob/main/docs/rfcs/0019-scheduled-notifications.md
+     */
+    cancelPushNotification(request: T.HostPushNotificationCancelRequest): ResultAsync<undefined, T.GenericError>;
+}
+/** Payment request and balance/status subscription methods. */
+export declare class PaymentClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to payment balance updates. */
+    balanceSubscribe({ request, }: {
+        request: T.HostPaymentBalanceSubscribeRequest;
+    }): ObservableLike<T.HostPaymentBalanceSubscribeItem, T.HostPaymentBalanceSubscribeError>;
+    /** Request a payment from the user. */
+    request(request: T.HostPaymentRequest): ResultAsync<T.HostPaymentResponse, T.HostPaymentError>;
+    /** Subscribe to payment lifecycle updates for a specific payment. */
+    statusSubscribe({ request, }: {
+        request: T.HostPaymentStatusSubscribeRequest;
+    }): ObservableLike<T.HostPaymentStatusSubscribeItem, T.HostPaymentStatusSubscribeError>;
+    /** Top up the user's payment balance. */
+    topUp(request: T.HostPaymentTopUpRequest): ResultAsync<undefined, T.HostPaymentTopUpError>;
+}
+/** Permission request methods. */
+export declare class PermissionsClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Request a device-capability permission from the user. */
+    requestDevicePermission(request: T.HostDevicePermissionRequest): ResultAsync<T.HostDevicePermissionResponse, T.GenericError>;
+    /** Request a remote-operation permission. */
+    requestRemotePermission(request: T.RemotePermissionRequest): ResultAsync<T.RemotePermissionResponse, T.GenericError>;
+}
+/** Preimage lookup and submission methods. */
+export declare class PreimageClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to preimage lookups for a given key. */
+    lookupSubscribe({ request, }: {
+        request: T.RemotePreimageLookupSubscribeRequest;
+    }): ObservableLike<T.RemotePreimageLookupSubscribeItem>;
+    /** Submit a preimage. Returns the preimage key (hash) on success. */
+    submit(request: HexString): ResultAsync<HexString, T.PreimageSubmitError>;
+}
+/** Resource pre-allocation (allowance management). */
+export declare class ResourceAllocationClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Request the host to pre-allocate one or more resources. */
+    request(request: T.HostRequestResourceAllocationRequest): ResultAsync<T.HostRequestResourceAllocationResponse, T.ResourceAllocationError>;
+}
+/** Signing operations. */
+export declare class SigningClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Construct a signed transaction for a product account. */
+    createTransaction(request: T.ProductAccountTxPayload): ResultAsync<T.HostCreateTransactionResponse, T.HostCreateTransactionError>;
+    /** Construct a signed transaction for a non-product (legacy) account. */
+    createTransactionWithLegacyAccount(request: T.LegacyAccountTxPayload): ResultAsync<T.HostCreateTransactionWithLegacyAccountResponse, T.HostCreateTransactionError>;
+    /** Sign raw bytes with a non-product account. */
+    signRawWithLegacyAccount(request: T.HostSignRawWithLegacyAccountRequest): ResultAsync<T.HostSignPayloadResponse, T.HostSignPayloadError>;
+    /** Sign an extrinsic payload with a non-product account. */
+    signPayloadWithLegacyAccount(request: T.HostSignPayloadWithLegacyAccountRequest): ResultAsync<T.HostSignPayloadResponse, T.HostSignPayloadError>;
+    /** Sign raw bytes or a message. */
+    signRaw(request: T.HostSignRawRequest): ResultAsync<T.HostSignPayloadResponse, T.HostSignPayloadError>;
+    /** Sign an extrinsic payload. */
+    signPayload(request: T.HostSignPayloadRequest): ResultAsync<T.HostSignPayloadResponse, T.HostSignPayloadError>;
+}
+/** Statement store methods. */
+export declare class StatementStoreClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to statements matching a topic filter. */
+    subscribe({ request, }: {
+        request: T.RemoteStatementStoreSubscribeRequest;
+    }): ObservableLike<T.RemoteStatementStoreSubscribeItem>;
+    /**
+     * Create a proof for a statement.
+     *
+     * **Deprecated:** use [\`create_proof_authorized\`](Self::create_proof_authorized)
+     * instead, which uses a pre-allocated allowance account and does not
+     * require a per-call signing prompt.
+     */
+    createProof(request: T.RemoteStatementStoreCreateProofRequest): ResultAsync<T.RemoteStatementStoreCreateProofResponse, T.RemoteStatementStoreCreateProofError>;
+    /**
+     * Create a proof for a statement using a pre-allocated allowance account,
+     * bypassing the per-call signing prompt.
+     */
+    createProofAuthorized(request: T.Statement): ResultAsync<T.RemoteStatementStoreCreateProofResponse, T.RemoteStatementStoreCreateProofError>;
+    /**
+     * Submit a signed statement to the network. The request body is the
+     * [\`SignedStatement\`](crate::v01::SignedStatement) directly (no wrapping
+     * struct), matching upstream \`triangle-js-sdks\`.
+     */
+    submit(request: T.SignedStatement): ResultAsync<undefined, T.GenericError>;
+}
+/**
+ * General-purpose TrUAPI methods for handshake, feature detection,
+ * and navigation.
+ */
+export declare class SystemClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Negotiate the wire codec version with the product. */
+    handshake(): ResultAsync<undefined, T.HostHandshakeError>;
+    /** Query whether the host supports a specific feature. */
+    featureSupported(request: T.HostFeatureSupportedRequest): ResultAsync<T.HostFeatureSupportedResponse, T.GenericError>;
+    /** Request the host to open a URL. */
+    navigateTo(request: T.HostNavigateToRequest): ResultAsync<undefined, T.HostNavigateToError>;
+}
+/** Host theme subscription. */
+export declare class ThemeClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to host theme changes. */
+    subscribe(): ObservableLike<T.HostThemeSubscribeItem>;
+}
+export interface TrUApiClient {
+    readonly account: AccountClient;
+    readonly chain: ChainClient;
+    readonly chat: ChatClient;
+    readonly entropy: EntropyClient;
+    readonly localStorage: LocalStorageClient;
+    readonly notifications: NotificationsClient;
+    readonly payment: PaymentClient;
+    readonly permissions: PermissionsClient;
+    readonly preimage: PreimageClient;
+    readonly resourceAllocation: ResourceAllocationClient;
+    readonly signing: SigningClient;
+    readonly statementStore: StatementStoreClient;
+    readonly system: SystemClient;
+    readonly theme: ThemeClient;
+}
+export type Client = TrUApiClient;
+export type GeneratedClientTransport = Omit<TrUApiTransport, "truapiVersion" | "codecVersion"> & Partial<Pick<TrUApiTransport, "truapiVersion" | "codecVersion">>;
+/** Creates the generated client facade by binding each service namespace to the
+ * shared transport instance. */
+export declare function createClient(transport: GeneratedClientTransport): TrUApiClient;
+
+
+// generated/index.d.ts
+
+
+// generated/wire-table.d.ts
+export declare const SYSTEM_HANDSHAKE: {
+    readonly request: 0;
+    readonly response: 1;
+};
+export declare const SYSTEM_FEATURE_SUPPORTED: {
+    readonly request: 2;
+    readonly response: 3;
+};
+export declare const NOTIFICATIONS_SEND_PUSH_NOTIFICATION: {
+    readonly request: 4;
+    readonly response: 5;
+};
+export declare const SYSTEM_NAVIGATE_TO: {
+    readonly request: 6;
+    readonly response: 7;
+};
+export declare const PERMISSIONS_REQUEST_DEVICE_PERMISSION: {
+    readonly request: 8;
+    readonly response: 9;
+};
+export declare const PERMISSIONS_REQUEST_REMOTE_PERMISSION: {
+    readonly request: 10;
+    readonly response: 11;
+};
+export declare const LOCAL_STORAGE_READ: {
+    readonly request: 12;
+    readonly response: 13;
+};
+export declare const LOCAL_STORAGE_WRITE: {
+    readonly request: 14;
+    readonly response: 15;
+};
+export declare const LOCAL_STORAGE_CLEAR: {
+    readonly request: 16;
+    readonly response: 17;
+};
+export declare const ACCOUNT_CONNECTION_STATUS_SUBSCRIBE: {
+    readonly start: 18;
+    readonly stop: 19;
+    readonly interrupt: 20;
+    readonly receive: 21;
+};
+export declare const ACCOUNT_GET_ACCOUNT: {
+    readonly request: 22;
+    readonly response: 23;
+};
+export declare const ACCOUNT_GET_ACCOUNT_ALIAS: {
+    readonly request: 24;
+    readonly response: 25;
+};
+export declare const ACCOUNT_CREATE_ACCOUNT_PROOF: {
+    readonly request: 26;
+    readonly response: 27;
+};
+export declare const ACCOUNT_GET_LEGACY_ACCOUNTS: {
+    readonly request: 28;
+    readonly response: 29;
+};
+export declare const SIGNING_CREATE_TRANSACTION: {
+    readonly request: 30;
+    readonly response: 31;
+};
+export declare const SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT: {
+    readonly request: 32;
+    readonly response: 33;
+};
+export declare const SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT: {
+    readonly request: 34;
+    readonly response: 35;
+};
+export declare const SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT: {
+    readonly request: 36;
+    readonly response: 37;
+};
+export declare const CHAT_CREATE_ROOM: {
+    readonly request: 38;
+    readonly response: 39;
+};
+export declare const CHAT_REGISTER_BOT: {
+    readonly request: 40;
+    readonly response: 41;
+};
+export declare const CHAT_LIST_SUBSCRIBE: {
+    readonly start: 42;
+    readonly stop: 43;
+    readonly interrupt: 44;
+    readonly receive: 45;
+};
+export declare const CHAT_POST_MESSAGE: {
+    readonly request: 46;
+    readonly response: 47;
+};
+export declare const CHAT_ACTION_SUBSCRIBE: {
+    readonly start: 48;
+    readonly stop: 49;
+    readonly interrupt: 50;
+    readonly receive: 51;
+};
+export declare const CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE: {
+    readonly start: 52;
+    readonly stop: 53;
+    readonly interrupt: 54;
+    readonly receive: 55;
+};
+export declare const STATEMENT_STORE_SUBSCRIBE: {
+    readonly start: 56;
+    readonly stop: 57;
+    readonly interrupt: 58;
+    readonly receive: 59;
+};
+export declare const STATEMENT_STORE_CREATE_PROOF: {
+    readonly request: 60;
+    readonly response: 61;
+};
+export declare const STATEMENT_STORE_SUBMIT: {
+    readonly request: 62;
+    readonly response: 63;
+};
+export declare const PREIMAGE_LOOKUP_SUBSCRIBE: {
+    readonly start: 64;
+    readonly stop: 65;
+    readonly interrupt: 66;
+    readonly receive: 67;
+};
+export declare const PREIMAGE_SUBMIT: {
+    readonly request: 68;
+    readonly response: 69;
+};
+export declare const CHAIN_FOLLOW_HEAD_SUBSCRIBE: {
+    readonly start: 76;
+    readonly stop: 77;
+    readonly interrupt: 78;
+    readonly receive: 79;
+};
+export declare const CHAIN_GET_HEAD_HEADER: {
+    readonly request: 80;
+    readonly response: 81;
+};
+export declare const CHAIN_GET_HEAD_BODY: {
+    readonly request: 82;
+    readonly response: 83;
+};
+export declare const CHAIN_GET_HEAD_STORAGE: {
+    readonly request: 84;
+    readonly response: 85;
+};
+export declare const CHAIN_CALL_HEAD: {
+    readonly request: 86;
+    readonly response: 87;
+};
+export declare const CHAIN_UNPIN_HEAD: {
+    readonly request: 88;
+    readonly response: 89;
+};
+export declare const CHAIN_CONTINUE_HEAD: {
+    readonly request: 90;
+    readonly response: 91;
+};
+export declare const CHAIN_STOP_HEAD_OPERATION: {
+    readonly request: 92;
+    readonly response: 93;
+};
+export declare const CHAIN_GET_SPEC_GENESIS_HASH: {
+    readonly request: 94;
+    readonly response: 95;
+};
+export declare const CHAIN_GET_SPEC_CHAIN_NAME: {
+    readonly request: 96;
+    readonly response: 97;
+};
+export declare const CHAIN_GET_SPEC_PROPERTIES: {
+    readonly request: 98;
+    readonly response: 99;
+};
+export declare const CHAIN_BROADCAST_TRANSACTION: {
+    readonly request: 100;
+    readonly response: 101;
+};
+export declare const CHAIN_STOP_TRANSACTION: {
+    readonly request: 102;
+    readonly response: 103;
+};
+export declare const THEME_SUBSCRIBE: {
+    readonly start: 104;
+    readonly stop: 105;
+    readonly interrupt: 106;
+    readonly receive: 107;
+};
+export declare const ENTROPY_DERIVE: {
+    readonly request: 108;
+    readonly response: 109;
+};
+export declare const ACCOUNT_GET_USER_ID: {
+    readonly request: 110;
+    readonly response: 111;
+};
+export declare const ACCOUNT_REQUEST_LOGIN: {
+    readonly request: 112;
+    readonly response: 113;
+};
+export declare const SIGNING_SIGN_RAW: {
+    readonly request: 114;
+    readonly response: 115;
+};
+export declare const SIGNING_SIGN_PAYLOAD: {
+    readonly request: 116;
+    readonly response: 117;
+};
+export declare const PAYMENT_BALANCE_SUBSCRIBE: {
+    readonly start: 118;
+    readonly stop: 119;
+    readonly interrupt: 120;
+    readonly receive: 121;
+};
+export declare const PAYMENT_TOP_UP: {
+    readonly request: 122;
+    readonly response: 123;
+};
+export declare const PAYMENT_REQUEST: {
+    readonly request: 124;
+    readonly response: 125;
+};
+export declare const PAYMENT_STATUS_SUBSCRIBE: {
+    readonly start: 126;
+    readonly stop: 127;
+    readonly interrupt: 128;
+    readonly receive: 129;
+};
+export declare const RESOURCE_ALLOCATION_REQUEST: {
+    readonly request: 130;
+    readonly response: 131;
+};
+export declare const STATEMENT_STORE_CREATE_PROOF_AUTHORIZED: {
+    readonly request: 132;
+    readonly response: 133;
+};
+export declare const NOTIFICATIONS_CANCEL_PUSH_NOTIFICATION: {
+    readonly request: 134;
+    readonly response: 135;
+};
+
+
+// index.d.ts
+
+
+// playground/codegen/services.d.ts
+export declare const services: ServiceInfo[];
+
+
+// playground/services-types.d.ts
+export interface MethodInfo {
+    name: string;
+    type: "unary" | "subscription";
+    /** TS-shaped signature for the method (e.g. \`getAccount(request: HostAccountGetRequest): Promise<…>\`). */
+    signature?: string;
+    /** Cargo-doc URL fragment for this method (relative to the rustdoc root for the truapi crate). */
+    docUrl?: string;
+    description?: string;
+    requestDescription?: string;
+    exampleSource?: string;
+    /** DataType id (kebab-case) of the method's request payload, when applicable. */
+    requestType?: string;
+    /** DataType id of the method's response. */
+    responseType?: string;
+    /** DataType id of the method's error. */
+    errorType?: string;
+}
+export interface ServiceInfo {
+    name: string;
+    methods: MethodInfo[];
+}
+
+
+// transport.d.ts
+/**
+ * Handle returned by TrUAPI subscription APIs.
+ **/
+export interface Subscription {
+    /**
+     * Stop the subscription. Calling this more than once has no additional effect.
+     **/
+    unsubscribe: () => void;
+    /**
+     * Transport-assigned request id for the subscription start frame.
+     *
+     * Methods that accept a \`followSubscriptionId\` use this value to scope
+     * follow-up requests to a specific active subscription.
+     **/
+    subscriptionId: string;
+}
+/**
+ * Terminal error delivered through \`Observer.error\` for every non-normal
+ * subscription end. When the peer interrupted the stream with a typed payload,
+ * \`reason\` carries the decoded \`Reason\`; otherwise \`reason\` is \`undefined\` and
+ * the underlying transport/decode error is preserved on \`cause\`.
+ *
+ * Discriminate with \`error.reason !== undefined\` (or \`'reason' in error\`).
+ **/
+export declare class SubscriptionError<Reason = never> extends Error {
+    /**
+     * Typed payload supplied by the peer when it interrupted the subscription.
+     * \`undefined\` when the stream ended for any other reason (transport close,
+     * decode failure, malformed interrupt payload).
+     **/
+    readonly reason?: Reason;
+    constructor(message: string, options?: {
+        reason?: Reason;
+        cause?: unknown;
+    });
+}
+/**
+ * Minimal Observable-compatible observer shape used by generated subscription
+ * APIs without depending on RxJS.
+ *
+ * \`Reason\` is the typed interrupt payload for the originating subscription.
+ * Methods without a typed interrupt resolve \`Reason\` to \`never\`, leaving
+ * \`error.reason\` typed as \`undefined\`.
+ **/
+export interface Observer<Item, Reason = never> {
+    /**
+     * Called with each successfully decoded subscription item.
+     **/
+    next(value: Item): void;
+    /**
+     * Called once when the stream terminates with an error. Inspect
+     * \`error.reason\` to distinguish a typed peer interrupt from a transport or
+     * decode failure (\`error.cause\` carries the underlying failure in the
+     * latter case).
+     **/
+    error(error: SubscriptionError<Reason>): void;
+    /**
+     * Called once when the peer normally completes the stream.
+     **/
+    complete(): void;
+}
+declare global {
+    interface SymbolConstructor {
+        readonly observable: unique symbol;
+    }
+}
+/**
+ * Minimal Observable-compatible object returned by generated subscription APIs.
+ *
+ * Implements the ES Observable interop protocol so that consumers can pass
+ * an instance straight to \`rxjs.from(...)\`.
+ **/
+export interface ObservableLike<Item, Reason = never> {
+    /**
+     * Start the stream and receive \`next\`, \`error\`, and \`complete\` callbacks.
+     **/
+    subscribe(observer?: Partial<Observer<Item, Reason>>): Subscription;
+    /**
+     * Observable interop hook. Returns \`this\`.
+     **/
+    [Symbol.observable](): ObservableLike<Item, Reason>;
+}
+/**
+ * Numeric frame ids for a one-shot request method.
+ **/
+export interface RequestFrameIds {
+    /**
+     * Wire discriminant for the outbound request frame.
+     **/
+    request: number;
+    /**
+     * Wire discriminant for the inbound response frame.
+     **/
+    response: number;
+}
+/**
+ * Numeric frame ids for a subscription method.
+ **/
+export interface SubscriptionFrameIds {
+    /**
+     * Wire discriminant for the outbound start frame.
+     **/
+    start: number;
+    /**
+     * Wire discriminant for the outbound stop frame.
+     **/
+    stop: number;
+    /**
+     * Wire discriminant for the inbound interrupt frame.
+     **/
+    interrupt: number;
+    /**
+     * Wire discriminant for the inbound receive frame.
+     **/
+    receive: number;
+}
+/**
+ * Options accepted by \`TrUApiTransport.request\`.
+ **/
+export interface RequestParams<Ok, Err> {
+    /**
+     * Wire discriminants for this request method.
+     **/
+    ids: RequestFrameIds;
+    /**
+     * SCALE-encoded request payload bytes.
+     **/
+    payload: Uint8Array;
+    /**
+     * Decode SCALE response payload bytes into the wire \`ResultPayload\`
+     * envelope. The transport unwraps the envelope into \`ResultAsync<Ok, Err>\`.
+     **/
+    decodeResponse: (payload: Uint8Array) => ResultPayload<Ok, Err>;
+}
+/**
+ * Options accepted by \`TrUApiTransport.subscribeRaw\`.
+ **/
+export interface SubscribeRawParams {
+    /**
+     * Wire discriminants for this subscription method.
+     **/
+    ids: SubscriptionFrameIds;
+    /**
+     * SCALE-encoded subscription start payload bytes.
+     **/
+    payload: Uint8Array;
+    /**
+     * Called with raw SCALE receive payload bytes.
+     **/
+    onReceive: (payload: Uint8Array) => void;
+    /**
+     * Called with raw SCALE interrupt payload bytes when the peer interrupts the subscription.
+     **/
+    onInterrupt?: (payload: Uint8Array) => void;
+    /**
+     * Called when the underlying provider closes while the subscription is active.
+     **/
+    onClose?: (error: Error) => void;
+}
+/**
+ * Byte-level transport used by generated client stubs.
+ **/
+export interface TrUApiTransport {
+    /**
+     * Highest TrUAPI protocol version supported by this generated client.
+     **/
+    readonly truapiVersion: number;
+    /**
+     * SCALE codec version negotiated through the handshake.
+     **/
+    readonly codecVersion: number;
+    /**
+     * Send a one-shot request and resolve with the typed Ok/Err outcome.
+     **/
+    request<Ok, Err>(params: RequestParams<Ok, Err>): ResultAsync<Ok, Err>;
+    /**
+     * Start a subscription and return a handle that can stop it.
+     **/
+    subscribeRaw(params: SubscribeRawParams): Subscription;
+    /**
+     * Tear down the transport and release the listeners it registered on the
+     * underlying \`Provider\`. Pending requests reject and live subscriptions
+     * receive \`onClose\`. Idempotent.
+     *
+     * The provider itself is left alone; the caller decides whether to also
+     * call \`provider.dispose()\` (long-lived hosts that swap providers will
+     * typically dispose the transport but keep the provider).
+     **/
+    dispose(): void;
+}
+/**
+ * Tagged payload inside a TrUAPI wire frame.
+ **/
+export interface Payload {
+    /**
+     * Wire-table numeric discriminant.
+     **/
+    id: number;
+    /**
+     * SCALE-encoded payload body.
+     **/
+    value: Uint8Array;
+}
+/**
+ * Top-level TrUAPI wire message.
+ **/
+export interface ProtocolMessage {
+    /**
+     * Request id used to correlate request/response and subscription frames.
+     **/
+    requestId: string;
+    /**
+     * Tagged SCALE payload carried by this frame.
+     **/
+    payload: Payload;
+}
+/**
+ * Raw message pipe abstraction used by the transport.
+ **/
+export interface Provider {
+    /**
+     * Send a complete SCALE-encoded wire frame to the peer.
+     **/
+    postMessage(message: Uint8Array): void;
+    /**
+     * Register a callback for inbound SCALE-encoded wire frames.
+     **/
+    subscribe(callback: (message: Uint8Array) => void): () => void;
+    /**
+     * Register a callback for provider-level close or failure events.
+     **/
+    subscribeClose?(callback: (error: Error) => void): () => void;
+    /**
+     * Release provider resources and close the underlying pipe.
+     **/
+    dispose(): void;
+}
+/**
+ * Encode a \`ProtocolMessage\` into a SCALE wire frame.
+ **/
+export declare function encodeWireMessage(message: ProtocolMessage): Result<Uint8Array, Error>;
+/**
+ * Decode a SCALE wire frame into a \`ProtocolMessage\`.
+ **/
+export declare function decodeWireMessage(message: Uint8Array): Result<ProtocolMessage, Error>;
+/**
+ * Create a provider for the child side of an iframe \`postMessage\` channel.
+ *
+ * \`target\` is the \`Window\` the provider posts to (typically \`window.parent\`);
+ * \`hostOrigin\` is the pinned \`targetOrigin\` for outbound frames and the
+ * required \`event.origin\` of inbound frames. The provider only delivers
+ * frames whose \`event.source === target\` and \`event.origin === hostOrigin\`,
+ * so it cannot be coerced by an unrelated frame parent.
+ **/
+export declare function createIframeProvider(options: {
+    target: Window;
+    hostOrigin: string;
+}): Provider;
+/**
+ * Create a provider from a web or Electron \`MessagePort\`.
+ **/
+export declare function createMessagePortProvider(port: MessagePort | Promise<MessagePort>): Provider;
+
+
+// well-known-chains.d.ts
+/** Well-known chain descriptors. Each chain is its own \`export const\` so that
+ * bundlers can tree-shake the ones a consumer does not import. */
+export interface WellKnownChain {
+    readonly name: string;
+    readonly network: "Mainnet" | "Testnet";
+    readonly genesis: HexString;
+}
+export declare const PASEO_NEXT_V2_ASSET_HUB: {
+    readonly name: "Paseo Next v2 Hub";
+    readonly network: "Testnet";
+    readonly genesis: "0xbf0488dbe9daa1de1c08c5f743e26fdc2a4ecd74cf87dd1b4b1eeb99ae4ef19f";
+};
+`;