// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.6.1
//   protoc               unknown
// source: cheqd/did/v2/query.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination.js";
import { DidDocWithMetadata, Metadata } from "./diddoc.js";
import { FeeParams } from "./fee.js";

/** QueryDidDocRequest is the request type for the Query/DidDoc method */
export interface QueryDidDocRequest {
  /**
   * DID unique identifier of the DID Document to fetch.
   * UUID-style DIDs as well as Indy-style DID are supported.
   *
   * Format: did:cheqd:<namespace>:<unique-identifier>
   *
   * Examples:
   * - did:cheqd:mainnet:c82f2b02-bdab-4dd7-b833-3e143745d612
   * - did:cheqd:testnet:wGHEXrZvJxR8vw5P3UWH1j
   */
  id: string;
}

/** QueryDidDocResponse is the response type for the Query/DidDoc method */
export interface QueryDidDocResponse {
  /**
   * Successful resolution of the DID Document returns the following:
   * - did_doc is the latest version of the DID Document
   * - metadata is is the DID Document metadata associated with the latest version of the DID Document
   */
  value: DidDocWithMetadata | undefined;
}

/** QueryDidDocVersionRequest is the request type for the Query/DidDocVersion method */
export interface QueryDidDocVersionRequest {
  /**
   * DID unique identifier of the DID Document to fetch.
   * UUID-style DIDs as well as Indy-style DID are supported.
   *
   * Format: did:cheqd:<namespace>:<unique-identifier>
   *
   * Examples:
   * - did:cheqd:mainnet:c82f2b02-bdab-4dd7-b833-3e143745d612
   * - did:cheqd:testnet:wGHEXrZvJxR8vw5P3UWH1j
   */
  id: string;
  /**
   * Unique version identifier of the DID Document to fetch.
   * Returns the specified version of the DID Document.
   *
   * Format: <uuid>
   *
   * Example: 93f2573c-eca9-4098-96cb-a1ec676a29ed
   */
  version: string;
}

/** QueryDidDocVersionResponse is the response type for the Query/DidDocVersion method */
export interface QueryDidDocVersionResponse {
  /**
   * Successful resolution of the DID Document returns the following:
   * - did_doc is the requested version of the DID Document
   * - metadata is DID Document metadata associated with the requested version of the DID Document
   */
  value: DidDocWithMetadata | undefined;
}

/** QueryAllDidDocVersionsMetadataRequest is the request type for the Query/AllDidDocVersionsMetadata method */
export interface QueryAllDidDocVersionsMetadataRequest {
  /**
   * DID unique identifier of the DID Document to fetch version metadata.
   * UUID-style DIDs as well as Indy-style DID are supported.
   *
   * Format: did:cheqd:<namespace>:<unique-identifier>
   *
   * Examples:
   * - did:cheqd:mainnet:c82f2b02-bdab-4dd7-b833-3e143745d612
   * - did:cheqd:testnet:wGHEXrZvJxR8vw5P3UWH1j
   */
  id: string;
  /** pagination defines an optional pagination for the request. */
  pagination: PageRequest | undefined;
}

/** QueryAllDidDocVersionsMetadataResponse is the response type for the Query/AllDidDocVersionsMetadata method */
export interface QueryAllDidDocVersionsMetadataResponse {
  /** versions is the list of all versions of the requested DID Document */
  versions: Metadata[];
  /** pagination defines the pagination in the response. */
  pagination: PageResponse | undefined;
}

/** QueryParamsRequest is the request type for the Query/Params RPC method. */
export interface QueryParamsRequest {
}

/** QueryParamsResponse is the response type for the Query/Params RPC method. */
export interface QueryParamsResponse {
  /** params defines the parameters of the module. */
  params: FeeParams | undefined;
}

function createBaseQueryDidDocRequest(): QueryDidDocRequest {
  return { id: "" };
}

export const QueryDidDocRequest: MessageFns<QueryDidDocRequest> = {
  encode(message: QueryDidDocRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryDidDocRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryDidDocRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryDidDocRequest {
    return { id: isSet(object.id) ? globalThis.String(object.id) : "" };
  },

  toJSON(message: QueryDidDocRequest): unknown {
    const obj: any = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryDidDocRequest>, I>>(base?: I): QueryDidDocRequest {
    return QueryDidDocRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryDidDocRequest>, I>>(object: I): QueryDidDocRequest {
    const message = createBaseQueryDidDocRequest();
    message.id = object.id ?? "";
    return message;
  },
};

function createBaseQueryDidDocResponse(): QueryDidDocResponse {
  return { value: undefined };
}

export const QueryDidDocResponse: MessageFns<QueryDidDocResponse> = {
  encode(message: QueryDidDocResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.value !== undefined) {
      DidDocWithMetadata.encode(message.value, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryDidDocResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryDidDocResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.value = DidDocWithMetadata.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryDidDocResponse {
    return { value: isSet(object.value) ? DidDocWithMetadata.fromJSON(object.value) : undefined };
  },

  toJSON(message: QueryDidDocResponse): unknown {
    const obj: any = {};
    if (message.value !== undefined) {
      obj.value = DidDocWithMetadata.toJSON(message.value);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryDidDocResponse>, I>>(base?: I): QueryDidDocResponse {
    return QueryDidDocResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryDidDocResponse>, I>>(object: I): QueryDidDocResponse {
    const message = createBaseQueryDidDocResponse();
    message.value = (object.value !== undefined && object.value !== null)
      ? DidDocWithMetadata.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseQueryDidDocVersionRequest(): QueryDidDocVersionRequest {
  return { id: "", version: "" };
}

export const QueryDidDocVersionRequest: MessageFns<QueryDidDocVersionRequest> = {
  encode(message: QueryDidDocVersionRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.version !== "") {
      writer.uint32(18).string(message.version);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryDidDocVersionRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryDidDocVersionRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.version = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryDidDocVersionRequest {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      version: isSet(object.version) ? globalThis.String(object.version) : "",
    };
  },

  toJSON(message: QueryDidDocVersionRequest): unknown {
    const obj: any = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.version !== "") {
      obj.version = message.version;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryDidDocVersionRequest>, I>>(base?: I): QueryDidDocVersionRequest {
    return QueryDidDocVersionRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryDidDocVersionRequest>, I>>(object: I): QueryDidDocVersionRequest {
    const message = createBaseQueryDidDocVersionRequest();
    message.id = object.id ?? "";
    message.version = object.version ?? "";
    return message;
  },
};

function createBaseQueryDidDocVersionResponse(): QueryDidDocVersionResponse {
  return { value: undefined };
}

export const QueryDidDocVersionResponse: MessageFns<QueryDidDocVersionResponse> = {
  encode(message: QueryDidDocVersionResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.value !== undefined) {
      DidDocWithMetadata.encode(message.value, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryDidDocVersionResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryDidDocVersionResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.value = DidDocWithMetadata.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryDidDocVersionResponse {
    return { value: isSet(object.value) ? DidDocWithMetadata.fromJSON(object.value) : undefined };
  },

  toJSON(message: QueryDidDocVersionResponse): unknown {
    const obj: any = {};
    if (message.value !== undefined) {
      obj.value = DidDocWithMetadata.toJSON(message.value);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryDidDocVersionResponse>, I>>(base?: I): QueryDidDocVersionResponse {
    return QueryDidDocVersionResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryDidDocVersionResponse>, I>>(object: I): QueryDidDocVersionResponse {
    const message = createBaseQueryDidDocVersionResponse();
    message.value = (object.value !== undefined && object.value !== null)
      ? DidDocWithMetadata.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseQueryAllDidDocVersionsMetadataRequest(): QueryAllDidDocVersionsMetadataRequest {
  return { id: "", pagination: undefined };
}

export const QueryAllDidDocVersionsMetadataRequest: MessageFns<QueryAllDidDocVersionsMetadataRequest> = {
  encode(message: QueryAllDidDocVersionsMetadataRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.pagination !== undefined) {
      PageRequest.encode(message.pagination, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllDidDocVersionsMetadataRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAllDidDocVersionsMetadataRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.pagination = PageRequest.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAllDidDocVersionsMetadataRequest {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      pagination: isSet(object.pagination) ? PageRequest.fromJSON(object.pagination) : undefined,
    };
  },

  toJSON(message: QueryAllDidDocVersionsMetadataRequest): unknown {
    const obj: any = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.pagination !== undefined) {
      obj.pagination = PageRequest.toJSON(message.pagination);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAllDidDocVersionsMetadataRequest>, I>>(
    base?: I,
  ): QueryAllDidDocVersionsMetadataRequest {
    return QueryAllDidDocVersionsMetadataRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAllDidDocVersionsMetadataRequest>, I>>(
    object: I,
  ): QueryAllDidDocVersionsMetadataRequest {
    const message = createBaseQueryAllDidDocVersionsMetadataRequest();
    message.id = object.id ?? "";
    message.pagination = (object.pagination !== undefined && object.pagination !== null)
      ? PageRequest.fromPartial(object.pagination)
      : undefined;
    return message;
  },
};

function createBaseQueryAllDidDocVersionsMetadataResponse(): QueryAllDidDocVersionsMetadataResponse {
  return { versions: [], pagination: undefined };
}

export const QueryAllDidDocVersionsMetadataResponse: MessageFns<QueryAllDidDocVersionsMetadataResponse> = {
  encode(message: QueryAllDidDocVersionsMetadataResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.versions) {
      Metadata.encode(v!, writer.uint32(10).fork()).join();
    }
    if (message.pagination !== undefined) {
      PageResponse.encode(message.pagination, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryAllDidDocVersionsMetadataResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryAllDidDocVersionsMetadataResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.versions.push(Metadata.decode(reader, reader.uint32()));
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.pagination = PageResponse.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryAllDidDocVersionsMetadataResponse {
    return {
      versions: globalThis.Array.isArray(object?.versions) ? object.versions.map((e: any) => Metadata.fromJSON(e)) : [],
      pagination: isSet(object.pagination) ? PageResponse.fromJSON(object.pagination) : undefined,
    };
  },

  toJSON(message: QueryAllDidDocVersionsMetadataResponse): unknown {
    const obj: any = {};
    if (message.versions?.length) {
      obj.versions = message.versions.map((e) => Metadata.toJSON(e));
    }
    if (message.pagination !== undefined) {
      obj.pagination = PageResponse.toJSON(message.pagination);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryAllDidDocVersionsMetadataResponse>, I>>(
    base?: I,
  ): QueryAllDidDocVersionsMetadataResponse {
    return QueryAllDidDocVersionsMetadataResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryAllDidDocVersionsMetadataResponse>, I>>(
    object: I,
  ): QueryAllDidDocVersionsMetadataResponse {
    const message = createBaseQueryAllDidDocVersionsMetadataResponse();
    message.versions = object.versions?.map((e) => Metadata.fromPartial(e)) || [];
    message.pagination = (object.pagination !== undefined && object.pagination !== null)
      ? PageResponse.fromPartial(object.pagination)
      : undefined;
    return message;
  },
};

function createBaseQueryParamsRequest(): QueryParamsRequest {
  return {};
}

export const QueryParamsRequest: MessageFns<QueryParamsRequest> = {
  encode(_: QueryParamsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryParamsRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(_: any): QueryParamsRequest {
    return {};
  },

  toJSON(_: QueryParamsRequest): unknown {
    const obj: any = {};
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryParamsRequest>, I>>(base?: I): QueryParamsRequest {
    return QueryParamsRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryParamsRequest>, I>>(_: I): QueryParamsRequest {
    const message = createBaseQueryParamsRequest();
    return message;
  },
};

function createBaseQueryParamsResponse(): QueryParamsResponse {
  return { params: undefined };
}

export const QueryParamsResponse: MessageFns<QueryParamsResponse> = {
  encode(message: QueryParamsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.params !== undefined) {
      FeeParams.encode(message.params, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseQueryParamsResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.params = FeeParams.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): QueryParamsResponse {
    return { params: isSet(object.params) ? FeeParams.fromJSON(object.params) : undefined };
  },

  toJSON(message: QueryParamsResponse): unknown {
    const obj: any = {};
    if (message.params !== undefined) {
      obj.params = FeeParams.toJSON(message.params);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<QueryParamsResponse>, I>>(base?: I): QueryParamsResponse {
    return QueryParamsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<QueryParamsResponse>, I>>(object: I): QueryParamsResponse {
    const message = createBaseQueryParamsResponse();
    message.params = (object.params !== undefined && object.params !== null)
      ? FeeParams.fromPartial(object.params)
      : undefined;
    return message;
  },
};

/** Query defines the gRPC querier service for the DID module */
export interface Query {
  /** Fetch latest version of a DID Document for a given DID */
  DidDoc(request: QueryDidDocRequest): Promise<QueryDidDocResponse>;
  /** Fetch specific version of a DID Document for a given DID */
  DidDocVersion(request: QueryDidDocVersionRequest): Promise<QueryDidDocVersionResponse>;
  /** Fetch list of all versions of DID Documents for a given DID */
  AllDidDocVersionsMetadata(
    request: QueryAllDidDocVersionsMetadataRequest,
  ): Promise<QueryAllDidDocVersionsMetadataResponse>;
  /** Params queries params of the did module. */
  Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
}

export const QueryServiceName = "cheqd.did.v2.Query";
export class QueryClientImpl implements Query {
  private readonly rpc: Rpc;
  private readonly service: string;
  constructor(rpc: Rpc, opts?: { service?: string }) {
    this.service = opts?.service || QueryServiceName;
    this.rpc = rpc;
    this.DidDoc = this.DidDoc.bind(this);
    this.DidDocVersion = this.DidDocVersion.bind(this);
    this.AllDidDocVersionsMetadata = this.AllDidDocVersionsMetadata.bind(this);
    this.Params = this.Params.bind(this);
  }
  DidDoc(request: QueryDidDocRequest): Promise<QueryDidDocResponse> {
    const data = QueryDidDocRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "DidDoc", data);
    return promise.then((data) => QueryDidDocResponse.decode(new BinaryReader(data)));
  }

  DidDocVersion(request: QueryDidDocVersionRequest): Promise<QueryDidDocVersionResponse> {
    const data = QueryDidDocVersionRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "DidDocVersion", data);
    return promise.then((data) => QueryDidDocVersionResponse.decode(new BinaryReader(data)));
  }

  AllDidDocVersionsMetadata(
    request: QueryAllDidDocVersionsMetadataRequest,
  ): Promise<QueryAllDidDocVersionsMetadataResponse> {
    const data = QueryAllDidDocVersionsMetadataRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "AllDidDocVersionsMetadata", data);
    return promise.then((data) => QueryAllDidDocVersionsMetadataResponse.decode(new BinaryReader(data)));
  }

  Params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
    const data = QueryParamsRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "Params", data);
    return promise.then((data) => QueryParamsResponse.decode(new BinaryReader(data)));
  }
}

interface Rpc {
  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}

type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;

type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

type KeysOfUnion<T> = T extends T ? keyof T : never;
type Exact<P, I extends P> = P extends Builtin ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}

interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}