dogecoin-core-trpc-api 0.0.2 → 0.0.4

package/dist/client/index.d.mts

@@ -0,0 +1,907 @@
+import { C as inferClientTypes, D as Unsubscribable, E as Observable, S as inferAsyncIterableYield, T as inferTransformedProcedureOutput, _ as TRPCResultMessage, a as AnyRouter, b as TRPC_ERROR_CODE_NUMBER, c as DecorateCreateRouterOptions, d as Maybe, f as MutationProcedure, g as TRPCErrorResponse, h as RouterRecord, i as AnyProcedure, l as DefaultErrorShape, m as QueryProcedure, o as BuiltRouter, p as ProcedureType, r as AnyClientTypes, s as DataTransformerOptions, t as AppRouter, u as InferrableClientTypes, v as TRPCSuccessResponse, w as inferProcedureInput, x as TypeError, y as TRPC_ERROR_CODE_KEY } from "../index-xhjl7-E2.mjs";
+
+//#region node_modules/@trpc/client/dist/subscriptions.d-Dlr1nWGD.d.mts
+//#region src/links/internals/subscriptions.d.ts
+interface ConnectionStateBase<TError> {
+  type: 'state';
+  data?: never;
+  error: TError | null;
+}
+interface ConnectionIdleState extends ConnectionStateBase<null> {
+  state: 'idle';
+}
+interface ConnectionConnectingState<TError> extends ConnectionStateBase<TError | null> {
+  state: 'connecting';
+}
+interface ConnectionPendingState extends ConnectionStateBase<null> {
+  state: 'pending';
+}
+type TRPCConnectionState<TError> = ConnectionIdleState | ConnectionConnectingState<TError> | ConnectionPendingState; //#endregion
+//#endregion
+//#region node_modules/@trpc/client/dist/types.d-sRNtuQA-.d.mts
+//#region src/internals/types.d.ts
+/**
+ * A subset of the standard fetch function type needed by tRPC internally.
+ * @see fetch from lib.dom.d.ts
+ * @remarks
+ * If you need a property that you know exists but doesn't exist on this
+ * interface, go ahead and add it.
+ */
+type FetchEsque = (input: RequestInfo | URL | string, init?: RequestInit | RequestInitEsque) => Promise<ResponseEsque>;
+/**
+ * A simpler version of the native fetch function's type for packages with
+ * their own fetch types, such as undici and node-fetch.
+ */
+/**
+ * A subset of the standard RequestInit properties needed by tRPC internally.
+ * @see RequestInit from lib.dom.d.ts
+ * @remarks
+ * If you need a property that you know exists but doesn't exist on this
+ * interface, go ahead and add it.
+ */
+interface RequestInitEsque {
+  /**
+   * Sets the request's body.
+   */
+  body?: FormData | string | null | Uint8Array<ArrayBuffer> | Blob | File;
+  /**
+   * Sets the request's associated headers.
+   */
+  headers?: [string, string][] | Record<string, string>;
+  /**
+   * The request's HTTP-style method.
+   */
+  method?: string;
+  /**
+   * Sets the request's signal.
+   */
+  signal?: AbortSignal | undefined;
+}
+/**
+ * A subset of the standard ReadableStream properties needed by tRPC internally.
+ * @see ReadableStream from lib.dom.d.ts
+ */
+type WebReadableStreamEsque = {
+  getReader: () => ReadableStreamDefaultReader<Uint8Array>;
+};
+type NodeJSReadableStreamEsque = {
+  on(eventName: string | symbol, listener: (...args: any[]) => void): NodeJSReadableStreamEsque;
+};
+/**
+ * A subset of the standard Response properties needed by tRPC internally.
+ * @see Response from lib.dom.d.ts
+ */
+interface ResponseEsque {
+  readonly ok: boolean;
+  readonly body?: NodeJSReadableStreamEsque | WebReadableStreamEsque | null;
+  /**
+   * @remarks
+   * The built-in Response::json() method returns Promise<any>, but
+   * that's not as type-safe as unknown. We use unknown because we're
+   * more type-safe. You do want more type safety, right? 😉
+   */
+  json(): Promise<unknown>;
+}
+/**
+ * @internal
+ */
+type NonEmptyArray<TItem> = [TItem, ...TItem[]];
+type ClientContext = Record<string, unknown>;
+/**
+ * @public
+ */
+interface TRPCProcedureOptions {
+  /**
+   * Client-side context
+   */
+  context?: ClientContext;
+  signal?: AbortSignal;
+} //#endregion
+//#region src/TRPCClientError.d.ts
+type inferErrorShape<TInferrable extends InferrableClientTypes> = inferClientTypes<TInferrable>['errorShape'];
+interface TRPCClientErrorBase<TShape extends DefaultErrorShape> {
+  readonly message: string;
+  readonly shape: Maybe<TShape>;
+  readonly data: Maybe<TShape['data']>;
+}
+declare class TRPCClientError<TRouterOrProcedure extends InferrableClientTypes> extends Error implements TRPCClientErrorBase<inferErrorShape<TRouterOrProcedure>> {
+  readonly cause: Error | undefined;
+  readonly shape: Maybe<inferErrorShape<TRouterOrProcedure>>;
+  readonly data: Maybe<inferErrorShape<TRouterOrProcedure>['data']>;
+  /**
+   * Additional meta data about the error
+   * In the case of HTTP-errors, we'll have `response` and potentially `responseJSON` here
+   */
+  meta: Record<string, unknown> | undefined;
+  constructor(message: string, opts?: {
+    result?: Maybe<TRPCErrorResponse<inferErrorShape<TRouterOrProcedure>>>;
+    cause?: Error;
+    meta?: Record<string, unknown>;
+  });
+  static from<TRouterOrProcedure extends InferrableClientTypes>(_cause: Error | TRPCErrorResponse<any> | object, opts?: {
+    meta?: Record<string, unknown>;
+    cause?: Error;
+  }): TRPCClientError<TRouterOrProcedure>;
+} //#endregion
+//#region src/links/internals/contentTypes.d.ts
+//# sourceMappingURL=contentTypes.d.ts.map
+//#endregion
+//#region src/links/types.d.ts
+/**
+ * @internal
+ */
+interface OperationContext extends Record<string, unknown> {}
+/**
+ * @internal
+ */
+type Operation<TInput = unknown> = {
+  id: number;
+  type: 'mutation' | 'query' | 'subscription';
+  input: TInput;
+  path: string;
+  context: OperationContext;
+  signal: Maybe<AbortSignal>;
+};
+interface HeadersInitEsque {
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+/**
+ * @internal
+ */
+type HTTPHeaders = HeadersInitEsque | Record<string, string[] | string | undefined>;
+/**
+ * The default `fetch` implementation has an overloaded signature. By convention this library
+ * only uses the overload taking a string and options object.
+ */
+interface TRPCClientRuntime {}
+/**
+ * @internal
+ */
+interface OperationResultEnvelope<TOutput, TError> {
+  result: TRPCResultMessage<TOutput>['result'] | TRPCSuccessResponse<TOutput>['result'] | TRPCConnectionState<TError>;
+  context?: OperationContext;
+}
+/**
+ * @internal
+ */
+type OperationResultObservable<TInferrable extends InferrableClientTypes, TOutput> = Observable<OperationResultEnvelope<TOutput, TRPCClientError<TInferrable>>, TRPCClientError<TInferrable>>;
+/**
+ * @internal
+ */
+/**
+ * @internal
+ */
+type OperationLink<TInferrable extends InferrableClientTypes, TInput = unknown, TOutput = unknown> = (opts: {
+  op: Operation<TInput>;
+  next: (op: Operation<TInput>) => OperationResultObservable<TInferrable, TOutput>;
+}) => OperationResultObservable<TInferrable, TOutput>;
+/**
+ * @public
+ */
+type TRPCLink<TInferrable extends InferrableClientTypes> = (opts: TRPCClientRuntime) => OperationLink<TInferrable>; //# sourceMappingURL=types.d.ts.map
+//#endregion
+//#endregion
+//#region node_modules/@trpc/client/dist/unstable-internals.d-BOmV7EK1.d.mts
+type TransformerOptionYes = {
+  /**
+   * Data transformer
+   *
+   * You must use the same transformer on the backend and frontend
+   * @see https://trpc.io/docs/v11/data-transformers
+   **/
+  transformer: DataTransformerOptions;
+};
+type TransformerOptionNo = {
+  /**
+   * Data transformer
+   *
+   * You must use the same transformer on the backend and frontend
+   * @see https://trpc.io/docs/v11/data-transformers
+   **/
+  transformer?: TypeError<'You must define a transformer on your your `initTRPC`-object first'>;
+};
+/**
+ * @internal
+ */
+type TransformerOptions<TRoot extends Pick<AnyClientTypes, 'transformer'>> = TRoot['transformer'] extends true ? TransformerOptionYes : TransformerOptionNo;
+/**
+ * @internal
+ */
+/**
+ * @internal
+ */
+//#endregion
+//#region node_modules/@trpc/client/dist/httpUtils.d-yYSKGhiS.d.mts
+//#region src/links/internals/httpUtils.d.ts
+/**
+ * @internal
+ */
+type HTTPLinkBaseOptions<TRoot extends Pick<AnyClientTypes, 'transformer'>> = {
+  url: string | URL;
+  /**
+   * Add ponyfill for fetch
+   */
+  fetch?: FetchEsque;
+  /**
+   * Send all requests `as POST`s requests regardless of the procedure type
+   * The HTTP handler must separately allow overriding the method. See:
+   * @see https://trpc.io/docs/rpc
+   */
+  methodOverride?: 'POST';
+} & TransformerOptions<TRoot>; //#endregion
+//#endregion
+//#region node_modules/@trpc/client/dist/httpBatchLink.d-B6vCg-F-.d.mts
+//#region src/links/HTTPBatchLinkOptions.d.ts
+type HTTPBatchLinkOptions<TRoot extends AnyClientTypes> = HTTPLinkBaseOptions<TRoot> & {
+  maxURLLength?: number;
+  /**
+   * Headers to be set on outgoing requests or a callback that of said headers
+   * @see http://trpc.io/docs/client/headers
+   */
+  headers?: HTTPHeaders | ((opts: {
+    opList: NonEmptyArray<Operation>;
+  }) => HTTPHeaders | Promise<HTTPHeaders>);
+  /**
+   * Maximum number of calls in a single batch request
+   * @default Infinity
+   */
+  maxItems?: number;
+}; //# sourceMappingURL=HTTPBatchLinkOptions.d.ts.map
+//#endregion
+//#region src/links/httpBatchLink.d.ts
+/**
+ * @see https://trpc.io/docs/client/links/httpBatchLink
+ */
+declare function httpBatchLink<TRouter extends AnyRouter>(opts: HTTPBatchLinkOptions<TRouter['_def']['_config']['$types']>): TRPCLink<TRouter>; //# sourceMappingURL=httpBatchLink.d.ts.map
+//#endregion
+//#endregion
+//#region node_modules/@trpc/client/dist/index.d.mts
+//#region src/internals/TRPCUntypedClient.d.ts
+interface TRPCRequestOptions {
+  /**
+   * Pass additional context to links
+   */
+  context?: OperationContext;
+  signal?: AbortSignal;
+}
+interface TRPCSubscriptionObserver<TValue, TError> {
+  onStarted: (opts: {
+    context: OperationContext | undefined;
+  }) => void;
+  onData: (value: inferAsyncIterableYield<TValue>) => void;
+  onError: (err: TError) => void;
+  onStopped: () => void;
+  onComplete: () => void;
+  onConnectionStateChange: (state: TRPCConnectionState<TError>) => void;
+}
+/** @internal */
+type CreateTRPCClientOptions<TRouter extends InferrableClientTypes> = {
+  links: TRPCLink<TRouter>[];
+  transformer?: TypeError<'The transformer property has moved to httpLink/httpBatchLink/wsLink'>;
+};
+declare class TRPCUntypedClient<TInferrable extends InferrableClientTypes> {
+  private readonly links;
+  readonly runtime: TRPCClientRuntime;
+  private requestId;
+  constructor(opts: CreateTRPCClientOptions<TInferrable>);
+  private $request;
+  private requestAsPromise;
+  query(path: string, input?: unknown, opts?: TRPCRequestOptions): Promise<unknown>;
+  mutation(path: string, input?: unknown, opts?: TRPCRequestOptions): Promise<unknown>;
+  subscription(path: string, input: unknown, opts: Partial<TRPCSubscriptionObserver<unknown, TRPCClientError<AnyRouter>>> & TRPCRequestOptions): Unsubscribable;
+} //# sourceMappingURL=TRPCUntypedClient.d.ts.map
+//#endregion
+//#region src/createTRPCUntypedClient.d.ts
+declare const untypedClientSymbol: unique symbol;
+/**
+ * @public
+ **/
+type TRPCClient<TRouter extends AnyRouter> = DecoratedProcedureRecord<{
+  transformer: TRouter['_def']['_config']['$types']['transformer'];
+  errorShape: TRouter['_def']['_config']['$types']['errorShape'];
+}, TRouter['_def']['record']> & {
+  [untypedClientSymbol]: TRPCUntypedClient<TRouter>;
+};
+/** @internal */
+type TRPCResolverDef = {
+  input: any;
+  output: any;
+  transformer: boolean;
+  errorShape: any;
+};
+type coerceAsyncGeneratorToIterable<T> = T extends AsyncGenerator<infer $T, infer $Return, infer $Next> ? AsyncIterable<$T, $Return, $Next> : T;
+/** @internal */
+type Resolver<TDef extends TRPCResolverDef> = (input: TDef['input'], opts?: TRPCProcedureOptions) => Promise<coerceAsyncGeneratorToIterable<TDef['output']>>;
+/** @internal */
+type SubscriptionResolver<TDef extends TRPCResolverDef> = (input: TDef['input'], opts: Partial<TRPCSubscriptionObserver<TDef['output'], TRPCClientError<TDef>>> & TRPCProcedureOptions) => Unsubscribable;
+type DecorateProcedure<TType extends ProcedureType, TDef extends TRPCResolverDef> = TType extends 'query' ? {
+  query: Resolver<TDef>;
+} : TType extends 'mutation' ? {
+  mutate: Resolver<TDef>;
+} : TType extends 'subscription' ? {
+  subscribe: SubscriptionResolver<TDef>;
+} : never;
+/**
+ * @internal
+ */
+type DecoratedProcedureRecord<TRoot extends InferrableClientTypes, TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value['_def']['type'], {
+  input: inferProcedureInput<$Value>;
+  output: inferTransformedProcedureOutput<inferClientTypes<TRoot>, $Value>;
+  errorShape: inferClientTypes<TRoot>['errorShape'];
+  transformer: inferClientTypes<TRoot>['transformer'];
+}> : $Value extends RouterRecord ? DecoratedProcedureRecord<TRoot, $Value> : never : never };
+/** @internal */
+//#endregion
+//#region src/client/index.d.ts
+type HttpBatchLinkOptions = Parameters<typeof httpBatchLink>[0];
+declare const DEFAULT_TRPC_URL = "https://rpc.dogeapi.io";
+type DogecoinCoreClientOptions = Omit<HttpBatchLinkOptions, "transformer" | "url"> & {
+  url?: HttpBatchLinkOptions["url"];
+};
+declare function createDogecoinCoreClient(options?: DogecoinCoreClientOptions): TRPCClient<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 DogecoinCoreClient = ReturnType<typeof createDogecoinCoreClient>;
+//#endregion
+export { type AppRouter, DEFAULT_TRPC_URL, DogecoinCoreClient, DogecoinCoreClientOptions, createDogecoinCoreClient };