dogecoin-core-trpc-api 0.0.3 → 0.0.4

package/dist/index-xhjl7-E2.d.cts

@@ -0,0 +1,1350 @@
+//#region node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
+//#region src/observable/types.d.ts
+interface Unsubscribable {
+  unsubscribe(): void;
+}
+interface Subscribable<TValue, TError> {
+  subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
+}
+interface Observable<TValue, TError> extends Subscribable<TValue, TError> {
+  pipe(): Observable<TValue, TError>;
+  pipe<TValue1, TError1>(op1: OperatorFunction<TValue, TError, TValue1, TError1>): Observable<TValue1, TError1>;
+  pipe<TValue1, TError1, TValue2, TError2>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4, TValue5, TError5>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>, op5: OperatorFunction<TValue4, TError4, TValue5, TError5>): Observable<TValue2, TError2>;
+}
+interface Observer<TValue, TError> {
+  next: (value: TValue) => void;
+  error: (err: TError) => void;
+  complete: () => void;
+}
+type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
+type OperatorFunction<TValueBefore, TErrorBefore, TValueAfter, TErrorAfter> = UnaryFunction<Subscribable<TValueBefore, TErrorBefore>, Subscribable<TValueAfter, TErrorAfter>>;
+//#endregion
+//#region node_modules/@trpc/server/dist/unstable-core-do-not-import.d-BdVSvUCr.d.mts
+//#region src/unstable-core-do-not-import/types.d.ts
+/**
+ * ================================
+ * Useful utility types that doesn't have anything to do with tRPC in particular
+ * ================================
+ */
+/**
+ * @public
+ */
+type Maybe<TType> = TType | null | undefined;
+/**
+ * @internal
+ * @see https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+type Simplify<TType> = TType extends any[] | Date ? TType : { [K in keyof TType]: TType[K] };
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+type MaybePromise<TType> = Promise<TType> | TType;
+/**
+ * See https://github.com/microsoft/TypeScript/issues/41966#issuecomment-758187996
+ * Fixes issues with iterating over keys of objects with index signatures.
+ * Without this, iterations over keys of objects with index signatures will lose
+ * type information about the keys and only the index signature will remain.
+ * @internal
+ */
+type WithoutIndexSignature<TObj> = { [K in keyof TObj as string extends K ? never : number extends K ? never : K]: TObj[K] };
+/**
+ * @internal
+ * Overwrite properties in `TType` with properties in `TWith`
+ * Only overwrites properties when the type to be overwritten
+ * is an object. Otherwise it will just use the type from `TWith`.
+ */
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+type GetRawInputFn = () => Promise<unknown>;
+declare const _errorSymbol: unique symbol;
+type TypeError<TMessage extends string> = TMessage & {
+  _: typeof _errorSymbol;
+};
+type ValueOf<TObj> = TObj[keyof TObj];
+/**
+ * @internal
+ * Infers the type of the value yielded by an async iterable
+ */
+type inferAsyncIterableYield<T> = T extends AsyncIterable<infer U> ? U : T; //#endregion
+//#region src/unstable-core-do-not-import/rpc/codes.d.ts
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */
+declare const TRPC_ERROR_CODES_BY_KEY: {
+  /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */
+  readonly PARSE_ERROR: -32700;
+  /**
+   * The JSON sent is not a valid Request object.
+   */
+  readonly BAD_REQUEST: -32600;
+  readonly INTERNAL_SERVER_ERROR: -32603;
+  readonly NOT_IMPLEMENTED: -32603;
+  readonly BAD_GATEWAY: -32603;
+  readonly SERVICE_UNAVAILABLE: -32603;
+  readonly GATEWAY_TIMEOUT: -32603;
+  readonly UNAUTHORIZED: -32001;
+  readonly PAYMENT_REQUIRED: -32002;
+  readonly FORBIDDEN: -32003;
+  readonly NOT_FOUND: -32004;
+  readonly METHOD_NOT_SUPPORTED: -32005;
+  readonly TIMEOUT: -32008;
+  readonly CONFLICT: -32009;
+  readonly PRECONDITION_FAILED: -32012;
+  readonly PAYLOAD_TOO_LARGE: -32013;
+  readonly UNSUPPORTED_MEDIA_TYPE: -32015;
+  readonly UNPROCESSABLE_CONTENT: -32022;
+  readonly PRECONDITION_REQUIRED: -32028;
+  readonly TOO_MANY_REQUESTS: -32029;
+  readonly CLIENT_CLOSED_REQUEST: -32099;
+};
+type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
+type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;
+/**
+ * tRPC error codes that are considered retryable
+ * With out of the box SSE, the client will reconnect when these errors are encountered
+ */
+declare class TRPCError extends Error {
+  readonly cause?: Error;
+  readonly code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
+  constructor(opts: {
+    message?: string;
+    code: TRPC_ERROR_CODE_KEY;
+    cause?: unknown;
+  });
+} //# sourceMappingURL=TRPCError.d.ts.map
+//#endregion
+//#region src/vendor/standard-schema-v1/spec.d.ts
+/**
+ *
+ * @see https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
+ */
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+} //# sourceMappingURL=spec.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/parser.d.ts
+type ParserZodEsque<TInput, TParsedInput> = {
+  _input: TInput;
+  _output: TParsedInput;
+};
+type ParserValibotEsque<TInput, TParsedInput> = {
+  schema: {
+    _types?: {
+      input: TInput;
+      output: TParsedInput;
+    };
+  };
+};
+type ParserArkTypeEsque<TInput, TParsedInput> = {
+  inferIn: TInput;
+  infer: TParsedInput;
+};
+type ParserStandardSchemaEsque<TInput, TParsedInput> = StandardSchemaV1<TInput, TParsedInput>;
+type ParserMyZodEsque<TInput> = {
+  parse: (input: any) => TInput;
+};
+type ParserSuperstructEsque<TInput> = {
+  create: (input: unknown) => TInput;
+};
+type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
+type ParserYupEsque<TInput> = {
+  validateSync: (input: unknown) => TInput;
+};
+type ParserScaleEsque<TInput> = {
+  assert(value: unknown): asserts value is TInput;
+};
+type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
+type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput> | ParserArkTypeEsque<TInput, TParsedInput> | ParserStandardSchemaEsque<TInput, TParsedInput>;
+type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+/**
+ * @internal
+ */
+interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
+  getRawInput: GetRawInputFn;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+  signal: AbortSignal | undefined;
+  /**
+   * The index of this call in a batch request.
+   */
+  batchIndex: number;
+} //#endregion
+//#region src/unstable-core-do-not-import/procedure.d.ts
+declare const procedureTypes: readonly ["query", "mutation", "subscription"];
+/**
+ * @public
+ */
+type ProcedureType = (typeof procedureTypes)[number];
+interface BuiltProcedureDef {
+  meta: unknown;
+  input: unknown;
+  output: unknown;
+}
+/**
+ *
+ * @internal
+ */
+interface Procedure<TType extends ProcedureType, TDef extends BuiltProcedureDef> {
+  _def: {
+    /**
+     * These are just types, they can't be used at runtime
+     * @internal
+     */
+    $types: {
+      input: TDef['input'];
+      output: TDef['output'];
+    };
+    procedure: true;
+    type: TType;
+    /**
+     * @internal
+     * Meta is not inferrable on individual procedures, only on the router
+     */
+    meta: unknown;
+    experimental_caller: boolean;
+    /**
+     * The input parsers for the procedure
+     */
+    inputs: Parser[];
+  };
+  meta: TDef['meta'];
+  /**
+   * @internal
+   */
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
+}
+interface QueryProcedure<TDef extends BuiltProcedureDef> extends Procedure<'query', TDef> {}
+interface MutationProcedure<TDef extends BuiltProcedureDef> extends Procedure<'mutation', TDef> {}
+interface SubscriptionProcedure<TDef extends BuiltProcedureDef> extends Procedure<'subscription', TDef> {}
+/**
+ * @deprecated
+ */
+interface LegacyObservableSubscriptionProcedure<TDef extends BuiltProcedureDef> extends SubscriptionProcedure<TDef> {
+  _observable: true;
+}
+type AnyQueryProcedure = QueryProcedure<any>;
+type AnyMutationProcedure = MutationProcedure<any>;
+type AnySubscriptionProcedure = SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
+type AnyProcedure = AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
+type inferProcedureInput<TProcedure extends AnyProcedure> = undefined extends inferProcedureParams<TProcedure>['$types']['input'] ? void | inferProcedureParams<TProcedure>['$types']['input'] : inferProcedureParams<TProcedure>['$types']['input'];
+type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure ? TProcedure['_def'] : never;
+type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>['$types']['output'];
+/**
+ * @internal
+ */
+interface ErrorHandlerOptions<TContext> {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+} //#endregion
+//#region src/unstable-core-do-not-import/http/types.d.ts
+/**
+ * @deprecated use `Headers` instead, this will be removed in v12
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/envelopes.d.ts
+/**
+ * Error response
+ */
+interface TRPCErrorShape<TData extends object = object> {
+  code: TRPC_ERROR_CODE_NUMBER;
+  message: string;
+  data: TData;
+}
+/**
+ * JSON-RPC 2.0 Specification
+ */
+declare namespace JSONRPC2 {
+  type RequestId = number | string | null;
+  /**
+   * All requests/responses extends this shape
+   */
+  interface BaseEnvelope {
+    id?: RequestId;
+    jsonrpc?: '2.0';
+  }
+  interface BaseRequest<TMethod extends string = string> extends BaseEnvelope {
+    method: TMethod;
+  }
+  interface Request<TMethod extends string = string, TParams = unknown> extends BaseRequest<TMethod> {
+    params: TParams;
+  }
+  interface ResultResponse<TResult = unknown> extends BaseEnvelope {
+    result: TResult;
+  }
+  interface ErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape> extends BaseEnvelope {
+    error: TError;
+  }
+}
+interface TRPCResult<TData = unknown> {
+  data: TData;
+  type?: 'data';
+  /**
+   * The id of the message to keep track of in case of a reconnect
+   */
+  id?: string;
+}
+interface TRPCSuccessResponse<TData> extends JSONRPC2.ResultResponse<TRPCResult<TData>> {}
+interface TRPCErrorResponse<TError extends TRPCErrorShape = TRPCErrorShape> extends JSONRPC2.ErrorResponse<TError> {}
+interface TRPCResultMessage<TData> extends JSONRPC2.ResultResponse<{
+  type: 'started';
+  data?: never;
+} | {
+  type: 'stopped';
+  data?: never;
+} | TRPCResult<TData>> {}
+//# sourceMappingURL=envelopes.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/transformer.d.ts
+/**
+ * @public
+ */
+interface DataTransformer {
+  serialize(object: any): any;
+  deserialize(object: any): any;
+}
+interface InputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the client** before sending the data to the server.
+   */
+  serialize(object: any): any;
+  /**
+   * This function runs **on the server** to transform the data before it is passed to the resolver
+   */
+  deserialize(object: any): any;
+}
+interface OutputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the server** before sending the data to the client.
+   */
+  serialize(object: any): any;
+  /**
+   * This function runs **only on the client** to transform the data sent from the server.
+   */
+  deserialize(object: any): any;
+}
+/**
+ * @public
+ */
+interface CombinedDataTransformer {
+  /**
+   * Specify how the data sent from the client to the server should be transformed.
+   */
+  input: InputDataTransformer;
+  /**
+   * Specify how the data sent from the server to the client should be transformed.
+   */
+  output: OutputDataTransformer;
+}
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
+/**
+ * @internal
+ */
+//# sourceMappingURL=parseTRPCMessage.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/error/formatter.d.ts
+/**
+ * @internal
+ */
+type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+  shape: DefaultErrorShape;
+}) => TShape;
+/**
+ * @internal
+ */
+type DefaultErrorData = {
+  code: TRPC_ERROR_CODE_KEY;
+  httpStatus: number;
+  /**
+   * Path to the procedure that threw the error
+   */
+  path?: string;
+  /**
+   * Stack trace of the error (only in development)
+   */
+  stack?: string;
+};
+/**
+ * @internal
+ */
+interface DefaultErrorShape extends TRPCErrorShape<DefaultErrorData> {
+  message: string;
+  code: TRPC_ERROR_CODE_NUMBER;
+}
+type Serialize$2 = (value: any) => any;
+type PathArray = readonly (string | number)[];
+type ProducerOnError = (opts: {
+  error: unknown;
+  path: PathArray;
+}) => void;
+interface JSONLProducerOptions {
+  serialize?: Serialize$2;
+  data: Record<string, unknown> | unknown[];
+  onError?: ProducerOnError;
+  formatError?: (opts: {
+    error: unknown;
+    path: PathArray;
+  }) => unknown;
+  maxDepth?: number;
+  /**
+   * Interval in milliseconds to send a ping to the client to keep the connection alive
+   * This will be sent as a whitespace character
+   * @default undefined
+   */
+  pingMs?: number;
+}
+/**
+ * JSON Lines stream producer
+ * @see https://jsonlines.org/
+ */
+//# sourceMappingURL=sse.types.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/stream/sse.d.ts
+type Serialize$1 = (value: any) => any;
+/**
+ * @internal
+ */
+interface SSEPingOptions {
+  /**
+   * Enable ping comments sent from the server
+   * @default false
+   */
+  enabled: boolean;
+  /**
+   * Interval in milliseconds
+   * @default 1000
+   */
+  intervalMs?: number;
+}
+interface SSEClientOptions {
+  /**
+   * Timeout and reconnect after inactivity in milliseconds
+   * @default undefined
+   */
+  reconnectAfterInactivityMs?: number;
+}
+interface SSEStreamProducerOptions<TValue = unknown> {
+  serialize?: Serialize$1;
+  data: AsyncIterable<TValue>;
+  maxDepth?: number;
+  ping?: SSEPingOptions;
+  /**
+   * Maximum duration in milliseconds for the request before ending the stream
+   * @default undefined
+   */
+  maxDurationMs?: number;
+  /**
+   * End the request immediately after data is sent
+   * Only useful for serverless runtimes that do not support streaming responses
+   * @default false
+   */
+  emitAndEndImmediately?: boolean;
+  formatError?: (opts: {
+    error: unknown;
+  }) => unknown;
+  /**
+   * Client-specific options - these will be sent to the client as part of the first message
+   * @default {}
+   */
+  client?: SSEClientOptions;
+}
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/rootConfig.d.ts
+/**
+ * The initial generics that are used in the init function
+ * @internal
+ */
+interface RootTypes {
+  ctx: object;
+  meta: object;
+  errorShape: DefaultErrorShape;
+  transformer: boolean;
+}
+/**
+ * The default check to see if we're in a server
+ */
+/**
+ * The tRPC root config
+ * @internal
+ */
+interface RootConfig<TTypes extends RootTypes> {
+  /**
+   * The types that are used in the config
+   * @internal
+   */
+  $types: TTypes;
+  /**
+   * Use a data transformer
+   * @see https://trpc.io/docs/v11/data-transformers
+   */
+  transformer: CombinedDataTransformer;
+  /**
+   * Use custom error formatting
+   * @see https://trpc.io/docs/v11/error-formatting
+   */
+  errorFormatter: ErrorFormatter<TTypes['ctx'], TTypes['errorShape']>;
+  /**
+   * Allow `@trpc/server` to run in non-server environments
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default false
+   */
+  allowOutsideOfServer: boolean;
+  /**
+   * Is this a server environment?
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
+   */
+  isServer: boolean;
+  /**
+   * Is this development?
+   * Will be used to decide if the API should return stack traces
+   * @default process.env.NODE_ENV !== 'production'
+   */
+  isDev: boolean;
+  defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
+  /**
+   * Options for server-sent events (SSE) subscriptions
+   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+   */
+  sse?: {
+    /**
+     * Enable server-sent events (SSE) subscriptions
+     * @default true
+     */
+    enabled?: boolean;
+  } & Pick<SSEStreamProducerOptions, 'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'>;
+  /**
+   * Options for batch stream
+   * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+   */
+  jsonl?: Pick<JSONLProducerOptions, 'pingMs'>;
+  experimental?: {};
+}
+/**
+ * @internal
+ */
+type CreateRootTypes<TGenerics extends RootTypes> = TGenerics;
+type AnyRootTypes = CreateRootTypes<{
+  ctx: any;
+  meta: any;
+  errorShape: any;
+  transformer: any;
+}>;
+//#endregion
+//#region src/unstable-core-do-not-import/router.d.ts
+interface RouterRecord {
+  [key: string]: AnyProcedure | RouterRecord;
+}
+type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedureInput<TProcedure>) => Promise<TProcedure['_def']['type'] extends 'subscription' ? TProcedure extends LegacyObservableSubscriptionProcedure<any> ? Observable<inferProcedureOutput<TProcedure>, TRPCError> : inferProcedureOutput<TProcedure> : inferProcedureOutput<TProcedure>>;
+/**
+ * @internal
+ */
+type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never };
+/**
+ * @internal
+ */
+type RouterCallerErrorHandler<TContext> = (opts: ErrorHandlerOptions<TContext>) => void;
+/**
+ * @internal
+ */
+type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
+/**
+ * @note
+ * If passing a function, we recommend it's a cached function
+ * e.g. wrapped in `React.cache` to avoid unnecessary computations
+ */
+
+ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>), options?: {
+  onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+  signal?: AbortSignal;
+}) => DecorateRouterRecord<TRecord>;
+type Lazy<TAny> = (() => Promise<TAny>) & {};
+type LazyLoader<TAny> = {
+  load: () => Promise<void>;
+  ref: Lazy<TAny>;
+};
+/**
+ * Lazy load a router
+ * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ */
+/**
+ * @internal
+ */
+interface RouterDef<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _config: RootConfig<TRoot>;
+  router: true;
+  procedure?: never;
+  procedures: TRecord;
+  record: TRecord;
+  lazy: Record<string, LazyLoader<AnyRouter>>;
+}
+interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _def: RouterDef<TRoot, TRecord>;
+  /**
+   * @see https://trpc.io/docs/v11/server/server-side-calls
+   */
+  createCaller: RouterCaller<TRoot, TRecord>;
+}
+type BuiltRouter<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = Router<TRoot, TRecord> & TRecord;
+type AnyRouter = Router<any, any>;
+/** @internal */
+type CreateRouterOptions = {
+  [key: string]: AnyProcedure | AnyRouter | CreateRouterOptions | Lazy<AnyRouter>;
+};
+/** @internal */
+type DecorateCreateRouterOptions<TRouterOptions extends CreateRouterOptions> = { [K in keyof TRouterOptions]: TRouterOptions[K] extends infer $Value ? $Value extends AnyProcedure ? $Value : $Value extends Router<any, infer TRecord> ? TRecord : $Value extends Lazy<Router<any, infer TRecord>> ? TRecord : $Value extends CreateRouterOptions ? DecorateCreateRouterOptions<$Value> : never : never };
+/**
+ * @internal
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/clientish/inferrable.d.ts
+type AnyClientTypes = Pick<AnyRootTypes, 'errorShape' | 'transformer'>;
+/**
+ * Result of `initTRPC.create()`
+ */
+type InitLike = {
+  _config: {
+    $types: AnyClientTypes;
+  };
+};
+/**
+ * Result of `initTRPC.create().router()`
+ */
+type RouterLike = {
+  _def: InitLike;
+};
+/**
+ * Result of `initTRPC.create()._config`
+ */
+type RootConfigLike = {
+  $types: AnyClientTypes;
+};
+/**
+ * Anything that can be inferred to the root config types needed for a TRPC client
+ */
+type InferrableClientTypes = RouterLike | InitLike | RootConfigLike | AnyClientTypes;
+type PickTypes<T extends AnyClientTypes> = {
+  transformer: T['transformer'];
+  errorShape: T['errorShape'];
+};
+/**
+ * Infer the root types from a InferrableClientTypes
+ */
+type inferClientTypes<TInferrable extends InferrableClientTypes> = TInferrable extends AnyClientTypes ? PickTypes<TInferrable> : TInferrable extends RootConfigLike ? PickTypes<TInferrable['$types']> : TInferrable extends InitLike ? PickTypes<TInferrable['_config']['$types']> : TInferrable extends RouterLike ? PickTypes<TInferrable['_def']['_config']['$types']> : never; //#endregion
+//#region src/unstable-core-do-not-import/clientish/serialize.d.ts
+/**
+ * @see https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
+ */
+type JsonPrimitive = boolean | number | string | null;
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonObject = {
+  readonly [key: string | number]: JsonValue;
+  [key: symbol]: never;
+};
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type IsJson<T> = T extends JsonValue ? true : false;
+type NonJsonPrimitive = Function | symbol | undefined;
+type IsAny<T> = 0 extends T & 1 ? true : false;
+type JsonReturnable = JsonPrimitive | undefined;
+type IsRecord<T extends object> = keyof WithoutIndexSignature<T> extends never ? true : false;
+type Serialize<T> = IsAny<T> extends true ? any : unknown extends T ? unknown : IsJson<T> extends true ? T : T extends AsyncIterable<infer $T, infer $Return, infer $Next> ? AsyncIterable<Serialize<$T>, Serialize<$Return>, Serialize<$Next>> : T extends PromiseLike<infer $T> ? Promise<Serialize<$T>> : T extends JsonReturnable ? T : T extends Map<any, any> | Set<any> ? object : T extends NonJsonPrimitive ? never : T extends {
+  toJSON(): infer U;
+} ? U : T extends [] ? [] : T extends [unknown, ...unknown[]] ? SerializeTuple<T> : T extends readonly (infer U)[] ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] : T extends object ? IsRecord<T> extends true ? Record<keyof T, Serialize<T[keyof T]>> : Simplify<SerializeObject<UndefinedToOptional<T>>> : never;
+/** JSON serialize [tuples](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) */
+type SerializeTuple<T extends [unknown, ...unknown[]]> = { [K in keyof T]: T[K] extends NonJsonPrimitive ? null : Serialize<T[K]> };
+type SerializeObjectKey<T extends Record<any, any>, K> = K extends symbol ? never : IsAny<T[K]> extends true ? K : unknown extends T[K] ? K : T[K] extends NonJsonPrimitive ? never : K;
+/**
+ * JSON serialize objects (not including arrays) and classes
+ * @internal
+ **/
+type SerializeObject<T extends object> = { [K in keyof T as SerializeObjectKey<T, K>]: Serialize<T[K]> };
+/**
+ * Extract keys from T where the value dosen't extend undefined
+ * Note: Can't parse IndexSignature or Record types
+ */
+type FilterDefinedKeys<T extends object> = Exclude<{ [K in keyof T]: undefined extends T[K] ? never : K }[keyof T], undefined>;
+/**
+ * Get value of exactOptionalPropertyTypes config
+ */
+type ExactOptionalPropertyTypes = {
+  a?: 0 | undefined;
+} extends {
+  a?: 0;
+} ? false : true;
+/**
+ * Check if T has an index signature
+ */
+type HasIndexSignature<T extends object> = string extends keyof T ? true : false;
+/**
+ * { [key: string]: number | undefined } --> { [key: string]: number }
+ */
+type HandleIndexSignature<T extends object> = { [K in keyof Omit<T, keyof WithoutIndexSignature<T>>]: Exclude<T[K], undefined> };
+/**
+ * { a: number | undefined } --> { a?: number }
+ * Note: Can't parse IndexSignature or Record types
+ */
+type HandleUndefined<T extends object> = { [K in keyof Omit<T, FilterDefinedKeys<T>>]?: Exclude<T[K], undefined> };
+/**
+ * Handle undefined, index signature and records
+ */
+type UndefinedToOptional<T extends object> = Pick<WithoutIndexSignature<T>, FilterDefinedKeys<WithoutIndexSignature<T>>> & (ExactOptionalPropertyTypes extends true ? HandleIndexSignature<T> & HandleUndefined<WithoutIndexSignature<T>> : HasIndexSignature<T> extends true ? HandleIndexSignature<T> : HandleUndefined<T>); //#endregion
+//#region src/unstable-core-do-not-import/clientish/inference.d.ts
+/**
+ * @internal
+ */
+type inferTransformedProcedureOutput<TInferrable extends InferrableClientTypes, TProcedure extends AnyProcedure> = inferClientTypes<TInferrable>['transformer'] extends false ? Serialize<inferProcedureOutput<TProcedure>> : inferProcedureOutput<TProcedure>;
+/** @internal */
+//#endregion
+//#region src/server/index.d.ts
+declare const appRouter: BuiltRouter<{
+  ctx: object;
+  meta: object;
+  errorShape: {
+    data: {
+      zodError: {
+        errors: string[];
+      } | null;
+      code: TRPC_ERROR_CODE_KEY;
+      httpStatus: number;
+      path?: string;
+      stack?: string;
+    };
+    message: string;
+    code: TRPC_ERROR_CODE_NUMBER;
+  };
+  transformer: true;
+}, DecorateCreateRouterOptions<{
+  estimateSmartFee: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      nblocks: number;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        feerate: number;
+        blocks: number;
+      };
+    };
+    meta: object;
+  }>;
+  getNetworkInfo: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        version: number;
+        subversion: string;
+        protocolversion: number;
+        localservices: string;
+        localrelay: boolean;
+        timeoffset: number;
+        networkactive: boolean;
+        connections: number;
+        networks: {
+          name: string;
+          limited: boolean;
+          reachable: boolean;
+          proxy: string;
+          proxy_randomize_credentials: boolean;
+        }[];
+        relayfee: number;
+        incrementalfee: number;
+        softdustlimit: number;
+        harddustlimit: number;
+        localaddresses: {
+          address: string;
+          port: number;
+          score: number;
+        }[];
+        warnings?: string | undefined;
+      };
+    };
+    meta: object;
+  }>;
+  getRawTransaction: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      txid: string;
+      verbose?: boolean | undefined;
+      blockhash?: string | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string | {
+        hex: string;
+        txid: string;
+        hash: string;
+        size: number;
+        vsize: number;
+        version: number;
+        locktime: number;
+        vin: {
+          txid?: string | undefined;
+          vout?: number | undefined;
+          scriptSig?: {
+            asm: string;
+            hex: string;
+          } | undefined;
+          sequence?: number | undefined;
+        }[];
+        vout: {
+          value: number;
+          n: number;
+          scriptPubKey: {
+            asm: string;
+            hex: string;
+            type: string;
+            addresses: string[];
+            reqSigs?: number | undefined;
+          };
+        }[];
+        blockhash?: string | undefined;
+        confirmations?: number | undefined;
+        time?: number | undefined;
+        blocktime?: number | undefined;
+      };
+    };
+    meta: object;
+  }>;
+  getBlockHash: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      height: number;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string;
+    };
+    meta: object;
+  }>;
+  getBlock: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      blockhash: string;
+      verbosity?: number | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string | {
+        hash: string;
+        confirmations: number;
+        size: number;
+        height: number;
+        version: number;
+        merkleroot: string;
+        tx: unknown[];
+        time: number;
+        nonce: number;
+        bits: string;
+        difficulty: number;
+        strippedsize?: number | undefined;
+        weight?: number | undefined;
+        versionHex?: string | undefined;
+        mediantime?: number | undefined;
+        chainwork?: string | undefined;
+        nTx?: number | undefined;
+        previousblockhash?: string | undefined;
+        nextblockhash?: string | undefined;
+      };
+    };
+    meta: object;
+  }>;
+  getBlockHeader: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      blockhash: string;
+      verbose?: boolean | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string | {
+        hash: string;
+        confirmations: number;
+        height: number;
+        version: number;
+        merkleroot: string;
+        time: number;
+        nonce: number;
+        bits: string;
+        difficulty: number;
+        versionHex?: string | undefined;
+        mediantime?: number | undefined;
+        chainwork?: string | undefined;
+        previousblockhash?: string | undefined;
+        nextblockhash?: string | undefined;
+      };
+    };
+    meta: object;
+  }>;
+  getTxOut: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      txid: string;
+      n: number;
+      include_mempool?: boolean | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        bestblock: string;
+        confirmations: number;
+        value: number;
+        scriptPubKey: {
+          asm: string;
+          hex: string;
+          type: string;
+          reqSigs?: number | undefined;
+          addresses?: string[] | undefined;
+        };
+        coinbase: boolean;
+      } | null;
+    };
+    meta: object;
+  }>;
+  getChainTips: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        height: number;
+        hash: string;
+        branchlen: number;
+        status: string;
+      }[];
+    };
+    meta: object;
+  }>;
+  getRawMempool: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      verbose?: boolean | undefined;
+      mempool_sequence?: boolean | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string[] | Record<string, {
+        vsize: number;
+        time: number;
+        height: number;
+        descendantcount: number;
+        descendantsize: number;
+        ancestorcount: number;
+        ancestorsize: number;
+        depends: string[];
+        weight?: number | undefined;
+        fee?: number | undefined;
+        modifiedfee?: number | undefined;
+        descendantfees?: number | undefined;
+        ancestorfees?: number | undefined;
+        wtxid?: string | undefined;
+        fees?: {
+          base: number;
+          modified: number;
+          ancestor: number;
+          descendant: number;
+        } | undefined;
+        spentby?: string[] | undefined;
+        "bip125-replaceable"?: boolean | undefined;
+        unbroadcast?: boolean | undefined;
+      }> | {
+        txids: string[];
+        mempool_sequence: number;
+      };
+    };
+    meta: object;
+  }>;
+  getMempoolEntry: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      txid: string;
+    };
+    output: Record<string, unknown> | {
+      id: string | number | null;
+      error: {
+        message: string;
+        code?: number | undefined;
+      } | null;
+      result: Record<string, unknown> | null;
+    };
+    meta: object;
+  }>;
+  getMempoolAncestors: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      txid: string;
+      verbose?: boolean | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string[] | Record<string, Record<string, unknown>>;
+    };
+    meta: object;
+  }>;
+  getMempoolDescendants: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      txid: string;
+      verbose?: boolean | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string[] | Record<string, Record<string, unknown>>;
+    };
+    meta: object;
+  }>;
+  getMempoolInfo: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        size: number;
+        bytes: number;
+        usage: number;
+        loaded?: boolean | undefined;
+        maxmempool?: number | undefined;
+        mempoolminfee?: number | undefined;
+        minrelaytxfee?: number | undefined;
+        unbroadcastcount?: number | undefined;
+      };
+    };
+    meta: object;
+  }>;
+  getBestBlockHash: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string;
+    };
+    meta: object;
+  }>;
+  getBlockCount: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: number;
+    };
+    meta: object;
+  }>;
+  getDifficulty: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: number;
+    };
+    meta: object;
+  }>;
+  getNetworkHashPs: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      nblocks?: number | undefined;
+      height?: number | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: number;
+    };
+    meta: object;
+  }>;
+  getBlockchainInfo: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        chain: string;
+        blocks: number;
+        headers: number;
+        bestblockhash: string;
+        difficulty: number;
+        mediantime: number;
+        verificationprogress: number;
+        initialblockdownload: boolean;
+        chainwork: string;
+        size_on_disk: number;
+        pruned: boolean;
+        pruneheight?: number | undefined;
+        automatic_pruning?: boolean | undefined;
+        prune_target_size?: number | undefined;
+        softforks?: Record<string, unknown> | unknown[] | undefined;
+        bip9_softforks?: Record<string, unknown> | undefined;
+        warnings?: string | undefined;
+      };
+    };
+    meta: object;
+  }>;
+  listUnspent: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      minconf?: number | undefined;
+      maxconf?: number | undefined;
+      addresses?: string[] | undefined;
+      include_unsafe?: boolean | undefined;
+      query_options?: {
+        minimumAmount?: number | undefined;
+        maximumAmount?: number | undefined;
+        maximumCount?: number | undefined;
+        minimumSumAmount?: number | undefined;
+      } | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        txid: string;
+        vout: number;
+        scriptPubKey: string;
+        amount: number;
+        confirmations: number;
+        spendable: boolean;
+        solvable: boolean;
+        address?: string | undefined;
+        account?: string | undefined;
+        redeemScript?: string | undefined;
+        safe?: boolean | undefined;
+      }[];
+    };
+    meta: object;
+  }>;
+  getTxOutProof: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      txids: string[];
+      blockhash?: string | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string;
+    };
+    meta: object;
+  }>;
+  verifyTxOutProof: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      proof: string;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string[];
+    };
+    meta: object;
+  }>;
+  validateAddress: QueryProcedure<{
+    input: {
+      requestId: string | null;
+      address: string;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: {
+        isvalid: boolean;
+        address?: string | undefined;
+        scriptPubKey?: string | undefined;
+        isscript?: boolean | undefined;
+        iswitness?: boolean | undefined;
+        witness_version?: number | undefined;
+        witness_program?: string | undefined;
+      };
+    };
+    meta: object;
+  }>;
+  ping: QueryProcedure<{
+    input: {
+      requestId: string | null;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: null;
+    };
+    meta: object;
+  }>;
+  sendRawTransaction: MutationProcedure<{
+    input: {
+      requestId: string | null;
+      hexstring: string;
+      maxfeerate?: string | number | undefined;
+    };
+    output: {
+      id: string | null;
+      error: {
+        message: string;
+      } | null;
+      result: string;
+    };
+    meta: object;
+  }>;
+  health: QueryProcedure<{
+    input: void;
+    output: {
+      status: string;
+      message: string;
+    };
+    meta: object;
+  }>;
+}>>;
+type AppRouter = typeof appRouter;
+//#endregion
+export { inferClientTypes as C, Unsubscribable as D, Observable as E, inferAsyncIterableYield as S, inferTransformedProcedureOutput as T, TRPCResultMessage as _, AnyRouter as a, TRPC_ERROR_CODE_NUMBER as b, DecorateCreateRouterOptions as c, Maybe as d, MutationProcedure as f, TRPCErrorResponse as g, RouterRecord as h, AnyProcedure as i, DefaultErrorShape as l, QueryProcedure as m, appRouter as n, BuiltRouter as o, ProcedureType as p, AnyClientTypes as r, DataTransformerOptions as s, AppRouter as t, InferrableClientTypes as u, TRPCSuccessResponse as v, inferProcedureInput as w, TypeError as x, TRPC_ERROR_CODE_KEY as y };