@xpla/xplajs 1.7.0-beta.0

package/src/xpla/volunteer/v1beta1/query.d.ts

@@ -0,0 +1,60 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** QueryVolunteerValidatorsRequest */
+export interface QueryVolunteerValidatorsRequest {
+}
+export interface QueryVolunteerValidatorsRequestProtoMsg {
+    typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest";
+    value: Uint8Array;
+}
+/** QueryVolunteerValidatorsRequest */
+export interface QueryVolunteerValidatorsRequestAmino {
+}
+export interface QueryVolunteerValidatorsRequestAminoMsg {
+    type: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest";
+    value: QueryVolunteerValidatorsRequestAmino;
+}
+/** QueryVolunteerValidatorsResponse */
+export interface QueryVolunteerValidatorsResponse {
+    volunteerValidators: string[];
+}
+export interface QueryVolunteerValidatorsResponseProtoMsg {
+    typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse";
+    value: Uint8Array;
+}
+/** QueryVolunteerValidatorsResponse */
+export interface QueryVolunteerValidatorsResponseAmino {
+    volunteer_validators: string[];
+}
+export interface QueryVolunteerValidatorsResponseAminoMsg {
+    type: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse";
+    value: QueryVolunteerValidatorsResponseAmino;
+}
+export declare const QueryVolunteerValidatorsRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryVolunteerValidatorsRequest;
+    isAmino(o: any): o is QueryVolunteerValidatorsRequestAmino;
+    encode(_: QueryVolunteerValidatorsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryVolunteerValidatorsRequest;
+    fromPartial(_: DeepPartial<QueryVolunteerValidatorsRequest>): QueryVolunteerValidatorsRequest;
+    fromAmino(_: QueryVolunteerValidatorsRequestAmino): QueryVolunteerValidatorsRequest;
+    toAmino(_: QueryVolunteerValidatorsRequest): QueryVolunteerValidatorsRequestAmino;
+    fromAminoMsg(object: QueryVolunteerValidatorsRequestAminoMsg): QueryVolunteerValidatorsRequest;
+    fromProtoMsg(message: QueryVolunteerValidatorsRequestProtoMsg): QueryVolunteerValidatorsRequest;
+    toProto(message: QueryVolunteerValidatorsRequest): Uint8Array;
+    toProtoMsg(message: QueryVolunteerValidatorsRequest): QueryVolunteerValidatorsRequestProtoMsg;
+};
+export declare const QueryVolunteerValidatorsResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryVolunteerValidatorsResponse;
+    isAmino(o: any): o is QueryVolunteerValidatorsResponseAmino;
+    encode(message: QueryVolunteerValidatorsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryVolunteerValidatorsResponse;
+    fromPartial(object: DeepPartial<QueryVolunteerValidatorsResponse>): QueryVolunteerValidatorsResponse;
+    fromAmino(object: QueryVolunteerValidatorsResponseAmino): QueryVolunteerValidatorsResponse;
+    toAmino(message: QueryVolunteerValidatorsResponse): QueryVolunteerValidatorsResponseAmino;
+    fromAminoMsg(object: QueryVolunteerValidatorsResponseAminoMsg): QueryVolunteerValidatorsResponse;
+    fromProtoMsg(message: QueryVolunteerValidatorsResponseProtoMsg): QueryVolunteerValidatorsResponse;
+    toProto(message: QueryVolunteerValidatorsResponse): Uint8Array;
+    toProtoMsg(message: QueryVolunteerValidatorsResponse): QueryVolunteerValidatorsResponseProtoMsg;
+};

package/src/xpla/volunteer/v1beta1/query.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryVolunteerValidatorsResponse = exports.QueryVolunteerValidatorsRequest = void 0;
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseQueryVolunteerValidatorsRequest() {
+    return {};
+}
+exports.QueryVolunteerValidatorsRequest = {
+    typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryVolunteerValidatorsRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryVolunteerValidatorsRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryVolunteerValidatorsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryVolunteerValidatorsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryVolunteerValidatorsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryVolunteerValidatorsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryVolunteerValidatorsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryVolunteerValidatorsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest",
+            value: exports.QueryVolunteerValidatorsRequest.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryVolunteerValidatorsRequest.typeUrl, exports.QueryVolunteerValidatorsRequest);
+function createBaseQueryVolunteerValidatorsResponse() {
+    return {
+        volunteerValidators: []
+    };
+}
+exports.QueryVolunteerValidatorsResponse = {
+    typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryVolunteerValidatorsResponse.typeUrl || Array.isArray(o.volunteerValidators) && (!o.volunteerValidators.length || typeof o.volunteerValidators[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryVolunteerValidatorsResponse.typeUrl || Array.isArray(o.volunteer_validators) && (!o.volunteer_validators.length || typeof o.volunteer_validators[0] === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.volunteerValidators) {
+            writer.uint32(10).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryVolunteerValidatorsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.volunteerValidators.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryVolunteerValidatorsResponse();
+        message.volunteerValidators = object.volunteerValidators?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryVolunteerValidatorsResponse();
+        message.volunteerValidators = object.volunteer_validators?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.volunteerValidators) {
+            obj.volunteer_validators = message.volunteerValidators.map(e => e);
+        }
+        else {
+            obj.volunteer_validators = message.volunteerValidators;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryVolunteerValidatorsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryVolunteerValidatorsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryVolunteerValidatorsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse",
+            value: exports.QueryVolunteerValidatorsResponse.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryVolunteerValidatorsResponse.typeUrl, exports.QueryVolunteerValidatorsResponse);

package/src/xpla/volunteer/v1beta1/query.lcd.ts

@@ -0,0 +1,17 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryVolunteerValidatorsRequest, QueryVolunteerValidatorsResponse } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* VolunteerValidators */
+  volunteerValidators = async (_params: QueryVolunteerValidatorsRequest = {}): Promise<QueryVolunteerValidatorsResponse> => {
+    const endpoint = `xpla/volunteer/v1beta1/validators`;
+    return await this.req.get<QueryVolunteerValidatorsResponse>(endpoint);
+  };
+}

package/src/xpla/volunteer/v1beta1/query.rpc.Query.ts

@@ -0,0 +1,30 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryVolunteerValidatorsRequest, QueryVolunteerValidatorsResponse } from "./query";
+/** Query defines the gRPC querier service for volunteer module. */
+export interface Query {
+  /** VolunteerValidators */
+  volunteerValidators(request?: QueryVolunteerValidatorsRequest): Promise<QueryVolunteerValidatorsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* VolunteerValidators */
+  volunteerValidators = async (request: QueryVolunteerValidatorsRequest = {}): Promise<QueryVolunteerValidatorsResponse> => {
+    const data = QueryVolunteerValidatorsRequest.encode(request).finish();
+    const promise = this.rpc.request("xpla.volunteer.v1beta1.Query", "VolunteerValidators", data);
+    return promise.then(data => QueryVolunteerValidatorsResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    volunteerValidators(request?: QueryVolunteerValidatorsRequest): Promise<QueryVolunteerValidatorsResponse> {
+      return queryService.volunteerValidators(request);
+    }
+  };
+};

package/src/xpla/volunteer/v1beta1/query.rpc.func.d.ts

@@ -0,0 +1,3 @@
+import { RpcResolver } from "../../../helper-func-types";
+import { QueryVolunteerValidatorsRequest, QueryVolunteerValidatorsResponse } from "./query";
+export declare const createGetVolunteerValidators: (clientResolver?: RpcResolver) => (request: QueryVolunteerValidatorsRequest) => Promise<QueryVolunteerValidatorsResponse>;

package/src/xpla/volunteer/v1beta1/query.rpc.func.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetVolunteerValidators = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const query_1 = require("./query");
+const createGetVolunteerValidators = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryVolunteerValidatorsRequest.encode,
+    decode: query_1.QueryVolunteerValidatorsResponse.decode,
+    service: "xpla.volunteer.v1beta1.Query",
+    method: "VolunteerValidators",
+    clientResolver
+});
+exports.createGetVolunteerValidators = createGetVolunteerValidators;

package/src/xpla/volunteer/v1beta1/query.rpc.func.ts

@@ -0,0 +1,9 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { QueryVolunteerValidatorsRequest, QueryVolunteerValidatorsResponse } from "./query";
+export const createGetVolunteerValidators = (clientResolver?: RpcResolver) => buildQuery<QueryVolunteerValidatorsRequest, QueryVolunteerValidatorsResponse>({
+  encode: QueryVolunteerValidatorsRequest.encode,
+  decode: QueryVolunteerValidatorsResponse.decode,
+  service: "xpla.volunteer.v1beta1.Query",
+  method: "VolunteerValidators",
+  clientResolver
+});

package/src/xpla/volunteer/v1beta1/query.ts

@@ -0,0 +1,160 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** QueryVolunteerValidatorsRequest */
+export interface QueryVolunteerValidatorsRequest {}
+export interface QueryVolunteerValidatorsRequestProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest";
+  value: Uint8Array;
+}
+/** QueryVolunteerValidatorsRequest */
+export interface QueryVolunteerValidatorsRequestAmino {}
+export interface QueryVolunteerValidatorsRequestAminoMsg {
+  type: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest";
+  value: QueryVolunteerValidatorsRequestAmino;
+}
+/** QueryVolunteerValidatorsResponse */
+export interface QueryVolunteerValidatorsResponse {
+  volunteerValidators: string[];
+}
+export interface QueryVolunteerValidatorsResponseProtoMsg {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse";
+  value: Uint8Array;
+}
+/** QueryVolunteerValidatorsResponse */
+export interface QueryVolunteerValidatorsResponseAmino {
+  volunteer_validators: string[];
+}
+export interface QueryVolunteerValidatorsResponseAminoMsg {
+  type: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse";
+  value: QueryVolunteerValidatorsResponseAmino;
+}
+function createBaseQueryVolunteerValidatorsRequest(): QueryVolunteerValidatorsRequest {
+  return {};
+}
+export const QueryVolunteerValidatorsRequest = {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest",
+  is(o: any): o is QueryVolunteerValidatorsRequest {
+    return o && o.$typeUrl === QueryVolunteerValidatorsRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryVolunteerValidatorsRequestAmino {
+    return o && o.$typeUrl === QueryVolunteerValidatorsRequest.typeUrl;
+  },
+  encode(_: QueryVolunteerValidatorsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryVolunteerValidatorsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryVolunteerValidatorsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<QueryVolunteerValidatorsRequest>): QueryVolunteerValidatorsRequest {
+    const message = createBaseQueryVolunteerValidatorsRequest();
+    return message;
+  },
+  fromAmino(_: QueryVolunteerValidatorsRequestAmino): QueryVolunteerValidatorsRequest {
+    const message = createBaseQueryVolunteerValidatorsRequest();
+    return message;
+  },
+  toAmino(_: QueryVolunteerValidatorsRequest): QueryVolunteerValidatorsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryVolunteerValidatorsRequestAminoMsg): QueryVolunteerValidatorsRequest {
+    return QueryVolunteerValidatorsRequest.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryVolunteerValidatorsRequestProtoMsg): QueryVolunteerValidatorsRequest {
+    return QueryVolunteerValidatorsRequest.decode(message.value);
+  },
+  toProto(message: QueryVolunteerValidatorsRequest): Uint8Array {
+    return QueryVolunteerValidatorsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryVolunteerValidatorsRequest): QueryVolunteerValidatorsRequestProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsRequest",
+      value: QueryVolunteerValidatorsRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryVolunteerValidatorsRequest.typeUrl, QueryVolunteerValidatorsRequest);
+function createBaseQueryVolunteerValidatorsResponse(): QueryVolunteerValidatorsResponse {
+  return {
+    volunteerValidators: []
+  };
+}
+export const QueryVolunteerValidatorsResponse = {
+  typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse",
+  is(o: any): o is QueryVolunteerValidatorsResponse {
+    return o && (o.$typeUrl === QueryVolunteerValidatorsResponse.typeUrl || Array.isArray(o.volunteerValidators) && (!o.volunteerValidators.length || typeof o.volunteerValidators[0] === "string"));
+  },
+  isAmino(o: any): o is QueryVolunteerValidatorsResponseAmino {
+    return o && (o.$typeUrl === QueryVolunteerValidatorsResponse.typeUrl || Array.isArray(o.volunteer_validators) && (!o.volunteer_validators.length || typeof o.volunteer_validators[0] === "string"));
+  },
+  encode(message: QueryVolunteerValidatorsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.volunteerValidators) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryVolunteerValidatorsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryVolunteerValidatorsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.volunteerValidators.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<QueryVolunteerValidatorsResponse>): QueryVolunteerValidatorsResponse {
+    const message = createBaseQueryVolunteerValidatorsResponse();
+    message.volunteerValidators = object.volunteerValidators?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: QueryVolunteerValidatorsResponseAmino): QueryVolunteerValidatorsResponse {
+    const message = createBaseQueryVolunteerValidatorsResponse();
+    message.volunteerValidators = object.volunteer_validators?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: QueryVolunteerValidatorsResponse): QueryVolunteerValidatorsResponseAmino {
+    const obj: any = {};
+    if (message.volunteerValidators) {
+      obj.volunteer_validators = message.volunteerValidators.map(e => e);
+    } else {
+      obj.volunteer_validators = message.volunteerValidators;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: QueryVolunteerValidatorsResponseAminoMsg): QueryVolunteerValidatorsResponse {
+    return QueryVolunteerValidatorsResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryVolunteerValidatorsResponseProtoMsg): QueryVolunteerValidatorsResponse {
+    return QueryVolunteerValidatorsResponse.decode(message.value);
+  },
+  toProto(message: QueryVolunteerValidatorsResponse): Uint8Array {
+    return QueryVolunteerValidatorsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryVolunteerValidatorsResponse): QueryVolunteerValidatorsResponseProtoMsg {
+    return {
+      typeUrl: "/xpla.volunteer.v1beta1.QueryVolunteerValidatorsResponse",
+      value: QueryVolunteerValidatorsResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryVolunteerValidatorsResponse.typeUrl, QueryVolunteerValidatorsResponse);

package/src/xpla/volunteer/v1beta1/tx.amino.ts

@@ -0,0 +1,13 @@
+import { MsgRegisterVolunteerValidator, MsgUnregisterVolunteerValidator } from "./tx";
+export const AminoConverter = {
+  "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator": {
+    aminoType: "xpladev/MsgRegisterVolunteerValidator",
+    toAmino: MsgRegisterVolunteerValidator.toAmino,
+    fromAmino: MsgRegisterVolunteerValidator.fromAmino
+  },
+  "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator": {
+    aminoType: "xpladev/MsgUnregisterVolunteerValidator",
+    toAmino: MsgUnregisterVolunteerValidator.toAmino,
+    fromAmino: MsgUnregisterVolunteerValidator.fromAmino
+  }
+};

package/src/xpla/volunteer/v1beta1/tx.d.ts

@@ -0,0 +1,168 @@
+import { Description, DescriptionAmino } from "../../../cosmos/staking/v1beta1/staking";
+import { Any, AnyProtoMsg, AnyAmino } from "../../../google/protobuf/any";
+import { Coin, CoinAmino } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * MsgRegisterVolunteerValidator defines a message to register a new volunteer
+ * validator.
+ */
+export interface MsgRegisterVolunteerValidator {
+    /** authority is the address of the governance account. */
+    authority: string;
+    validatorDescription: Description;
+    delegatorAddress: string;
+    validatorAddress: string;
+    pubkey?: Any | undefined;
+    amount: Coin;
+}
+export interface MsgRegisterVolunteerValidatorProtoMsg {
+    typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidator";
+    value: Uint8Array;
+}
+export type MsgRegisterVolunteerValidatorEncoded = Omit<MsgRegisterVolunteerValidator, "pubkey"> & {
+    pubkey?: AnyProtoMsg | undefined;
+};
+/**
+ * MsgRegisterVolunteerValidator defines a message to register a new volunteer
+ * validator.
+ */
+export interface MsgRegisterVolunteerValidatorAmino {
+    /** authority is the address of the governance account. */
+    authority: string;
+    validator_description: DescriptionAmino;
+    delegator_address: string;
+    validator_address: string;
+    pubkey?: AnyAmino;
+    amount: CoinAmino;
+}
+export interface MsgRegisterVolunteerValidatorAminoMsg {
+    type: "xpladev/MsgRegisterVolunteerValidator";
+    value: MsgRegisterVolunteerValidatorAmino;
+}
+/**
+ * MsgRegisterVolunteerValidatorResponse defines the RegisterVolunteerValidator
+ * response.
+ */
+export interface MsgRegisterVolunteerValidatorResponse {
+}
+export interface MsgRegisterVolunteerValidatorResponseProtoMsg {
+    typeUrl: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidatorResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgRegisterVolunteerValidatorResponse defines the RegisterVolunteerValidator
+ * response.
+ */
+export interface MsgRegisterVolunteerValidatorResponseAmino {
+}
+export interface MsgRegisterVolunteerValidatorResponseAminoMsg {
+    type: "/xpla.volunteer.v1beta1.MsgRegisterVolunteerValidatorResponse";
+    value: MsgRegisterVolunteerValidatorResponseAmino;
+}
+/**
+ * MsgUnregisterVolunteerValidator defines a message to unregister a volunteer
+ * validator.
+ */
+export interface MsgUnregisterVolunteerValidator {
+    /** authority is the address of the governance account. */
+    authority: string;
+    validatorAddress: string;
+}
+export interface MsgUnregisterVolunteerValidatorProtoMsg {
+    typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidator";
+    value: Uint8Array;
+}
+/**
+ * MsgUnregisterVolunteerValidator defines a message to unregister a volunteer
+ * validator.
+ */
+export interface MsgUnregisterVolunteerValidatorAmino {
+    /** authority is the address of the governance account. */
+    authority: string;
+    validator_address: string;
+}
+export interface MsgUnregisterVolunteerValidatorAminoMsg {
+    type: "xpladev/MsgUnregisterVolunteerValidator";
+    value: MsgUnregisterVolunteerValidatorAmino;
+}
+/**
+ * MsgUnregisterVolunteerValidatorResponse defines the
+ * UnregisterVolunteerValidator response.
+ */
+export interface MsgUnregisterVolunteerValidatorResponse {
+}
+export interface MsgUnregisterVolunteerValidatorResponseProtoMsg {
+    typeUrl: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidatorResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgUnregisterVolunteerValidatorResponse defines the
+ * UnregisterVolunteerValidator response.
+ */
+export interface MsgUnregisterVolunteerValidatorResponseAmino {
+}
+export interface MsgUnregisterVolunteerValidatorResponseAminoMsg {
+    type: "/xpla.volunteer.v1beta1.MsgUnregisterVolunteerValidatorResponse";
+    value: MsgUnregisterVolunteerValidatorResponseAmino;
+}
+export declare const MsgRegisterVolunteerValidator: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgRegisterVolunteerValidator;
+    isAmino(o: any): o is MsgRegisterVolunteerValidatorAmino;
+    encode(message: MsgRegisterVolunteerValidator, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgRegisterVolunteerValidator;
+    fromPartial(object: DeepPartial<MsgRegisterVolunteerValidator>): MsgRegisterVolunteerValidator;
+    fromAmino(object: MsgRegisterVolunteerValidatorAmino): MsgRegisterVolunteerValidator;
+    toAmino(message: MsgRegisterVolunteerValidator): MsgRegisterVolunteerValidatorAmino;
+    fromAminoMsg(object: MsgRegisterVolunteerValidatorAminoMsg): MsgRegisterVolunteerValidator;
+    toAminoMsg(message: MsgRegisterVolunteerValidator): MsgRegisterVolunteerValidatorAminoMsg;
+    fromProtoMsg(message: MsgRegisterVolunteerValidatorProtoMsg): MsgRegisterVolunteerValidator;
+    toProto(message: MsgRegisterVolunteerValidator): Uint8Array;
+    toProtoMsg(message: MsgRegisterVolunteerValidator): MsgRegisterVolunteerValidatorProtoMsg;
+};
+export declare const MsgRegisterVolunteerValidatorResponse: {
+    typeUrl: string;
+    is(o: any): o is MsgRegisterVolunteerValidatorResponse;
+    isAmino(o: any): o is MsgRegisterVolunteerValidatorResponseAmino;
+    encode(_: MsgRegisterVolunteerValidatorResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgRegisterVolunteerValidatorResponse;
+    fromPartial(_: DeepPartial<MsgRegisterVolunteerValidatorResponse>): MsgRegisterVolunteerValidatorResponse;
+    fromAmino(_: MsgRegisterVolunteerValidatorResponseAmino): MsgRegisterVolunteerValidatorResponse;
+    toAmino(_: MsgRegisterVolunteerValidatorResponse): MsgRegisterVolunteerValidatorResponseAmino;
+    fromAminoMsg(object: MsgRegisterVolunteerValidatorResponseAminoMsg): MsgRegisterVolunteerValidatorResponse;
+    fromProtoMsg(message: MsgRegisterVolunteerValidatorResponseProtoMsg): MsgRegisterVolunteerValidatorResponse;
+    toProto(message: MsgRegisterVolunteerValidatorResponse): Uint8Array;
+    toProtoMsg(message: MsgRegisterVolunteerValidatorResponse): MsgRegisterVolunteerValidatorResponseProtoMsg;
+};
+export declare const MsgUnregisterVolunteerValidator: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgUnregisterVolunteerValidator;
+    isAmino(o: any): o is MsgUnregisterVolunteerValidatorAmino;
+    encode(message: MsgUnregisterVolunteerValidator, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUnregisterVolunteerValidator;
+    fromPartial(object: DeepPartial<MsgUnregisterVolunteerValidator>): MsgUnregisterVolunteerValidator;
+    fromAmino(object: MsgUnregisterVolunteerValidatorAmino): MsgUnregisterVolunteerValidator;
+    toAmino(message: MsgUnregisterVolunteerValidator): MsgUnregisterVolunteerValidatorAmino;
+    fromAminoMsg(object: MsgUnregisterVolunteerValidatorAminoMsg): MsgUnregisterVolunteerValidator;
+    toAminoMsg(message: MsgUnregisterVolunteerValidator): MsgUnregisterVolunteerValidatorAminoMsg;
+    fromProtoMsg(message: MsgUnregisterVolunteerValidatorProtoMsg): MsgUnregisterVolunteerValidator;
+    toProto(message: MsgUnregisterVolunteerValidator): Uint8Array;
+    toProtoMsg(message: MsgUnregisterVolunteerValidator): MsgUnregisterVolunteerValidatorProtoMsg;
+};
+export declare const MsgUnregisterVolunteerValidatorResponse: {
+    typeUrl: string;
+    is(o: any): o is MsgUnregisterVolunteerValidatorResponse;
+    isAmino(o: any): o is MsgUnregisterVolunteerValidatorResponseAmino;
+    encode(_: MsgUnregisterVolunteerValidatorResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUnregisterVolunteerValidatorResponse;
+    fromPartial(_: DeepPartial<MsgUnregisterVolunteerValidatorResponse>): MsgUnregisterVolunteerValidatorResponse;
+    fromAmino(_: MsgUnregisterVolunteerValidatorResponseAmino): MsgUnregisterVolunteerValidatorResponse;
+    toAmino(_: MsgUnregisterVolunteerValidatorResponse): MsgUnregisterVolunteerValidatorResponseAmino;
+    fromAminoMsg(object: MsgUnregisterVolunteerValidatorResponseAminoMsg): MsgUnregisterVolunteerValidatorResponse;
+    fromProtoMsg(message: MsgUnregisterVolunteerValidatorResponseProtoMsg): MsgUnregisterVolunteerValidatorResponse;
+    toProto(message: MsgUnregisterVolunteerValidatorResponse): Uint8Array;
+    toProtoMsg(message: MsgUnregisterVolunteerValidatorResponse): MsgUnregisterVolunteerValidatorResponseProtoMsg;
+};