@bandprotocol/bandchain.js/esm/codegen/band/tunnel/v1beta1/query.js

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
import { Tunnel, Deposit, Packet, TotalFees } from "./tunnel";
import { Params } from "./params";
import { BinaryReader, BinaryWriter } from "../../../binary";
/** TunnelStatusFilter defines a filter for tunnel status. */
export var TunnelStatusFilter;
(function (TunnelStatusFilter) {
    /** TUNNEL_STATUS_FILTER_UNSPECIFIED - TUNNEL_STATUS_FILTER_UNSPECIFIED defines an unspecified status. */
    TunnelStatusFilter[TunnelStatusFilter["TUNNEL_STATUS_FILTER_UNSPECIFIED"] = 0] = "TUNNEL_STATUS_FILTER_UNSPECIFIED";
    /** TUNNEL_STATUS_FILTER_ACTIVE - TUNNEL_STATUS_FILTER_ACTIVE defines an active tunnel. */
    TunnelStatusFilter[TunnelStatusFilter["TUNNEL_STATUS_FILTER_ACTIVE"] = 1] = "TUNNEL_STATUS_FILTER_ACTIVE";
    /** TUNNEL_STATUS_FILTER_INACTIVE - TUNNEL_STATUS_FILTER_INACTIVE defines an inactive tunnel. */
    TunnelStatusFilter[TunnelStatusFilter["TUNNEL_STATUS_FILTER_INACTIVE"] = 2] = "TUNNEL_STATUS_FILTER_INACTIVE";
    TunnelStatusFilter[TunnelStatusFilter["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(TunnelStatusFilter || (TunnelStatusFilter = {}));
export const TunnelStatusFilterSDKType = TunnelStatusFilter;
export const TunnelStatusFilterAmino = TunnelStatusFilter;
export function tunnelStatusFilterFromJSON(object) {
    switch (object) {
        case 0:
        case "TUNNEL_STATUS_FILTER_UNSPECIFIED":
            return TunnelStatusFilter.TUNNEL_STATUS_FILTER_UNSPECIFIED;
        case 1:
        case "TUNNEL_STATUS_FILTER_ACTIVE":
            return TunnelStatusFilter.TUNNEL_STATUS_FILTER_ACTIVE;
        case 2:
        case "TUNNEL_STATUS_FILTER_INACTIVE":
            return TunnelStatusFilter.TUNNEL_STATUS_FILTER_INACTIVE;
        case -1:
        case "UNRECOGNIZED":
        default:
            return TunnelStatusFilter.UNRECOGNIZED;
    }
}
export function tunnelStatusFilterToJSON(object) {
    switch (object) {
        case TunnelStatusFilter.TUNNEL_STATUS_FILTER_UNSPECIFIED:
            return "TUNNEL_STATUS_FILTER_UNSPECIFIED";
        case TunnelStatusFilter.TUNNEL_STATUS_FILTER_ACTIVE:
            return "TUNNEL_STATUS_FILTER_ACTIVE";
        case TunnelStatusFilter.TUNNEL_STATUS_FILTER_INACTIVE:
            return "TUNNEL_STATUS_FILTER_INACTIVE";
        case TunnelStatusFilter.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
function createBaseQueryTunnelsRequest() {
    return {
        statusFilter: 0,
        pagination: undefined
    };
}
export const QueryTunnelsRequest = {
    typeUrl: "/band.tunnel.v1beta1.QueryTunnelsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.statusFilter !== 0) {
            writer.uint32(8).int32(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 = createBaseQueryTunnelsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.statusFilter = reader.int32();
                    break;
                case 2:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryTunnelsRequest();
        message.statusFilter = object.statusFilter ?? 0;
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryTunnelsRequest();
        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 === 0 ? undefined : message.statusFilter;
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryTunnelsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryTunnelsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryTunnelsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryTunnelsRequest",
            value: QueryTunnelsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryTunnelsResponse() {
    return {
        tunnels: [],
        pagination: undefined
    };
}
export const QueryTunnelsResponse = {
    typeUrl: "/band.tunnel.v1beta1.QueryTunnelsResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.tunnels) {
            Tunnel.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 = createBaseQueryTunnelsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnels.push(Tunnel.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 = createBaseQueryTunnelsResponse();
        message.tunnels = object.tunnels?.map(e => Tunnel.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryTunnelsResponse();
        message.tunnels = object.tunnels?.map(e => Tunnel.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.tunnels) {
            obj.tunnels = message.tunnels.map(e => e ? Tunnel.toAmino(e) : undefined);
        }
        else {
            obj.tunnels = message.tunnels;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryTunnelsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryTunnelsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryTunnelsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryTunnelsResponse",
            value: QueryTunnelsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryTunnelRequest() {
    return {
        tunnelId: BigInt(0)
    };
}
export const QueryTunnelRequest = {
    typeUrl: "/band.tunnel.v1beta1.QueryTunnelRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        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 = createBaseQueryTunnelRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryTunnelRequest();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryTunnelRequest();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryTunnelRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryTunnelRequest.decode(message.value);
    },
    toProto(message) {
        return QueryTunnelRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryTunnelRequest",
            value: QueryTunnelRequest.encode(message).finish()
        };
    }
};
function createBaseQueryTunnelResponse() {
    return {
        tunnel: Tunnel.fromPartial({})
    };
}
export const QueryTunnelResponse = {
    typeUrl: "/band.tunnel.v1beta1.QueryTunnelResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnel !== undefined) {
            Tunnel.encode(message.tunnel, 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 = createBaseQueryTunnelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnel = Tunnel.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryTunnelResponse();
        message.tunnel = object.tunnel !== undefined && object.tunnel !== null ? Tunnel.fromPartial(object.tunnel) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryTunnelResponse();
        if (object.tunnel !== undefined && object.tunnel !== null) {
            message.tunnel = Tunnel.fromAmino(object.tunnel);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel = message.tunnel ? Tunnel.toAmino(message.tunnel) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryTunnelResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryTunnelResponse.decode(message.value);
    },
    toProto(message) {
        return QueryTunnelResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryTunnelResponse",
            value: QueryTunnelResponse.encode(message).finish()
        };
    }
};
function createBaseQueryDepositsRequest() {
    return {
        tunnelId: BigInt(0),
        pagination: undefined
    };
}
export const QueryDepositsRequest = {
    typeUrl: "/band.tunnel.v1beta1.QueryDepositsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        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 = createBaseQueryDepositsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDepositsRequest();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDepositsRequest();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDepositsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDepositsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryDepositsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryDepositsRequest",
            value: QueryDepositsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryDepositsResponse() {
    return {
        deposits: [],
        pagination: undefined
    };
}
export const QueryDepositsResponse = {
    typeUrl: "/band.tunnel.v1beta1.QueryDepositsResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.deposits) {
            Deposit.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 = createBaseQueryDepositsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.deposits.push(Deposit.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 = createBaseQueryDepositsResponse();
        message.deposits = object.deposits?.map(e => Deposit.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDepositsResponse();
        message.deposits = object.deposits?.map(e => Deposit.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.deposits) {
            obj.deposits = message.deposits.map(e => e ? Deposit.toAmino(e) : undefined);
        }
        else {
            obj.deposits = message.deposits;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDepositsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDepositsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryDepositsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryDepositsResponse",
            value: QueryDepositsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryDepositRequest() {
    return {
        tunnelId: BigInt(0),
        depositor: ""
    };
}
export const QueryDepositRequest = {
    typeUrl: "/band.tunnel.v1beta1.QueryDepositRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.depositor !== "") {
            writer.uint32(18).string(message.depositor);
        }
        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 = createBaseQueryDepositRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.depositor = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDepositRequest();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.depositor = object.depositor ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDepositRequest();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.depositor !== undefined && object.depositor !== null) {
            message.depositor = object.depositor;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.depositor = message.depositor === "" ? undefined : message.depositor;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDepositRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDepositRequest.decode(message.value);
    },
    toProto(message) {
        return QueryDepositRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryDepositRequest",
            value: QueryDepositRequest.encode(message).finish()
        };
    }
};
function createBaseQueryDepositResponse() {
    return {
        deposit: Deposit.fromPartial({})
    };
}
export const QueryDepositResponse = {
    typeUrl: "/band.tunnel.v1beta1.QueryDepositResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.deposit !== undefined) {
            Deposit.encode(message.deposit, 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 = createBaseQueryDepositResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.deposit = Deposit.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryDepositResponse();
        message.deposit = object.deposit !== undefined && object.deposit !== null ? Deposit.fromPartial(object.deposit) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryDepositResponse();
        if (object.deposit !== undefined && object.deposit !== null) {
            message.deposit = Deposit.fromAmino(object.deposit);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.deposit = message.deposit ? Deposit.toAmino(message.deposit) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryDepositResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryDepositResponse.decode(message.value);
    },
    toProto(message) {
        return QueryDepositResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryDepositResponse",
            value: QueryDepositResponse.encode(message).finish()
        };
    }
};
function createBaseQueryPacketsRequest() {
    return {
        tunnelId: BigInt(0),
        pagination: undefined
    };
}
export const QueryPacketsRequest = {
    typeUrl: "/band.tunnel.v1beta1.QueryPacketsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        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 = createBaseQueryPacketsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPacketsRequest();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPacketsRequest();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPacketsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPacketsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryPacketsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryPacketsRequest",
            value: QueryPacketsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryPacketsResponse() {
    return {
        packets: [],
        pagination: undefined
    };
}
export const QueryPacketsResponse = {
    typeUrl: "/band.tunnel.v1beta1.QueryPacketsResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.packets) {
            Packet.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 = createBaseQueryPacketsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.packets.push(Packet.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 = createBaseQueryPacketsResponse();
        message.packets = object.packets?.map(e => Packet.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPacketsResponse();
        message.packets = object.packets?.map(e => Packet.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.packets) {
            obj.packets = message.packets.map(e => e ? Packet.toAmino(e) : undefined);
        }
        else {
            obj.packets = message.packets;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPacketsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPacketsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryPacketsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryPacketsResponse",
            value: QueryPacketsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryPacketRequest() {
    return {
        tunnelId: BigInt(0),
        sequence: BigInt(0)
    };
}
export const QueryPacketRequest = {
    typeUrl: "/band.tunnel.v1beta1.QueryPacketRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.sequence !== BigInt(0)) {
            writer.uint32(16).uint64(message.sequence);
        }
        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 = createBaseQueryPacketRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.sequence = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPacketRequest();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPacketRequest();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.sequence !== undefined && object.sequence !== null) {
            message.sequence = BigInt(object.sequence);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPacketRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPacketRequest.decode(message.value);
    },
    toProto(message) {
        return QueryPacketRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryPacketRequest",
            value: QueryPacketRequest.encode(message).finish()
        };
    }
};
function createBaseQueryPacketResponse() {
    return {
        packet: undefined
    };
}
export const QueryPacketResponse = {
    typeUrl: "/band.tunnel.v1beta1.QueryPacketResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.packet !== undefined) {
            Packet.encode(message.packet, 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 = createBaseQueryPacketResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.packet = Packet.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryPacketResponse();
        message.packet = object.packet !== undefined && object.packet !== null ? Packet.fromPartial(object.packet) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryPacketResponse();
        if (object.packet !== undefined && object.packet !== null) {
            message.packet = Packet.fromAmino(object.packet);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.packet = message.packet ? Packet.toAmino(message.packet) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryPacketResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryPacketResponse.decode(message.value);
    },
    toProto(message) {
        return QueryPacketResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryPacketResponse",
            value: QueryPacketResponse.encode(message).finish()
        };
    }
};
function createBaseQueryTotalFeesRequest() {
    return {};
}
export const QueryTotalFeesRequest = {
    typeUrl: "/band.tunnel.v1beta1.QueryTotalFeesRequest",
    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 = createBaseQueryTotalFeesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryTotalFeesRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryTotalFeesRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryTotalFeesRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryTotalFeesRequest.decode(message.value);
    },
    toProto(message) {
        return QueryTotalFeesRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryTotalFeesRequest",
            value: QueryTotalFeesRequest.encode(message).finish()
        };
    }
};
function createBaseQueryTotalFeesResponse() {
    return {
        totalFees: TotalFees.fromPartial({})
    };
}
export const QueryTotalFeesResponse = {
    typeUrl: "/band.tunnel.v1beta1.QueryTotalFeesResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.totalFees !== undefined) {
            TotalFees.encode(message.totalFees, 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 = createBaseQueryTotalFeesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.totalFees = TotalFees.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryTotalFeesResponse();
        message.totalFees = object.totalFees !== undefined && object.totalFees !== null ? TotalFees.fromPartial(object.totalFees) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryTotalFeesResponse();
        if (object.total_fees !== undefined && object.total_fees !== null) {
            message.totalFees = TotalFees.fromAmino(object.total_fees);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.total_fees = message.totalFees ? TotalFees.toAmino(message.totalFees) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryTotalFeesResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryTotalFeesResponse.decode(message.value);
    },
    toProto(message) {
        return QueryTotalFeesResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.QueryTotalFeesResponse",
            value: QueryTotalFeesResponse.encode(message).finish()
        };
    }
};
function createBaseQueryParamsRequest() {
    return {};
}
export const QueryParamsRequest = {
    typeUrl: "/band.tunnel.v1beta1.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: "/band.tunnel.v1beta1.QueryParamsRequest",
            value: QueryParamsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryParamsResponse() {
    return {
        params: Params.fromPartial({})
    };
}
export const QueryParamsResponse = {
    typeUrl: "/band.tunnel.v1beta1.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) : undefined;
        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: "/band.tunnel.v1beta1.QueryParamsResponse",
            value: QueryParamsResponse.encode(message).finish()
        };
    }
};