@sparkdreamnft/sparkdreamjs 0.0.17 → 0.0.18

package/esm/sparkdream/service/v1/query.js

@@ -0,0 +1,1582 @@
+//@ts-nocheck
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Params } from "./params";
+import { Operator } from "./operator";
+import { ServiceTypeConfig } from "./service_type_config";
+import { Report } from "./report";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * QueryParamsRequest is request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryParamsRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        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) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * QueryParamsResponse is response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryParamsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        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:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorRequest() {
+    return {
+        address: "",
+        serviceType: ""
+    };
+}
+/**
+ * QueryOperatorRequest defines the QueryOperatorRequest message.
+ * @name QueryOperatorRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorRequest
+ */
+export const QueryOperatorRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorRequest();
+        message.address = object.address ?? "";
+        message.serviceType = object.serviceType ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorRequest();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorRequest",
+            value: QueryOperatorRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorResponse() {
+    return {
+        operator: Operator.fromPartial({})
+    };
+}
+/**
+ * QueryOperatorResponse defines the QueryOperatorResponse message.
+ * @name QueryOperatorResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorResponse
+ */
+export const QueryOperatorResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operator !== undefined) {
+            Operator.encode(message.operator, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operator = Operator.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorResponse();
+        message.operator = object.operator !== undefined && object.operator !== null ? Operator.fromPartial(object.operator) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorResponse();
+        if (object.operator !== undefined && object.operator !== null) {
+            message.operator = Operator.fromAmino(object.operator);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator = message.operator ? Operator.toAmino(message.operator) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorResponse",
+            value: QueryOperatorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryServiceTypeRequest() {
+    return {
+        serviceType: ""
+    };
+}
+/**
+ * QueryServiceTypeRequest defines the QueryServiceTypeRequest message.
+ * @name QueryServiceTypeRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryServiceTypeRequest
+ */
+export const QueryServiceTypeRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryServiceTypeRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.serviceType !== "") {
+            writer.uint32(10).string(message.serviceType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryServiceTypeRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.serviceType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryServiceTypeRequest();
+        message.serviceType = object.serviceType ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryServiceTypeRequest();
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryServiceTypeRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryServiceTypeRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryServiceTypeRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryServiceTypeRequest",
+            value: QueryServiceTypeRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryServiceTypeResponse() {
+    return {
+        config: ServiceTypeConfig.fromPartial({})
+    };
+}
+/**
+ * QueryServiceTypeResponse defines the QueryServiceTypeResponse message.
+ * @name QueryServiceTypeResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryServiceTypeResponse
+ */
+export const QueryServiceTypeResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryServiceTypeResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.config !== undefined) {
+            ServiceTypeConfig.encode(message.config, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryServiceTypeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.config = ServiceTypeConfig.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryServiceTypeResponse();
+        message.config = object.config !== undefined && object.config !== null ? ServiceTypeConfig.fromPartial(object.config) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryServiceTypeResponse();
+        if (object.config !== undefined && object.config !== null) {
+            message.config = ServiceTypeConfig.fromAmino(object.config);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.config = message.config ? ServiceTypeConfig.toAmino(message.config) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryServiceTypeResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryServiceTypeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryServiceTypeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryServiceTypeResponse",
+            value: QueryServiceTypeResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryServiceTypesRequest() {
+    return {
+        enabledOnly: false,
+        pagination: undefined
+    };
+}
+/**
+ * QueryServiceTypesRequest defines the QueryServiceTypesRequest message.
+ * @name QueryServiceTypesRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryServiceTypesRequest
+ */
+export const QueryServiceTypesRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryServiceTypesRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.enabledOnly === true) {
+            writer.uint32(8).bool(message.enabledOnly);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryServiceTypesRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.enabledOnly = reader.bool();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryServiceTypesRequest();
+        message.enabledOnly = object.enabledOnly ?? false;
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryServiceTypesRequest();
+        if (object.enabled_only !== undefined && object.enabled_only !== null) {
+            message.enabledOnly = object.enabled_only;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.enabled_only = message.enabledOnly === false ? undefined : message.enabledOnly;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryServiceTypesRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryServiceTypesRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryServiceTypesRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryServiceTypesRequest",
+            value: QueryServiceTypesRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryServiceTypesResponse() {
+    return {
+        configs: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryServiceTypesResponse defines the QueryServiceTypesResponse message.
+ * @name QueryServiceTypesResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryServiceTypesResponse
+ */
+export const QueryServiceTypesResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryServiceTypesResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.configs) {
+            ServiceTypeConfig.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryServiceTypesResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.configs.push(ServiceTypeConfig.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryServiceTypesResponse();
+        message.configs = object.configs?.map(e => ServiceTypeConfig.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryServiceTypesResponse();
+        message.configs = object.configs?.map(e => ServiceTypeConfig.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.configs) {
+            obj.configs = message.configs.map(e => e ? ServiceTypeConfig.toAmino(e) : undefined);
+        }
+        else {
+            obj.configs = message.configs;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryServiceTypesResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryServiceTypesResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryServiceTypesResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryServiceTypesResponse",
+            value: QueryServiceTypesResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorsRequest() {
+    return {
+        statusFilter: "",
+        pagination: undefined
+    };
+}
+/**
+ * QueryOperatorsRequest defines the QueryOperatorsRequest message.
+ * @name QueryOperatorsRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorsRequest
+ */
+export const QueryOperatorsRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.statusFilter !== "") {
+            writer.uint32(10).string(message.statusFilter);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.statusFilter = reader.string();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorsRequest();
+        message.statusFilter = object.statusFilter ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorsRequest();
+        if (object.status_filter !== undefined && object.status_filter !== null) {
+            message.statusFilter = object.status_filter;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.status_filter = message.statusFilter === "" ? undefined : message.statusFilter;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorsRequest",
+            value: QueryOperatorsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorsResponse() {
+    return {
+        operators: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryOperatorsResponse defines the QueryOperatorsResponse message.
+ * @name QueryOperatorsResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorsResponse
+ */
+export const QueryOperatorsResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.operators) {
+            Operator.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operators.push(Operator.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorsResponse();
+        message.operators = object.operators?.map(e => Operator.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorsResponse();
+        message.operators = object.operators?.map(e => Operator.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.operators) {
+            obj.operators = message.operators.map(e => e ? Operator.toAmino(e) : undefined);
+        }
+        else {
+            obj.operators = message.operators;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorsResponse",
+            value: QueryOperatorsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorsByControllerRequest() {
+    return {
+        controller: "",
+        statusFilter: "",
+        pagination: undefined
+    };
+}
+/**
+ * QueryOperatorsByControllerRequest defines the QueryOperatorsByControllerRequest message.
+ * @name QueryOperatorsByControllerRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorsByControllerRequest
+ */
+export const QueryOperatorsByControllerRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorsByControllerRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.controller !== "") {
+            writer.uint32(10).string(message.controller);
+        }
+        if (message.statusFilter !== "") {
+            writer.uint32(18).string(message.statusFilter);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorsByControllerRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.controller = reader.string();
+                    break;
+                case 2:
+                    message.statusFilter = reader.string();
+                    break;
+                case 3:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorsByControllerRequest();
+        message.controller = object.controller ?? "";
+        message.statusFilter = object.statusFilter ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorsByControllerRequest();
+        if (object.controller !== undefined && object.controller !== null) {
+            message.controller = object.controller;
+        }
+        if (object.status_filter !== undefined && object.status_filter !== null) {
+            message.statusFilter = object.status_filter;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.controller = message.controller === "" ? undefined : message.controller;
+        obj.status_filter = message.statusFilter === "" ? undefined : message.statusFilter;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorsByControllerRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorsByControllerRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorsByControllerRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorsByControllerRequest",
+            value: QueryOperatorsByControllerRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorsByControllerResponse() {
+    return {
+        operators: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryOperatorsByControllerResponse defines the QueryOperatorsByControllerResponse message.
+ * @name QueryOperatorsByControllerResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorsByControllerResponse
+ */
+export const QueryOperatorsByControllerResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorsByControllerResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.operators) {
+            Operator.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorsByControllerResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operators.push(Operator.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorsByControllerResponse();
+        message.operators = object.operators?.map(e => Operator.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorsByControllerResponse();
+        message.operators = object.operators?.map(e => Operator.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.operators) {
+            obj.operators = message.operators.map(e => e ? Operator.toAmino(e) : undefined);
+        }
+        else {
+            obj.operators = message.operators;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorsByControllerResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorsByControllerResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorsByControllerResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorsByControllerResponse",
+            value: QueryOperatorsByControllerResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorsByServiceTypeRequest() {
+    return {
+        serviceType: "",
+        statusFilter: "",
+        pagination: undefined
+    };
+}
+/**
+ * QueryOperatorsByServiceTypeRequest defines the QueryOperatorsByServiceTypeRequest message.
+ * @name QueryOperatorsByServiceTypeRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorsByServiceTypeRequest
+ */
+export const QueryOperatorsByServiceTypeRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorsByServiceTypeRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.serviceType !== "") {
+            writer.uint32(10).string(message.serviceType);
+        }
+        if (message.statusFilter !== "") {
+            writer.uint32(18).string(message.statusFilter);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorsByServiceTypeRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.serviceType = reader.string();
+                    break;
+                case 2:
+                    message.statusFilter = reader.string();
+                    break;
+                case 3:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorsByServiceTypeRequest();
+        message.serviceType = object.serviceType ?? "";
+        message.statusFilter = object.statusFilter ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorsByServiceTypeRequest();
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.status_filter !== undefined && object.status_filter !== null) {
+            message.statusFilter = object.status_filter;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.status_filter = message.statusFilter === "" ? undefined : message.statusFilter;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorsByServiceTypeRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorsByServiceTypeRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorsByServiceTypeRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorsByServiceTypeRequest",
+            value: QueryOperatorsByServiceTypeRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorsByServiceTypeResponse() {
+    return {
+        operators: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryOperatorsByServiceTypeResponse defines the QueryOperatorsByServiceTypeResponse message.
+ * @name QueryOperatorsByServiceTypeResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorsByServiceTypeResponse
+ */
+export const QueryOperatorsByServiceTypeResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorsByServiceTypeResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.operators) {
+            Operator.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorsByServiceTypeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operators.push(Operator.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorsByServiceTypeResponse();
+        message.operators = object.operators?.map(e => Operator.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorsByServiceTypeResponse();
+        message.operators = object.operators?.map(e => Operator.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.operators) {
+            obj.operators = message.operators.map(e => e ? Operator.toAmino(e) : undefined);
+        }
+        else {
+            obj.operators = message.operators;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorsByServiceTypeResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorsByServiceTypeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorsByServiceTypeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorsByServiceTypeResponse",
+            value: QueryOperatorsByServiceTypeResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryReportRequest() {
+    return {
+        reportId: BigInt(0)
+    };
+}
+/**
+ * QueryReportRequest defines the QueryReportRequest message.
+ * @name QueryReportRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryReportRequest
+ */
+export const QueryReportRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryReportRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.reportId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.reportId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryReportRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reportId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryReportRequest();
+        message.reportId = object.reportId !== undefined && object.reportId !== null ? BigInt(object.reportId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryReportRequest();
+        if (object.report_id !== undefined && object.report_id !== null) {
+            message.reportId = BigInt(object.report_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.report_id = message.reportId !== BigInt(0) ? message.reportId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryReportRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryReportRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryReportRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryReportRequest",
+            value: QueryReportRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryReportResponse() {
+    return {
+        report: Report.fromPartial({})
+    };
+}
+/**
+ * QueryReportResponse defines the QueryReportResponse message.
+ * @name QueryReportResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryReportResponse
+ */
+export const QueryReportResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryReportResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.report !== undefined) {
+            Report.encode(message.report, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryReportResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.report = Report.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryReportResponse();
+        message.report = object.report !== undefined && object.report !== null ? Report.fromPartial(object.report) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryReportResponse();
+        if (object.report !== undefined && object.report !== null) {
+            message.report = Report.fromAmino(object.report);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.report = message.report ? Report.toAmino(message.report) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryReportResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryReportResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryReportResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryReportResponse",
+            value: QueryReportResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryReportsByOperatorRequest() {
+    return {
+        operatorAddress: "",
+        serviceType: "",
+        statusFilter: "",
+        pagination: undefined
+    };
+}
+/**
+ * QueryReportsByOperatorRequest defines the QueryReportsByOperatorRequest message.
+ * @name QueryReportsByOperatorRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryReportsByOperatorRequest
+ */
+export const QueryReportsByOperatorRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryReportsByOperatorRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.operatorAddress !== "") {
+            writer.uint32(10).string(message.operatorAddress);
+        }
+        if (message.serviceType !== "") {
+            writer.uint32(18).string(message.serviceType);
+        }
+        if (message.statusFilter !== "") {
+            writer.uint32(26).string(message.statusFilter);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryReportsByOperatorRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.operatorAddress = reader.string();
+                    break;
+                case 2:
+                    message.serviceType = reader.string();
+                    break;
+                case 3:
+                    message.statusFilter = reader.string();
+                    break;
+                case 4:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryReportsByOperatorRequest();
+        message.operatorAddress = object.operatorAddress ?? "";
+        message.serviceType = object.serviceType ?? "";
+        message.statusFilter = object.statusFilter ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryReportsByOperatorRequest();
+        if (object.operator_address !== undefined && object.operator_address !== null) {
+            message.operatorAddress = object.operator_address;
+        }
+        if (object.service_type !== undefined && object.service_type !== null) {
+            message.serviceType = object.service_type;
+        }
+        if (object.status_filter !== undefined && object.status_filter !== null) {
+            message.statusFilter = object.status_filter;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.operator_address = message.operatorAddress === "" ? undefined : message.operatorAddress;
+        obj.service_type = message.serviceType === "" ? undefined : message.serviceType;
+        obj.status_filter = message.statusFilter === "" ? undefined : message.statusFilter;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryReportsByOperatorRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryReportsByOperatorRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryReportsByOperatorRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryReportsByOperatorRequest",
+            value: QueryReportsByOperatorRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryReportsByOperatorResponse() {
+    return {
+        reports: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryReportsByOperatorResponse defines the QueryReportsByOperatorResponse message.
+ * @name QueryReportsByOperatorResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryReportsByOperatorResponse
+ */
+export const QueryReportsByOperatorResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryReportsByOperatorResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.reports) {
+            Report.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryReportsByOperatorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reports.push(Report.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryReportsByOperatorResponse();
+        message.reports = object.reports?.map(e => Report.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryReportsByOperatorResponse();
+        message.reports = object.reports?.map(e => Report.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.reports) {
+            obj.reports = message.reports.map(e => e ? Report.toAmino(e) : undefined);
+        }
+        else {
+            obj.reports = message.reports;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryReportsByOperatorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryReportsByOperatorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryReportsByOperatorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryReportsByOperatorResponse",
+            value: QueryReportsByOperatorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorReputationSnapshotRequest() {
+    return {
+        address: ""
+    };
+}
+/**
+ * QueryOperatorReputationSnapshotRequest defines the QueryOperatorReputationSnapshotRequest message.
+ * @name QueryOperatorReputationSnapshotRequest
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorReputationSnapshotRequest
+ */
+export const QueryOperatorReputationSnapshotRequest = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorReputationSnapshotRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorReputationSnapshotRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorReputationSnapshotRequest();
+        message.address = object.address ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorReputationSnapshotRequest();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorReputationSnapshotRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorReputationSnapshotRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorReputationSnapshotRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorReputationSnapshotRequest",
+            value: QueryOperatorReputationSnapshotRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryOperatorReputationSnapshotResponse() {
+    return {
+        totalBondBlocks: "",
+        effectiveBondBlocks: ""
+    };
+}
+/**
+ * QueryOperatorReputationSnapshotResponse returns aggregate bond-block
+ * accrual for an address, settled at query time per §6.6.
+ * @name QueryOperatorReputationSnapshotResponse
+ * @package sparkdream.service.v1
+ * @see proto type: sparkdream.service.v1.QueryOperatorReputationSnapshotResponse
+ */
+export const QueryOperatorReputationSnapshotResponse = {
+    typeUrl: "/sparkdream.service.v1.QueryOperatorReputationSnapshotResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.totalBondBlocks !== "") {
+            writer.uint32(10).string(message.totalBondBlocks);
+        }
+        if (message.effectiveBondBlocks !== "") {
+            writer.uint32(18).string(message.effectiveBondBlocks);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryOperatorReputationSnapshotResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.totalBondBlocks = reader.string();
+                    break;
+                case 2:
+                    message.effectiveBondBlocks = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryOperatorReputationSnapshotResponse();
+        message.totalBondBlocks = object.totalBondBlocks ?? "";
+        message.effectiveBondBlocks = object.effectiveBondBlocks ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryOperatorReputationSnapshotResponse();
+        if (object.total_bond_blocks !== undefined && object.total_bond_blocks !== null) {
+            message.totalBondBlocks = object.total_bond_blocks;
+        }
+        if (object.effective_bond_blocks !== undefined && object.effective_bond_blocks !== null) {
+            message.effectiveBondBlocks = object.effective_bond_blocks;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.total_bond_blocks = message.totalBondBlocks === "" ? undefined : message.totalBondBlocks;
+        obj.effective_bond_blocks = message.effectiveBondBlocks === "" ? undefined : message.effectiveBondBlocks;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryOperatorReputationSnapshotResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryOperatorReputationSnapshotResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryOperatorReputationSnapshotResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.service.v1.QueryOperatorReputationSnapshotResponse",
+            value: QueryOperatorReputationSnapshotResponse.encode(message).finish()
+        };
+    }
+};