Variable dexConst

dex: {
    CancellationInitiator: any;
    OrderStatus: any;
    OrderType: any;
    PositionDirection: any;
    PositionEffect: any;
    Unit: any;
    LCDQueryClient: any;
    MsgClientImpl: any;
    QueryClientImpl: any;
    ActiveOrders: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ActiveOrders;
        encode(message: ActiveOrders, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ActiveOrdersAmino): ActiveOrders;
        fromAminoMsg(object: ActiveOrdersAminoMsg): ActiveOrders;
        fromPartial(object: {
            ids?: bigint[];
        }): ActiveOrders;
        fromProtoMsg(message: ActiveOrdersProtoMsg): ActiveOrders;
        toAmino(message: ActiveOrders): ActiveOrdersAmino;
        toProto(message: ActiveOrders): Uint8Array;
        toProtoMsg(message: ActiveOrders): ActiveOrdersProtoMsg;
    };
    AddAssetMetadataProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AddAssetMetadataProposal;
        encode(message: AddAssetMetadataProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AddAssetMetadataProposalAmino): AddAssetMetadataProposal;
        fromAminoMsg(object: AddAssetMetadataProposalAminoMsg): AddAssetMetadataProposal;
        fromPartial(object: {
            assetList?: {
                ibcInfo?: {
                    dstChannel?: string;
                    sourceChainID?: string;
                    sourceChannel?: string;
                    sourceDenom?: string;
                };
                metadata?: {
                    base?: string;
                    denomUnits?: {
                        aliases?: ...;
                        denom?: ...;
                        exponent?: ...;
                    }[];
                    description?: string;
                    display?: string;
                    name?: string;
                    symbol?: string;
                };
                typeAsset?: string;
            }[];
            description?: string;
            title?: string;
        }): AddAssetMetadataProposal;
        fromProtoMsg(message: AddAssetMetadataProposalProtoMsg): AddAssetMetadataProposal;
        toAmino(message: AddAssetMetadataProposal): AddAssetMetadataProposalAmino;
        toProto(message: AddAssetMetadataProposal): Uint8Array;
        toProtoMsg(message: AddAssetMetadataProposal): AddAssetMetadataProposalProtoMsg;
    };
    Allocation: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Allocation;
        encode(message: Allocation, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AllocationAmino): Allocation;
        fromAminoMsg(object: AllocationAminoMsg): Allocation;
        fromPartial(object: {
            account?: string;
            orderId?: bigint;
            quantity?: string;
        }): Allocation;
        fromProtoMsg(message: AllocationProtoMsg): Allocation;
        toAmino(message: Allocation): AllocationAmino;
        toProto(message: Allocation): Uint8Array;
        toProtoMsg(message: Allocation): AllocationProtoMsg;
    };
    AminoConverter: {
        /seiprotocol.seichain.dex.MsgCancelOrders: {
            aminoType: string;
            fromAmino: ((object: MsgCancelOrdersAmino) => MsgCancelOrders);
            toAmino: ((message: MsgCancelOrders) => MsgCancelOrdersAmino);
        };
        /seiprotocol.seichain.dex.MsgContractDepositRent: {
            aminoType: string;
            fromAmino: ((object: MsgContractDepositRentAmino) => MsgContractDepositRent);
            toAmino: ((message: MsgContractDepositRent) => MsgContractDepositRentAmino);
        };
        /seiprotocol.seichain.dex.MsgPlaceOrders: {
            aminoType: string;
            fromAmino: ((object: MsgPlaceOrdersAmino) => MsgPlaceOrders);
            toAmino: ((message: MsgPlaceOrders) => MsgPlaceOrdersAmino);
        };
        /seiprotocol.seichain.dex.MsgRegisterContract: {
            aminoType: string;
            fromAmino: ((object: MsgRegisterContractAmino) => MsgRegisterContract);
            toAmino: ((message: MsgRegisterContract) => MsgRegisterContractAmino);
        };
        /seiprotocol.seichain.dex.MsgRegisterPairs: {
            aminoType: string;
            fromAmino: ((object: MsgRegisterPairsAmino) => MsgRegisterPairs);
            toAmino: ((message: MsgRegisterPairs) => MsgRegisterPairsAmino);
        };
        /seiprotocol.seichain.dex.MsgUnregisterContract: {
            aminoType: string;
            fromAmino: ((object: MsgUnregisterContractAmino) => MsgUnregisterContract);
            toAmino: ((message: MsgUnregisterContract) => MsgUnregisterContractAmino);
        };
        /seiprotocol.seichain.dex.MsgUnsuspendContract: {
            aminoType: string;
            fromAmino: ((object: MsgUnsuspendContractAmino) => MsgUnsuspendContract);
            toAmino: ((message: MsgUnsuspendContract) => MsgUnsuspendContractAmino);
        };
        /seiprotocol.seichain.dex.MsgUpdatePriceTickSize: {
            aminoType: string;
            fromAmino: ((object: MsgUpdatePriceTickSizeAmino) => MsgUpdatePriceTickSize);
            toAmino: ((message: MsgUpdatePriceTickSize) => MsgUpdatePriceTickSizeAmino);
        };
        /seiprotocol.seichain.dex.MsgUpdateQuantityTickSize: {
            aminoType: string;
            fromAmino: ((object: MsgUpdateQuantityTickSizeAmino) => MsgUpdateQuantityTickSize);
            toAmino: ((message: MsgUpdateQuantityTickSize) => MsgUpdateQuantityTickSizeAmino);
        };
    };
    AssetIBCInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AssetIBCInfo;
        encode(message: AssetIBCInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AssetIBCInfoAmino): AssetIBCInfo;
        fromAminoMsg(object: AssetIBCInfoAminoMsg): AssetIBCInfo;
        fromPartial(object: {
            dstChannel?: string;
            sourceChainID?: string;
            sourceChannel?: string;
            sourceDenom?: string;
        }): AssetIBCInfo;
        fromProtoMsg(message: AssetIBCInfoProtoMsg): AssetIBCInfo;
        toAmino(message: AssetIBCInfo): AssetIBCInfoAmino;
        toProto(message: AssetIBCInfo): Uint8Array;
        toProtoMsg(message: AssetIBCInfo): AssetIBCInfoProtoMsg;
    };
    AssetMetadata: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AssetMetadata;
        encode(message: AssetMetadata, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AssetMetadataAmino): AssetMetadata;
        fromAminoMsg(object: AssetMetadataAminoMsg): AssetMetadata;
        fromPartial(object: {
            ibcInfo?: {
                dstChannel?: string;
                sourceChainID?: string;
                sourceChannel?: string;
                sourceDenom?: string;
            };
            metadata?: {
                base?: string;
                denomUnits?: {
                    aliases?: string[];
                    denom?: string;
                    exponent?: number;
                }[];
                description?: string;
                display?: string;
                name?: string;
                symbol?: string;
            };
            typeAsset?: string;
        }): AssetMetadata;
        fromProtoMsg(message: AssetMetadataProtoMsg): AssetMetadata;
        toAmino(message: AssetMetadata): AssetMetadataAmino;
        toProto(message: AssetMetadata): Uint8Array;
        toProtoMsg(message: AssetMetadata): AssetMetadataProtoMsg;
    };
    BatchContractPair: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BatchContractPair;
        encode(message: BatchContractPair, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BatchContractPairAmino): BatchContractPair;
        fromAminoMsg(object: BatchContractPairAminoMsg): BatchContractPair;
        fromPartial(object: {
            contractAddr?: string;
            pairs?: {
                assetDenom?: string;
                priceDenom?: string;
                priceTicksize?: string;
                quantityTicksize?: string;
            }[];
        }): BatchContractPair;
        fromProtoMsg(message: BatchContractPairProtoMsg): BatchContractPair;
        toAmino(message: BatchContractPair): BatchContractPairAmino;
        toProto(message: BatchContractPair): Uint8Array;
        toProtoMsg(message: BatchContractPair): BatchContractPairProtoMsg;
    };
    Cancellation: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Cancellation;
        encode(message: Cancellation, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CancellationAmino): Cancellation;
        fromAminoMsg(object: CancellationAminoMsg): Cancellation;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            creator?: string;
            id?: bigint;
            initiator?: CancellationInitiator;
            positionDirection?: PositionDirection;
            price?: string;
            priceDenom?: string;
        }): Cancellation;
        fromProtoMsg(message: CancellationProtoMsg): Cancellation;
        toAmino(message: Cancellation): CancellationAmino;
        toProto(message: Cancellation): Uint8Array;
        toProtoMsg(message: Cancellation): CancellationProtoMsg;
    };
    CancellationInitiatorAmino: typeof CancellationInitiator;
    CancellationInitiatorSDKType: typeof CancellationInitiator;
    ContractDependencyInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractDependencyInfo;
        encode(message: ContractDependencyInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractDependencyInfoAmino): ContractDependencyInfo;
        fromAminoMsg(object: ContractDependencyInfoAminoMsg): ContractDependencyInfo;
        fromPartial(object: {
            dependency?: string;
            immediateElderSibling?: string;
            immediateYoungerSibling?: string;
        }): ContractDependencyInfo;
        fromProtoMsg(message: ContractDependencyInfoProtoMsg): ContractDependencyInfo;
        toAmino(message: ContractDependencyInfo): ContractDependencyInfoAmino;
        toProto(message: ContractDependencyInfo): Uint8Array;
        toProtoMsg(message: ContractDependencyInfo): ContractDependencyInfoProtoMsg;
    };
    ContractInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractInfo;
        encode(message: ContractInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractInfoAmino): ContractInfo;
        fromAminoMsg(object: ContractInfoAminoMsg): ContractInfo;
        fromPartial(object: {
            codeId?: bigint;
            contractAddr?: string;
            dependencies?: {
                dependency?: string;
                immediateElderSibling?: string;
                immediateYoungerSibling?: string;
            }[];
            needHook?: boolean;
            needOrderMatching?: boolean;
            numIncomingDependencies?: bigint;
        }): ContractInfo;
        fromProtoMsg(message: ContractInfoProtoMsg): ContractInfo;
        toAmino(message: ContractInfo): ContractInfoAmino;
        toProto(message: ContractInfo): Uint8Array;
        toProtoMsg(message: ContractInfo): ContractInfoProtoMsg;
    };
    ContractInfoV2: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractInfoV2;
        encode(message: ContractInfoV2, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractInfoV2Amino): ContractInfoV2;
        fromAminoMsg(object: ContractInfoV2AminoMsg): ContractInfoV2;
        fromPartial(object: {
            codeId?: bigint;
            contractAddr?: string;
            creator?: string;
            dependencies?: {
                dependency?: string;
                immediateElderSibling?: string;
                immediateYoungerSibling?: string;
            }[];
            needHook?: boolean;
            needOrderMatching?: boolean;
            numIncomingDependencies?: bigint;
            rentBalance?: bigint;
            suspended?: boolean;
            suspensionReason?: string;
        }): ContractInfoV2;
        fromProtoMsg(message: ContractInfoV2ProtoMsg): ContractInfoV2;
        toAmino(message: ContractInfoV2): ContractInfoV2Amino;
        toProto(message: ContractInfoV2): Uint8Array;
        toProtoMsg(message: ContractInfoV2): ContractInfoV2ProtoMsg;
    };
    ContractPairPrices: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractPairPrices;
        encode(message: ContractPairPrices, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractPairPricesAmino): ContractPairPrices;
        fromAminoMsg(object: ContractPairPricesAminoMsg): ContractPairPrices;
        fromPartial(object: {
            pricePair?: {
                assetDenom?: string;
                priceDenom?: string;
                priceTicksize?: string;
                quantityTicksize?: string;
            };
            prices?: {
                pair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                price?: string;
                snapshotTimestampInSeconds?: bigint;
            }[];
        }): ContractPairPrices;
        fromProtoMsg(message: ContractPairPricesProtoMsg): ContractPairPrices;
        toAmino(message: ContractPairPrices): ContractPairPricesAmino;
        toProto(message: ContractPairPrices): Uint8Array;
        toProtoMsg(message: ContractPairPrices): ContractPairPricesProtoMsg;
    };
    ContractState: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractState;
        encode(message: ContractState, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractStateAmino): ContractState;
        fromAminoMsg(object: ContractStateAminoMsg): ContractState;
        fromPartial(object: {
            contractInfo?: {
                codeId?: bigint;
                contractAddr?: string;
                creator?: string;
                dependencies?: {
                    dependency?: string;
                    immediateElderSibling?: string;
                    immediateYoungerSibling?: string;
                }[];
                needHook?: boolean;
                needOrderMatching?: boolean;
                numIncomingDependencies?: bigint;
                rentBalance?: bigint;
                suspended?: boolean;
                suspensionReason?: string;
            };
            longBookList?: {
                entry?: {
                    allocations?: {
                        account?: ...;
                        orderId?: ...;
                        quantity?: ...;
                    }[];
                    assetDenom?: string;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                };
                price?: string;
            }[];
            nextOrderId?: bigint;
            pairList?: {
                assetDenom?: string;
                priceDenom?: string;
                priceTicksize?: string;
                quantityTicksize?: string;
            }[];
            priceList?: {
                pricePair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                prices?: {
                    pair?: {
                        assetDenom?: ...;
                        priceDenom?: ...;
                        priceTicksize?: ...;
                        quantityTicksize?: ...;
                    };
                    price?: string;
                    snapshotTimestampInSeconds?: bigint;
                }[];
            }[];
            shortBookList?: {
                entry?: {
                    allocations?: {
                        account?: ...;
                        orderId?: ...;
                        quantity?: ...;
                    }[];
                    assetDenom?: string;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                };
                price?: string;
            }[];
            triggeredOrdersList?: {
                account?: string;
                assetDenom?: string;
                contractAddr?: string;
                data?: string;
                id?: bigint;
                nominal?: string;
                orderType?: OrderType;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
                quantity?: string;
                status?: OrderStatus;
                statusDescription?: string;
                triggerPrice?: string;
                triggerStatus?: boolean;
            }[];
        }): ContractState;
        fromProtoMsg(message: ContractStateProtoMsg): ContractState;
        toAmino(message: ContractState): ContractStateAmino;
        toProto(message: ContractState): Uint8Array;
        toProtoMsg(message: ContractState): ContractStateProtoMsg;
    };
    DepositInfoEntry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DepositInfoEntry;
        encode(message: DepositInfoEntry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DepositInfoEntryAmino): DepositInfoEntry;
        fromAminoMsg(object: DepositInfoEntryAminoMsg): DepositInfoEntry;
        fromPartial(object: {
            amount?: string;
            creator?: string;
            denom?: string;
        }): DepositInfoEntry;
        fromProtoMsg(message: DepositInfoEntryProtoMsg): DepositInfoEntry;
        toAmino(message: DepositInfoEntry): DepositInfoEntryAmino;
        toProto(message: DepositInfoEntry): Uint8Array;
        toProtoMsg(message: DepositInfoEntry): DepositInfoEntryProtoMsg;
    };
    GenesisState: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): GenesisState;
        encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: GenesisStateAmino): GenesisState;
        fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
        fromPartial(object: {
            contractState?: {
                contractInfo?: {
                    codeId?: bigint;
                    contractAddr?: string;
                    creator?: string;
                    dependencies?: {
                        dependency?: ...;
                        immediateElderSibling?: ...;
                        immediateYoungerSibling?: ...;
                    }[];
                    needHook?: boolean;
                    needOrderMatching?: boolean;
                    numIncomingDependencies?: bigint;
                    rentBalance?: bigint;
                    suspended?: boolean;
                    suspensionReason?: string;
                };
                longBookList?: {
                    entry?: {
                        allocations?: ...;
                        assetDenom?: ...;
                        price?: ...;
                        priceDenom?: ...;
                        quantity?: ...;
                    };
                    price?: string;
                }[];
                nextOrderId?: bigint;
                pairList?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                }[];
                priceList?: {
                    pricePair?: {
                        assetDenom?: ...;
                        priceDenom?: ...;
                        priceTicksize?: ...;
                        quantityTicksize?: ...;
                    };
                    prices?: (...)[];
                }[];
                shortBookList?: {
                    entry?: {
                        allocations?: ...;
                        assetDenom?: ...;
                        price?: ...;
                        priceDenom?: ...;
                        quantity?: ...;
                    };
                    price?: string;
                }[];
                triggeredOrdersList?: {
                    account?: string;
                    assetDenom?: string;
                    contractAddr?: string;
                    data?: string;
                    id?: bigint;
                    nominal?: string;
                    orderType?: OrderType;
                    positionDirection?: PositionDirection;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                    status?: OrderStatus;
                    statusDescription?: string;
                    triggerPrice?: string;
                    triggerStatus?: boolean;
                }[];
            }[];
            lastEpoch?: bigint;
            params?: {
                beginBlockGasLimit?: bigint;
                contractUnsuspendCost?: bigint;
                defaultGasPerCancel?: bigint;
                defaultGasPerOrder?: bigint;
                defaultGasPerOrderDataByte?: bigint;
                endBlockGasLimit?: bigint;
                gasAllowancePerSettlement?: bigint;
                maxOrderPerPrice?: bigint;
                maxPairsPerContract?: bigint;
                minProcessableRent?: bigint;
                minRentDeposit?: bigint;
                orderBookEntriesPerLoad?: bigint;
                priceSnapshotRetention?: bigint;
                sudoCallGasPrice?: string;
            };
        }): GenesisState;
        fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
        toAmino(message: GenesisState): GenesisStateAmino;
        toProto(message: GenesisState): Uint8Array;
        toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
    };
    LegacyContractInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LegacyContractInfo;
        encode(message: LegacyContractInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LegacyContractInfoAmino): LegacyContractInfo;
        fromAminoMsg(object: LegacyContractInfoAminoMsg): LegacyContractInfo;
        fromPartial(object: {
            codeId?: bigint;
            contractAddr?: string;
            dependentContractAddrs?: string[];
            needHook?: boolean;
            needOrderMatching?: boolean;
        }): LegacyContractInfo;
        fromProtoMsg(message: LegacyContractInfoProtoMsg): LegacyContractInfo;
        toAmino(message: LegacyContractInfo): LegacyContractInfoAmino;
        toProto(message: LegacyContractInfo): Uint8Array;
        toProtoMsg(message: LegacyContractInfo): LegacyContractInfoProtoMsg;
    };
    LongBook: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LongBook;
        encode(message: LongBook, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LongBookAmino): LongBook;
        fromAminoMsg(object: LongBookAminoMsg): LongBook;
        fromPartial(object: {
            entry?: {
                allocations?: {
                    account?: string;
                    orderId?: bigint;
                    quantity?: string;
                }[];
                assetDenom?: string;
                price?: string;
                priceDenom?: string;
                quantity?: string;
            };
            price?: string;
        }): LongBook;
        fromProtoMsg(message: LongBookProtoMsg): LongBook;
        toAmino(message: LongBook): LongBookAmino;
        toProto(message: LongBook): Uint8Array;
        toProtoMsg(message: LongBook): LongBookProtoMsg;
    };
    MatchResult: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MatchResult;
        encode(message: MatchResult, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MatchResultAmino): MatchResult;
        fromAminoMsg(object: MatchResultAminoMsg): MatchResult;
        fromPartial(object: {
            cancellations?: {
                assetDenom?: string;
                contractAddr?: string;
                creator?: string;
                id?: bigint;
                initiator?: CancellationInitiator;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
            }[];
            contractAddr?: string;
            height?: bigint;
            orders?: {
                account?: string;
                assetDenom?: string;
                contractAddr?: string;
                data?: string;
                id?: bigint;
                nominal?: string;
                orderType?: OrderType;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
                quantity?: string;
                status?: OrderStatus;
                statusDescription?: string;
                triggerPrice?: string;
                triggerStatus?: boolean;
            }[];
            settlements?: {
                account?: string;
                assetDenom?: string;
                executionCostOrProceed?: string;
                expectedCostOrProceed?: string;
                height?: bigint;
                orderId?: bigint;
                orderType?: string;
                positionDirection?: string;
                priceDenom?: string;
                quantity?: string;
                settlementId?: bigint;
                timestamp?: bigint;
            }[];
        }): MatchResult;
        fromProtoMsg(message: MatchResultProtoMsg): MatchResult;
        toAmino(message: MatchResult): MatchResultAmino;
        toProto(message: MatchResult): Uint8Array;
        toProtoMsg(message: MatchResult): MatchResultProtoMsg;
    };
    MessageComposer: {
        encoded: {
            cancelOrders(value: MsgCancelOrders): {
                typeUrl: string;
                value: Uint8Array;
            };
            contractDepositRent(value: MsgContractDepositRent): {
                typeUrl: string;
                value: Uint8Array;
            };
            placeOrders(value: MsgPlaceOrders): {
                typeUrl: string;
                value: Uint8Array;
            };
            registerContract(value: MsgRegisterContract): {
                typeUrl: string;
                value: Uint8Array;
            };
            registerPairs(value: MsgRegisterPairs): {
                typeUrl: string;
                value: Uint8Array;
            };
            unregisterContract(value: MsgUnregisterContract): {
                typeUrl: string;
                value: Uint8Array;
            };
            unsuspendContract(value: MsgUnsuspendContract): {
                typeUrl: string;
                value: Uint8Array;
            };
            updatePriceTickSize(value: MsgUpdatePriceTickSize): {
                typeUrl: string;
                value: Uint8Array;
            };
            updateQuantityTickSize(value: MsgUpdateQuantityTickSize): {
                typeUrl: string;
                value: Uint8Array;
            };
        };
        fromPartial: {
            cancelOrders(value: MsgCancelOrders): {
                typeUrl: string;
                value: MsgCancelOrders;
            };
            contractDepositRent(value: MsgContractDepositRent): {
                typeUrl: string;
                value: MsgContractDepositRent;
            };
            placeOrders(value: MsgPlaceOrders): {
                typeUrl: string;
                value: MsgPlaceOrders;
            };
            registerContract(value: MsgRegisterContract): {
                typeUrl: string;
                value: MsgRegisterContract;
            };
            registerPairs(value: MsgRegisterPairs): {
                typeUrl: string;
                value: MsgRegisterPairs;
            };
            unregisterContract(value: MsgUnregisterContract): {
                typeUrl: string;
                value: MsgUnregisterContract;
            };
            unsuspendContract(value: MsgUnsuspendContract): {
                typeUrl: string;
                value: MsgUnsuspendContract;
            };
            updatePriceTickSize(value: MsgUpdatePriceTickSize): {
                typeUrl: string;
                value: MsgUpdatePriceTickSize;
            };
            updateQuantityTickSize(value: MsgUpdateQuantityTickSize): {
                typeUrl: string;
                value: MsgUpdateQuantityTickSize;
            };
        };
        withTypeUrl: {
            cancelOrders(value: MsgCancelOrders): {
                typeUrl: string;
                value: MsgCancelOrders;
            };
            contractDepositRent(value: MsgContractDepositRent): {
                typeUrl: string;
                value: MsgContractDepositRent;
            };
            placeOrders(value: MsgPlaceOrders): {
                typeUrl: string;
                value: MsgPlaceOrders;
            };
            registerContract(value: MsgRegisterContract): {
                typeUrl: string;
                value: MsgRegisterContract;
            };
            registerPairs(value: MsgRegisterPairs): {
                typeUrl: string;
                value: MsgRegisterPairs;
            };
            unregisterContract(value: MsgUnregisterContract): {
                typeUrl: string;
                value: MsgUnregisterContract;
            };
            unsuspendContract(value: MsgUnsuspendContract): {
                typeUrl: string;
                value: MsgUnsuspendContract;
            };
            updatePriceTickSize(value: MsgUpdatePriceTickSize): {
                typeUrl: string;
                value: MsgUpdatePriceTickSize;
            };
            updateQuantityTickSize(value: MsgUpdateQuantityTickSize): {
                typeUrl: string;
                value: MsgUpdateQuantityTickSize;
            };
        };
    };
    MsgCancelOrders: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgCancelOrders;
        encode(message: MsgCancelOrders, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgCancelOrdersAmino): MsgCancelOrders;
        fromAminoMsg(object: MsgCancelOrdersAminoMsg): MsgCancelOrders;
        fromPartial(object: {
            cancellations?: {
                assetDenom?: string;
                contractAddr?: string;
                creator?: string;
                id?: bigint;
                initiator?: CancellationInitiator;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
            }[];
            contractAddr?: string;
            creator?: string;
        }): MsgCancelOrders;
        fromProtoMsg(message: MsgCancelOrdersProtoMsg): MsgCancelOrders;
        toAmino(message: MsgCancelOrders): MsgCancelOrdersAmino;
        toProto(message: MsgCancelOrders): Uint8Array;
        toProtoMsg(message: MsgCancelOrders): MsgCancelOrdersProtoMsg;
    };
    MsgCancelOrdersResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgCancelOrdersResponse;
        encode(_: MsgCancelOrdersResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgCancelOrdersResponseAmino): MsgCancelOrdersResponse;
        fromAminoMsg(object: MsgCancelOrdersResponseAminoMsg): MsgCancelOrdersResponse;
        fromPartial(_: {}): MsgCancelOrdersResponse;
        fromProtoMsg(message: MsgCancelOrdersResponseProtoMsg): MsgCancelOrdersResponse;
        toAmino(_: MsgCancelOrdersResponse): MsgCancelOrdersResponseAmino;
        toProto(message: MsgCancelOrdersResponse): Uint8Array;
        toProtoMsg(message: MsgCancelOrdersResponse): MsgCancelOrdersResponseProtoMsg;
    };
    MsgContractDepositRent: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgContractDepositRent;
        encode(message: MsgContractDepositRent, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgContractDepositRentAmino): MsgContractDepositRent;
        fromAminoMsg(object: MsgContractDepositRentAminoMsg): MsgContractDepositRent;
        fromPartial(object: {
            amount?: bigint;
            contractAddr?: string;
            sender?: string;
        }): MsgContractDepositRent;
        fromProtoMsg(message: MsgContractDepositRentProtoMsg): MsgContractDepositRent;
        toAmino(message: MsgContractDepositRent): MsgContractDepositRentAmino;
        toProto(message: MsgContractDepositRent): Uint8Array;
        toProtoMsg(message: MsgContractDepositRent): MsgContractDepositRentProtoMsg;
    };
    MsgContractDepositRentResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgContractDepositRentResponse;
        encode(_: MsgContractDepositRentResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgContractDepositRentResponseAmino): MsgContractDepositRentResponse;
        fromAminoMsg(object: MsgContractDepositRentResponseAminoMsg): MsgContractDepositRentResponse;
        fromPartial(_: {}): MsgContractDepositRentResponse;
        fromProtoMsg(message: MsgContractDepositRentResponseProtoMsg): MsgContractDepositRentResponse;
        toAmino(_: MsgContractDepositRentResponse): MsgContractDepositRentResponseAmino;
        toProto(message: MsgContractDepositRentResponse): Uint8Array;
        toProtoMsg(message: MsgContractDepositRentResponse): MsgContractDepositRentResponseProtoMsg;
    };
    MsgPlaceOrders: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgPlaceOrders;
        encode(message: MsgPlaceOrders, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgPlaceOrdersAmino): MsgPlaceOrders;
        fromAminoMsg(object: MsgPlaceOrdersAminoMsg): MsgPlaceOrders;
        fromPartial(object: {
            contractAddr?: string;
            creator?: string;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            orders?: {
                account?: string;
                assetDenom?: string;
                contractAddr?: string;
                data?: string;
                id?: bigint;
                nominal?: string;
                orderType?: OrderType;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
                quantity?: string;
                status?: OrderStatus;
                statusDescription?: string;
                triggerPrice?: string;
                triggerStatus?: boolean;
            }[];
        }): MsgPlaceOrders;
        fromProtoMsg(message: MsgPlaceOrdersProtoMsg): MsgPlaceOrders;
        toAmino(message: MsgPlaceOrders): MsgPlaceOrdersAmino;
        toProto(message: MsgPlaceOrders): Uint8Array;
        toProtoMsg(message: MsgPlaceOrders): MsgPlaceOrdersProtoMsg;
    };
    MsgPlaceOrdersResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgPlaceOrdersResponse;
        encode(message: MsgPlaceOrdersResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgPlaceOrdersResponseAmino): MsgPlaceOrdersResponse;
        fromAminoMsg(object: MsgPlaceOrdersResponseAminoMsg): MsgPlaceOrdersResponse;
        fromPartial(object: {
            orderIds?: bigint[];
        }): MsgPlaceOrdersResponse;
        fromProtoMsg(message: MsgPlaceOrdersResponseProtoMsg): MsgPlaceOrdersResponse;
        toAmino(message: MsgPlaceOrdersResponse): MsgPlaceOrdersResponseAmino;
        toProto(message: MsgPlaceOrdersResponse): Uint8Array;
        toProtoMsg(message: MsgPlaceOrdersResponse): MsgPlaceOrdersResponseProtoMsg;
    };
    MsgRegisterContract: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgRegisterContract;
        encode(message: MsgRegisterContract, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgRegisterContractAmino): MsgRegisterContract;
        fromAminoMsg(object: MsgRegisterContractAminoMsg): MsgRegisterContract;
        fromPartial(object: {
            contract?: {
                codeId?: bigint;
                contractAddr?: string;
                creator?: string;
                dependencies?: {
                    dependency?: string;
                    immediateElderSibling?: string;
                    immediateYoungerSibling?: string;
                }[];
                needHook?: boolean;
                needOrderMatching?: boolean;
                numIncomingDependencies?: bigint;
                rentBalance?: bigint;
                suspended?: boolean;
                suspensionReason?: string;
            };
            creator?: string;
        }): MsgRegisterContract;
        fromProtoMsg(message: MsgRegisterContractProtoMsg): MsgRegisterContract;
        toAmino(message: MsgRegisterContract): MsgRegisterContractAmino;
        toProto(message: MsgRegisterContract): Uint8Array;
        toProtoMsg(message: MsgRegisterContract): MsgRegisterContractProtoMsg;
    };
    MsgRegisterContractResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgRegisterContractResponse;
        encode(_: MsgRegisterContractResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgRegisterContractResponseAmino): MsgRegisterContractResponse;
        fromAminoMsg(object: MsgRegisterContractResponseAminoMsg): MsgRegisterContractResponse;
        fromPartial(_: {}): MsgRegisterContractResponse;
        fromProtoMsg(message: MsgRegisterContractResponseProtoMsg): MsgRegisterContractResponse;
        toAmino(_: MsgRegisterContractResponse): MsgRegisterContractResponseAmino;
        toProto(message: MsgRegisterContractResponse): Uint8Array;
        toProtoMsg(message: MsgRegisterContractResponse): MsgRegisterContractResponseProtoMsg;
    };
    MsgRegisterPairs: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgRegisterPairs;
        encode(message: MsgRegisterPairs, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgRegisterPairsAmino): MsgRegisterPairs;
        fromAminoMsg(object: MsgRegisterPairsAminoMsg): MsgRegisterPairs;
        fromPartial(object: {
            batchcontractpair?: {
                contractAddr?: string;
                pairs?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                }[];
            }[];
            creator?: string;
        }): MsgRegisterPairs;
        fromProtoMsg(message: MsgRegisterPairsProtoMsg): MsgRegisterPairs;
        toAmino(message: MsgRegisterPairs): MsgRegisterPairsAmino;
        toProto(message: MsgRegisterPairs): Uint8Array;
        toProtoMsg(message: MsgRegisterPairs): MsgRegisterPairsProtoMsg;
    };
    MsgRegisterPairsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgRegisterPairsResponse;
        encode(_: MsgRegisterPairsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgRegisterPairsResponseAmino): MsgRegisterPairsResponse;
        fromAminoMsg(object: MsgRegisterPairsResponseAminoMsg): MsgRegisterPairsResponse;
        fromPartial(_: {}): MsgRegisterPairsResponse;
        fromProtoMsg(message: MsgRegisterPairsResponseProtoMsg): MsgRegisterPairsResponse;
        toAmino(_: MsgRegisterPairsResponse): MsgRegisterPairsResponseAmino;
        toProto(message: MsgRegisterPairsResponse): Uint8Array;
        toProtoMsg(message: MsgRegisterPairsResponse): MsgRegisterPairsResponseProtoMsg;
    };
    MsgUnregisterContract: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUnregisterContract;
        encode(message: MsgUnregisterContract, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUnregisterContractAmino): MsgUnregisterContract;
        fromAminoMsg(object: MsgUnregisterContractAminoMsg): MsgUnregisterContract;
        fromPartial(object: {
            contractAddr?: string;
            creator?: string;
        }): MsgUnregisterContract;
        fromProtoMsg(message: MsgUnregisterContractProtoMsg): MsgUnregisterContract;
        toAmino(message: MsgUnregisterContract): MsgUnregisterContractAmino;
        toProto(message: MsgUnregisterContract): Uint8Array;
        toProtoMsg(message: MsgUnregisterContract): MsgUnregisterContractProtoMsg;
    };
    MsgUnregisterContractResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUnregisterContractResponse;
        encode(_: MsgUnregisterContractResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgUnregisterContractResponseAmino): MsgUnregisterContractResponse;
        fromAminoMsg(object: MsgUnregisterContractResponseAminoMsg): MsgUnregisterContractResponse;
        fromPartial(_: {}): MsgUnregisterContractResponse;
        fromProtoMsg(message: MsgUnregisterContractResponseProtoMsg): MsgUnregisterContractResponse;
        toAmino(_: MsgUnregisterContractResponse): MsgUnregisterContractResponseAmino;
        toProto(message: MsgUnregisterContractResponse): Uint8Array;
        toProtoMsg(message: MsgUnregisterContractResponse): MsgUnregisterContractResponseProtoMsg;
    };
    MsgUnsuspendContract: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUnsuspendContract;
        encode(message: MsgUnsuspendContract, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUnsuspendContractAmino): MsgUnsuspendContract;
        fromAminoMsg(object: MsgUnsuspendContractAminoMsg): MsgUnsuspendContract;
        fromPartial(object: {
            contractAddr?: string;
            creator?: string;
        }): MsgUnsuspendContract;
        fromProtoMsg(message: MsgUnsuspendContractProtoMsg): MsgUnsuspendContract;
        toAmino(message: MsgUnsuspendContract): MsgUnsuspendContractAmino;
        toProto(message: MsgUnsuspendContract): Uint8Array;
        toProtoMsg(message: MsgUnsuspendContract): MsgUnsuspendContractProtoMsg;
    };
    MsgUnsuspendContractResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUnsuspendContractResponse;
        encode(_: MsgUnsuspendContractResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgUnsuspendContractResponseAmino): MsgUnsuspendContractResponse;
        fromAminoMsg(object: MsgUnsuspendContractResponseAminoMsg): MsgUnsuspendContractResponse;
        fromPartial(_: {}): MsgUnsuspendContractResponse;
        fromProtoMsg(message: MsgUnsuspendContractResponseProtoMsg): MsgUnsuspendContractResponse;
        toAmino(_: MsgUnsuspendContractResponse): MsgUnsuspendContractResponseAmino;
        toProto(message: MsgUnsuspendContractResponse): Uint8Array;
        toProtoMsg(message: MsgUnsuspendContractResponse): MsgUnsuspendContractResponseProtoMsg;
    };
    MsgUpdatePriceTickSize: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpdatePriceTickSize;
        encode(message: MsgUpdatePriceTickSize, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUpdatePriceTickSizeAmino): MsgUpdatePriceTickSize;
        fromAminoMsg(object: MsgUpdatePriceTickSizeAminoMsg): MsgUpdatePriceTickSize;
        fromPartial(object: {
            creator?: string;
            tickSizeList?: {
                contractAddr?: string;
                pair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                ticksize?: string;
            }[];
        }): MsgUpdatePriceTickSize;
        fromProtoMsg(message: MsgUpdatePriceTickSizeProtoMsg): MsgUpdatePriceTickSize;
        toAmino(message: MsgUpdatePriceTickSize): MsgUpdatePriceTickSizeAmino;
        toProto(message: MsgUpdatePriceTickSize): Uint8Array;
        toProtoMsg(message: MsgUpdatePriceTickSize): MsgUpdatePriceTickSizeProtoMsg;
    };
    MsgUpdateQuantityTickSize: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpdateQuantityTickSize;
        encode(message: MsgUpdateQuantityTickSize, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUpdateQuantityTickSizeAmino): MsgUpdateQuantityTickSize;
        fromAminoMsg(object: MsgUpdateQuantityTickSizeAminoMsg): MsgUpdateQuantityTickSize;
        fromPartial(object: {
            creator?: string;
            tickSizeList?: {
                contractAddr?: string;
                pair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                ticksize?: string;
            }[];
        }): MsgUpdateQuantityTickSize;
        fromProtoMsg(message: MsgUpdateQuantityTickSizeProtoMsg): MsgUpdateQuantityTickSize;
        toAmino(message: MsgUpdateQuantityTickSize): MsgUpdateQuantityTickSizeAmino;
        toProto(message: MsgUpdateQuantityTickSize): Uint8Array;
        toProtoMsg(message: MsgUpdateQuantityTickSize): MsgUpdateQuantityTickSizeProtoMsg;
    };
    MsgUpdateTickSizeResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpdateTickSizeResponse;
        encode(_: MsgUpdateTickSizeResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgUpdateTickSizeResponseAmino): MsgUpdateTickSizeResponse;
        fromAminoMsg(object: MsgUpdateTickSizeResponseAminoMsg): MsgUpdateTickSizeResponse;
        fromPartial(_: {}): MsgUpdateTickSizeResponse;
        fromProtoMsg(message: MsgUpdateTickSizeResponseProtoMsg): MsgUpdateTickSizeResponse;
        toAmino(_: MsgUpdateTickSizeResponse): MsgUpdateTickSizeResponseAmino;
        toProto(message: MsgUpdateTickSizeResponse): Uint8Array;
        toProtoMsg(message: MsgUpdateTickSizeResponse): MsgUpdateTickSizeResponseProtoMsg;
    };
    Order: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Order;
        encode(message: Order, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: OrderAmino): Order;
        fromAminoMsg(object: OrderAminoMsg): Order;
        fromPartial(object: {
            account?: string;
            assetDenom?: string;
            contractAddr?: string;
            data?: string;
            id?: bigint;
            nominal?: string;
            orderType?: OrderType;
            positionDirection?: PositionDirection;
            price?: string;
            priceDenom?: string;
            quantity?: string;
            status?: OrderStatus;
            statusDescription?: string;
            triggerPrice?: string;
            triggerStatus?: boolean;
        }): Order;
        fromProtoMsg(message: OrderProtoMsg): Order;
        toAmino(message: Order): OrderAmino;
        toProto(message: Order): Uint8Array;
        toProtoMsg(message: Order): OrderProtoMsg;
    };
    OrderEntry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): OrderEntry;
        encode(message: OrderEntry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: OrderEntryAmino): OrderEntry;
        fromAminoMsg(object: OrderEntryAminoMsg): OrderEntry;
        fromPartial(object: {
            allocations?: {
                account?: string;
                orderId?: bigint;
                quantity?: string;
            }[];
            assetDenom?: string;
            price?: string;
            priceDenom?: string;
            quantity?: string;
        }): OrderEntry;
        fromProtoMsg(message: OrderEntryProtoMsg): OrderEntry;
        toAmino(message: OrderEntry): OrderEntryAmino;
        toProto(message: OrderEntry): Uint8Array;
        toProtoMsg(message: OrderEntry): OrderEntryProtoMsg;
    };
    OrderStatusAmino: typeof OrderStatus;
    OrderStatusSDKType: typeof OrderStatus;
    OrderTypeAmino: typeof OrderType;
    OrderTypeSDKType: typeof OrderType;
    Pair: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Pair;
        encode(message: Pair, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PairAmino): Pair;
        fromAminoMsg(object: PairAminoMsg): Pair;
        fromPartial(object: {
            assetDenom?: string;
            priceDenom?: string;
            priceTicksize?: string;
            quantityTicksize?: string;
        }): Pair;
        fromProtoMsg(message: PairProtoMsg): Pair;
        toAmino(message: Pair): PairAmino;
        toProto(message: Pair): Uint8Array;
        toProtoMsg(message: Pair): PairProtoMsg;
    };
    Params: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Params;
        encode(message: Params, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ParamsAmino): Params;
        fromAminoMsg(object: ParamsAminoMsg): Params;
        fromPartial(object: {
            beginBlockGasLimit?: bigint;
            contractUnsuspendCost?: bigint;
            defaultGasPerCancel?: bigint;
            defaultGasPerOrder?: bigint;
            defaultGasPerOrderDataByte?: bigint;
            endBlockGasLimit?: bigint;
            gasAllowancePerSettlement?: bigint;
            maxOrderPerPrice?: bigint;
            maxPairsPerContract?: bigint;
            minProcessableRent?: bigint;
            minRentDeposit?: bigint;
            orderBookEntriesPerLoad?: bigint;
            priceSnapshotRetention?: bigint;
            sudoCallGasPrice?: string;
        }): Params;
        fromProtoMsg(message: ParamsProtoMsg): Params;
        toAmino(message: Params): ParamsAmino;
        toProto(message: Params): Uint8Array;
        toProtoMsg(message: Params): ParamsProtoMsg;
    };
    PositionDirectionAmino: typeof PositionDirection;
    PositionDirectionSDKType: typeof PositionDirection;
    PositionEffectAmino: typeof PositionEffect;
    PositionEffectSDKType: typeof PositionEffect;
    Price: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Price;
        encode(message: Price, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PriceAmino): Price;
        fromAminoMsg(object: PriceAminoMsg): Price;
        fromPartial(object: {
            pair?: {
                assetDenom?: string;
                priceDenom?: string;
                priceTicksize?: string;
                quantityTicksize?: string;
            };
            price?: string;
            snapshotTimestampInSeconds?: bigint;
        }): Price;
        fromProtoMsg(message: PriceProtoMsg): Price;
        toAmino(message: Price): PriceAmino;
        toProto(message: Price): Uint8Array;
        toProtoMsg(message: Price): PriceProtoMsg;
    };
    PriceCandlestick: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): PriceCandlestick;
        encode(message: PriceCandlestick, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PriceCandlestickAmino): PriceCandlestick;
        fromAminoMsg(object: PriceCandlestickAminoMsg): PriceCandlestick;
        fromPartial(object: {
            beginTimestamp?: bigint;
            close?: string;
            endTimestamp?: bigint;
            high?: string;
            low?: string;
            open?: string;
            volume?: string;
        }): PriceCandlestick;
        fromProtoMsg(message: PriceCandlestickProtoMsg): PriceCandlestick;
        toAmino(message: PriceCandlestick): PriceCandlestickAmino;
        toProto(message: PriceCandlestick): Uint8Array;
        toProtoMsg(message: PriceCandlestick): PriceCandlestickProtoMsg;
    };
    QueryAllLongBookRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAllLongBookRequest;
        encode(message: QueryAllLongBookRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAllLongBookRequestAmino): QueryAllLongBookRequest;
        fromAminoMsg(object: QueryAllLongBookRequestAminoMsg): QueryAllLongBookRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            priceDenom?: string;
        }): QueryAllLongBookRequest;
        fromProtoMsg(message: QueryAllLongBookRequestProtoMsg): QueryAllLongBookRequest;
        toAmino(message: QueryAllLongBookRequest): QueryAllLongBookRequestAmino;
        toProto(message: QueryAllLongBookRequest): Uint8Array;
        toProtoMsg(message: QueryAllLongBookRequest): QueryAllLongBookRequestProtoMsg;
    };
    QueryAllLongBookResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAllLongBookResponse;
        encode(message: QueryAllLongBookResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAllLongBookResponseAmino): QueryAllLongBookResponse;
        fromAminoMsg(object: QueryAllLongBookResponseAminoMsg): QueryAllLongBookResponse;
        fromPartial(object: {
            LongBook?: {
                entry?: {
                    allocations?: {
                        account?: ...;
                        orderId?: ...;
                        quantity?: ...;
                    }[];
                    assetDenom?: string;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                };
                price?: string;
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryAllLongBookResponse;
        fromProtoMsg(message: QueryAllLongBookResponseProtoMsg): QueryAllLongBookResponse;
        toAmino(message: QueryAllLongBookResponse): QueryAllLongBookResponseAmino;
        toProto(message: QueryAllLongBookResponse): Uint8Array;
        toProtoMsg(message: QueryAllLongBookResponse): QueryAllLongBookResponseProtoMsg;
    };
    QueryAllShortBookRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAllShortBookRequest;
        encode(message: QueryAllShortBookRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAllShortBookRequestAmino): QueryAllShortBookRequest;
        fromAminoMsg(object: QueryAllShortBookRequestAminoMsg): QueryAllShortBookRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            priceDenom?: string;
        }): QueryAllShortBookRequest;
        fromProtoMsg(message: QueryAllShortBookRequestProtoMsg): QueryAllShortBookRequest;
        toAmino(message: QueryAllShortBookRequest): QueryAllShortBookRequestAmino;
        toProto(message: QueryAllShortBookRequest): Uint8Array;
        toProtoMsg(message: QueryAllShortBookRequest): QueryAllShortBookRequestProtoMsg;
    };
    QueryAllShortBookResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAllShortBookResponse;
        encode(message: QueryAllShortBookResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAllShortBookResponseAmino): QueryAllShortBookResponse;
        fromAminoMsg(object: QueryAllShortBookResponseAminoMsg): QueryAllShortBookResponse;
        fromPartial(object: {
            ShortBook?: {
                entry?: {
                    allocations?: {
                        account?: ...;
                        orderId?: ...;
                        quantity?: ...;
                    }[];
                    assetDenom?: string;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                };
                price?: string;
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryAllShortBookResponse;
        fromProtoMsg(message: QueryAllShortBookResponseProtoMsg): QueryAllShortBookResponse;
        toAmino(message: QueryAllShortBookResponse): QueryAllShortBookResponseAmino;
        toProto(message: QueryAllShortBookResponse): Uint8Array;
        toProtoMsg(message: QueryAllShortBookResponse): QueryAllShortBookResponseProtoMsg;
    };
    QueryAssetListRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAssetListRequest;
        encode(_: QueryAssetListRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryAssetListRequestAmino): QueryAssetListRequest;
        fromAminoMsg(object: QueryAssetListRequestAminoMsg): QueryAssetListRequest;
        fromPartial(_: {}): QueryAssetListRequest;
        fromProtoMsg(message: QueryAssetListRequestProtoMsg): QueryAssetListRequest;
        toAmino(_: QueryAssetListRequest): QueryAssetListRequestAmino;
        toProto(message: QueryAssetListRequest): Uint8Array;
        toProtoMsg(message: QueryAssetListRequest): QueryAssetListRequestProtoMsg;
    };
    QueryAssetListResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAssetListResponse;
        encode(message: QueryAssetListResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAssetListResponseAmino): QueryAssetListResponse;
        fromAminoMsg(object: QueryAssetListResponseAminoMsg): QueryAssetListResponse;
        fromPartial(object: {
            assetList?: {
                ibcInfo?: {
                    dstChannel?: string;
                    sourceChainID?: string;
                    sourceChannel?: string;
                    sourceDenom?: string;
                };
                metadata?: {
                    base?: string;
                    denomUnits?: {
                        aliases?: ...;
                        denom?: ...;
                        exponent?: ...;
                    }[];
                    description?: string;
                    display?: string;
                    name?: string;
                    symbol?: string;
                };
                typeAsset?: string;
            }[];
        }): QueryAssetListResponse;
        fromProtoMsg(message: QueryAssetListResponseProtoMsg): QueryAssetListResponse;
        toAmino(message: QueryAssetListResponse): QueryAssetListResponseAmino;
        toProto(message: QueryAssetListResponse): Uint8Array;
        toProtoMsg(message: QueryAssetListResponse): QueryAssetListResponseProtoMsg;
    };
    QueryAssetMetadataRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAssetMetadataRequest;
        encode(message: QueryAssetMetadataRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAssetMetadataRequestAmino): QueryAssetMetadataRequest;
        fromAminoMsg(object: QueryAssetMetadataRequestAminoMsg): QueryAssetMetadataRequest;
        fromPartial(object: {
            denom?: string;
        }): QueryAssetMetadataRequest;
        fromProtoMsg(message: QueryAssetMetadataRequestProtoMsg): QueryAssetMetadataRequest;
        toAmino(message: QueryAssetMetadataRequest): QueryAssetMetadataRequestAmino;
        toProto(message: QueryAssetMetadataRequest): Uint8Array;
        toProtoMsg(message: QueryAssetMetadataRequest): QueryAssetMetadataRequestProtoMsg;
    };
    QueryAssetMetadataResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAssetMetadataResponse;
        encode(message: QueryAssetMetadataResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAssetMetadataResponseAmino): QueryAssetMetadataResponse;
        fromAminoMsg(object: QueryAssetMetadataResponseAminoMsg): QueryAssetMetadataResponse;
        fromPartial(object: {
            metadata?: {
                ibcInfo?: {
                    dstChannel?: string;
                    sourceChainID?: string;
                    sourceChannel?: string;
                    sourceDenom?: string;
                };
                metadata?: {
                    base?: string;
                    denomUnits?: {
                        aliases?: (...) | (...);
                        denom?: (...) | (...);
                        exponent?: (...) | (...);
                    }[];
                    description?: string;
                    display?: string;
                    name?: string;
                    symbol?: string;
                };
                typeAsset?: string;
            };
        }): QueryAssetMetadataResponse;
        fromProtoMsg(message: QueryAssetMetadataResponseProtoMsg): QueryAssetMetadataResponse;
        toAmino(message: QueryAssetMetadataResponse): QueryAssetMetadataResponseAmino;
        toProto(message: QueryAssetMetadataResponse): Uint8Array;
        toProtoMsg(message: QueryAssetMetadataResponse): QueryAssetMetadataResponseProtoMsg;
    };
    QueryGetHistoricalPricesRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetHistoricalPricesRequest;
        encode(message: QueryGetHistoricalPricesRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetHistoricalPricesRequestAmino): QueryGetHistoricalPricesRequest;
        fromAminoMsg(object: QueryGetHistoricalPricesRequestAminoMsg): QueryGetHistoricalPricesRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            numOfPeriods?: bigint;
            periodLengthInSeconds?: bigint;
            priceDenom?: string;
        }): QueryGetHistoricalPricesRequest;
        fromProtoMsg(message: QueryGetHistoricalPricesRequestProtoMsg): QueryGetHistoricalPricesRequest;
        toAmino(message: QueryGetHistoricalPricesRequest): QueryGetHistoricalPricesRequestAmino;
        toProto(message: QueryGetHistoricalPricesRequest): Uint8Array;
        toProtoMsg(message: QueryGetHistoricalPricesRequest): QueryGetHistoricalPricesRequestProtoMsg;
    };
    QueryGetHistoricalPricesResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetHistoricalPricesResponse;
        encode(message: QueryGetHistoricalPricesResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetHistoricalPricesResponseAmino): QueryGetHistoricalPricesResponse;
        fromAminoMsg(object: QueryGetHistoricalPricesResponseAminoMsg): QueryGetHistoricalPricesResponse;
        fromPartial(object: {
            prices?: {
                beginTimestamp?: bigint;
                close?: string;
                endTimestamp?: bigint;
                high?: string;
                low?: string;
                open?: string;
                volume?: string;
            }[];
        }): QueryGetHistoricalPricesResponse;
        fromProtoMsg(message: QueryGetHistoricalPricesResponseProtoMsg): QueryGetHistoricalPricesResponse;
        toAmino(message: QueryGetHistoricalPricesResponse): QueryGetHistoricalPricesResponseAmino;
        toProto(message: QueryGetHistoricalPricesResponse): Uint8Array;
        toProtoMsg(message: QueryGetHistoricalPricesResponse): QueryGetHistoricalPricesResponseProtoMsg;
    };
    QueryGetLatestPriceRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetLatestPriceRequest;
        encode(message: QueryGetLatestPriceRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetLatestPriceRequestAmino): QueryGetLatestPriceRequest;
        fromAminoMsg(object: QueryGetLatestPriceRequestAminoMsg): QueryGetLatestPriceRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            priceDenom?: string;
        }): QueryGetLatestPriceRequest;
        fromProtoMsg(message: QueryGetLatestPriceRequestProtoMsg): QueryGetLatestPriceRequest;
        toAmino(message: QueryGetLatestPriceRequest): QueryGetLatestPriceRequestAmino;
        toProto(message: QueryGetLatestPriceRequest): Uint8Array;
        toProtoMsg(message: QueryGetLatestPriceRequest): QueryGetLatestPriceRequestProtoMsg;
    };
    QueryGetLatestPriceResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetLatestPriceResponse;
        encode(message: QueryGetLatestPriceResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetLatestPriceResponseAmino): QueryGetLatestPriceResponse;
        fromAminoMsg(object: QueryGetLatestPriceResponseAminoMsg): QueryGetLatestPriceResponse;
        fromPartial(object: {
            price?: {
                pair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                price?: string;
                snapshotTimestampInSeconds?: bigint;
            };
        }): QueryGetLatestPriceResponse;
        fromProtoMsg(message: QueryGetLatestPriceResponseProtoMsg): QueryGetLatestPriceResponse;
        toAmino(message: QueryGetLatestPriceResponse): QueryGetLatestPriceResponseAmino;
        toProto(message: QueryGetLatestPriceResponse): Uint8Array;
        toProtoMsg(message: QueryGetLatestPriceResponse): QueryGetLatestPriceResponseProtoMsg;
    };
    QueryGetLongBookRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetLongBookRequest;
        encode(message: QueryGetLongBookRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetLongBookRequestAmino): QueryGetLongBookRequest;
        fromAminoMsg(object: QueryGetLongBookRequestAminoMsg): QueryGetLongBookRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            price?: string;
            priceDenom?: string;
        }): QueryGetLongBookRequest;
        fromProtoMsg(message: QueryGetLongBookRequestProtoMsg): QueryGetLongBookRequest;
        toAmino(message: QueryGetLongBookRequest): QueryGetLongBookRequestAmino;
        toProto(message: QueryGetLongBookRequest): Uint8Array;
        toProtoMsg(message: QueryGetLongBookRequest): QueryGetLongBookRequestProtoMsg;
    };
    QueryGetLongBookResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetLongBookResponse;
        encode(message: QueryGetLongBookResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetLongBookResponseAmino): QueryGetLongBookResponse;
        fromAminoMsg(object: QueryGetLongBookResponseAminoMsg): QueryGetLongBookResponse;
        fromPartial(object: {
            LongBook?: {
                entry?: {
                    allocations?: {
                        account?: (...) | (...);
                        orderId?: (...) | (...);
                        quantity?: (...) | (...);
                    }[];
                    assetDenom?: string;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                };
                price?: string;
            };
        }): QueryGetLongBookResponse;
        fromProtoMsg(message: QueryGetLongBookResponseProtoMsg): QueryGetLongBookResponse;
        toAmino(message: QueryGetLongBookResponse): QueryGetLongBookResponseAmino;
        toProto(message: QueryGetLongBookResponse): Uint8Array;
        toProtoMsg(message: QueryGetLongBookResponse): QueryGetLongBookResponseProtoMsg;
    };
    QueryGetMarketSummaryRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetMarketSummaryRequest;
        encode(message: QueryGetMarketSummaryRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetMarketSummaryRequestAmino): QueryGetMarketSummaryRequest;
        fromAminoMsg(object: QueryGetMarketSummaryRequestAminoMsg): QueryGetMarketSummaryRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            lookbackInSeconds?: bigint;
            priceDenom?: string;
        }): QueryGetMarketSummaryRequest;
        fromProtoMsg(message: QueryGetMarketSummaryRequestProtoMsg): QueryGetMarketSummaryRequest;
        toAmino(message: QueryGetMarketSummaryRequest): QueryGetMarketSummaryRequestAmino;
        toProto(message: QueryGetMarketSummaryRequest): Uint8Array;
        toProtoMsg(message: QueryGetMarketSummaryRequest): QueryGetMarketSummaryRequestProtoMsg;
    };
    QueryGetMarketSummaryResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetMarketSummaryResponse;
        encode(message: QueryGetMarketSummaryResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetMarketSummaryResponseAmino): QueryGetMarketSummaryResponse;
        fromAminoMsg(object: QueryGetMarketSummaryResponseAminoMsg): QueryGetMarketSummaryResponse;
        fromPartial(object: {
            highPrice?: string;
            lastPrice?: string;
            lowPrice?: string;
            totalVolume?: string;
            totalVolumeNotional?: string;
        }): QueryGetMarketSummaryResponse;
        fromProtoMsg(message: QueryGetMarketSummaryResponseProtoMsg): QueryGetMarketSummaryResponse;
        toAmino(message: QueryGetMarketSummaryResponse): QueryGetMarketSummaryResponseAmino;
        toProto(message: QueryGetMarketSummaryResponse): Uint8Array;
        toProtoMsg(message: QueryGetMarketSummaryResponse): QueryGetMarketSummaryResponseProtoMsg;
    };
    QueryGetMatchResultRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetMatchResultRequest;
        encode(message: QueryGetMatchResultRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetMatchResultRequestAmino): QueryGetMatchResultRequest;
        fromAminoMsg(object: QueryGetMatchResultRequestAminoMsg): QueryGetMatchResultRequest;
        fromPartial(object: {
            contractAddr?: string;
        }): QueryGetMatchResultRequest;
        fromProtoMsg(message: QueryGetMatchResultRequestProtoMsg): QueryGetMatchResultRequest;
        toAmino(message: QueryGetMatchResultRequest): QueryGetMatchResultRequestAmino;
        toProto(message: QueryGetMatchResultRequest): Uint8Array;
        toProtoMsg(message: QueryGetMatchResultRequest): QueryGetMatchResultRequestProtoMsg;
    };
    QueryGetMatchResultResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetMatchResultResponse;
        encode(message: QueryGetMatchResultResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetMatchResultResponseAmino): QueryGetMatchResultResponse;
        fromAminoMsg(object: QueryGetMatchResultResponseAminoMsg): QueryGetMatchResultResponse;
        fromPartial(object: {
            result?: {
                cancellations?: {
                    assetDenom?: string;
                    contractAddr?: string;
                    creator?: string;
                    id?: bigint;
                    initiator?: CancellationInitiator;
                    positionDirection?: PositionDirection;
                    price?: string;
                    priceDenom?: string;
                }[];
                contractAddr?: string;
                height?: bigint;
                orders?: {
                    account?: string;
                    assetDenom?: string;
                    contractAddr?: string;
                    data?: string;
                    id?: bigint;
                    nominal?: string;
                    orderType?: OrderType;
                    positionDirection?: PositionDirection;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                    status?: OrderStatus;
                    statusDescription?: string;
                    triggerPrice?: string;
                    triggerStatus?: boolean;
                }[];
                settlements?: {
                    account?: string;
                    assetDenom?: string;
                    executionCostOrProceed?: string;
                    expectedCostOrProceed?: string;
                    height?: bigint;
                    orderId?: bigint;
                    orderType?: string;
                    positionDirection?: string;
                    priceDenom?: string;
                    quantity?: string;
                    settlementId?: bigint;
                    timestamp?: bigint;
                }[];
            };
        }): QueryGetMatchResultResponse;
        fromProtoMsg(message: QueryGetMatchResultResponseProtoMsg): QueryGetMatchResultResponse;
        toAmino(message: QueryGetMatchResultResponse): QueryGetMatchResultResponseAmino;
        toProto(message: QueryGetMatchResultResponse): Uint8Array;
        toProtoMsg(message: QueryGetMatchResultResponse): QueryGetMatchResultResponseProtoMsg;
    };
    QueryGetOrderByIDRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetOrderByIDRequest;
        encode(message: QueryGetOrderByIDRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetOrderByIDRequestAmino): QueryGetOrderByIDRequest;
        fromAminoMsg(object: QueryGetOrderByIDRequestAminoMsg): QueryGetOrderByIDRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            id?: bigint;
            priceDenom?: string;
        }): QueryGetOrderByIDRequest;
        fromProtoMsg(message: QueryGetOrderByIDRequestProtoMsg): QueryGetOrderByIDRequest;
        toAmino(message: QueryGetOrderByIDRequest): QueryGetOrderByIDRequestAmino;
        toProto(message: QueryGetOrderByIDRequest): Uint8Array;
        toProtoMsg(message: QueryGetOrderByIDRequest): QueryGetOrderByIDRequestProtoMsg;
    };
    QueryGetOrderByIDResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetOrderByIDResponse;
        encode(message: QueryGetOrderByIDResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetOrderByIDResponseAmino): QueryGetOrderByIDResponse;
        fromAminoMsg(object: QueryGetOrderByIDResponseAminoMsg): QueryGetOrderByIDResponse;
        fromPartial(object: {
            order?: {
                account?: string;
                assetDenom?: string;
                contractAddr?: string;
                data?: string;
                id?: bigint;
                nominal?: string;
                orderType?: OrderType;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
                quantity?: string;
                status?: OrderStatus;
                statusDescription?: string;
                triggerPrice?: string;
                triggerStatus?: boolean;
            };
        }): QueryGetOrderByIDResponse;
        fromProtoMsg(message: QueryGetOrderByIDResponseProtoMsg): QueryGetOrderByIDResponse;
        toAmino(message: QueryGetOrderByIDResponse): QueryGetOrderByIDResponseAmino;
        toProto(message: QueryGetOrderByIDResponse): Uint8Array;
        toProtoMsg(message: QueryGetOrderByIDResponse): QueryGetOrderByIDResponseProtoMsg;
    };
    QueryGetOrderCountRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetOrderCountRequest;
        encode(message: QueryGetOrderCountRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetOrderCountRequestAmino): QueryGetOrderCountRequest;
        fromAminoMsg(object: QueryGetOrderCountRequestAminoMsg): QueryGetOrderCountRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            positionDirection?: PositionDirection;
            price?: string;
            priceDenom?: string;
        }): QueryGetOrderCountRequest;
        fromProtoMsg(message: QueryGetOrderCountRequestProtoMsg): QueryGetOrderCountRequest;
        toAmino(message: QueryGetOrderCountRequest): QueryGetOrderCountRequestAmino;
        toProto(message: QueryGetOrderCountRequest): Uint8Array;
        toProtoMsg(message: QueryGetOrderCountRequest): QueryGetOrderCountRequestProtoMsg;
    };
    QueryGetOrderCountResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetOrderCountResponse;
        encode(message: QueryGetOrderCountResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetOrderCountResponseAmino): QueryGetOrderCountResponse;
        fromAminoMsg(object: QueryGetOrderCountResponseAminoMsg): QueryGetOrderCountResponse;
        fromPartial(object: {
            count?: bigint;
        }): QueryGetOrderCountResponse;
        fromProtoMsg(message: QueryGetOrderCountResponseProtoMsg): QueryGetOrderCountResponse;
        toAmino(message: QueryGetOrderCountResponse): QueryGetOrderCountResponseAmino;
        toProto(message: QueryGetOrderCountResponse): Uint8Array;
        toProtoMsg(message: QueryGetOrderCountResponse): QueryGetOrderCountResponseProtoMsg;
    };
    QueryGetOrdersRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetOrdersRequest;
        encode(message: QueryGetOrdersRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetOrdersRequestAmino): QueryGetOrdersRequest;
        fromAminoMsg(object: QueryGetOrdersRequestAminoMsg): QueryGetOrdersRequest;
        fromPartial(object: {
            account?: string;
            contractAddr?: string;
        }): QueryGetOrdersRequest;
        fromProtoMsg(message: QueryGetOrdersRequestProtoMsg): QueryGetOrdersRequest;
        toAmino(message: QueryGetOrdersRequest): QueryGetOrdersRequestAmino;
        toProto(message: QueryGetOrdersRequest): Uint8Array;
        toProtoMsg(message: QueryGetOrdersRequest): QueryGetOrdersRequestProtoMsg;
    };
    QueryGetOrdersResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetOrdersResponse;
        encode(message: QueryGetOrdersResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetOrdersResponseAmino): QueryGetOrdersResponse;
        fromAminoMsg(object: QueryGetOrdersResponseAminoMsg): QueryGetOrdersResponse;
        fromPartial(object: {
            orders?: {
                account?: string;
                assetDenom?: string;
                contractAddr?: string;
                data?: string;
                id?: bigint;
                nominal?: string;
                orderType?: OrderType;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
                quantity?: string;
                status?: OrderStatus;
                statusDescription?: string;
                triggerPrice?: string;
                triggerStatus?: boolean;
            }[];
        }): QueryGetOrdersResponse;
        fromProtoMsg(message: QueryGetOrdersResponseProtoMsg): QueryGetOrdersResponse;
        toAmino(message: QueryGetOrdersResponse): QueryGetOrdersResponseAmino;
        toProto(message: QueryGetOrdersResponse): Uint8Array;
        toProtoMsg(message: QueryGetOrdersResponse): QueryGetOrdersResponseProtoMsg;
    };
    QueryGetPriceRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetPriceRequest;
        encode(message: QueryGetPriceRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetPriceRequestAmino): QueryGetPriceRequest;
        fromAminoMsg(object: QueryGetPriceRequestAminoMsg): QueryGetPriceRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            priceDenom?: string;
            timestamp?: bigint;
        }): QueryGetPriceRequest;
        fromProtoMsg(message: QueryGetPriceRequestProtoMsg): QueryGetPriceRequest;
        toAmino(message: QueryGetPriceRequest): QueryGetPriceRequestAmino;
        toProto(message: QueryGetPriceRequest): Uint8Array;
        toProtoMsg(message: QueryGetPriceRequest): QueryGetPriceRequestProtoMsg;
    };
    QueryGetPriceResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetPriceResponse;
        encode(message: QueryGetPriceResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetPriceResponseAmino): QueryGetPriceResponse;
        fromAminoMsg(object: QueryGetPriceResponseAminoMsg): QueryGetPriceResponse;
        fromPartial(object: {
            found?: boolean;
            price?: {
                pair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                price?: string;
                snapshotTimestampInSeconds?: bigint;
            };
        }): QueryGetPriceResponse;
        fromProtoMsg(message: QueryGetPriceResponseProtoMsg): QueryGetPriceResponse;
        toAmino(message: QueryGetPriceResponse): QueryGetPriceResponseAmino;
        toProto(message: QueryGetPriceResponse): Uint8Array;
        toProtoMsg(message: QueryGetPriceResponse): QueryGetPriceResponseProtoMsg;
    };
    QueryGetPricesRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetPricesRequest;
        encode(message: QueryGetPricesRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetPricesRequestAmino): QueryGetPricesRequest;
        fromAminoMsg(object: QueryGetPricesRequestAminoMsg): QueryGetPricesRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            priceDenom?: string;
        }): QueryGetPricesRequest;
        fromProtoMsg(message: QueryGetPricesRequestProtoMsg): QueryGetPricesRequest;
        toAmino(message: QueryGetPricesRequest): QueryGetPricesRequestAmino;
        toProto(message: QueryGetPricesRequest): Uint8Array;
        toProtoMsg(message: QueryGetPricesRequest): QueryGetPricesRequestProtoMsg;
    };
    QueryGetPricesResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetPricesResponse;
        encode(message: QueryGetPricesResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetPricesResponseAmino): QueryGetPricesResponse;
        fromAminoMsg(object: QueryGetPricesResponseAminoMsg): QueryGetPricesResponse;
        fromPartial(object: {
            prices?: {
                pair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                price?: string;
                snapshotTimestampInSeconds?: bigint;
            }[];
        }): QueryGetPricesResponse;
        fromProtoMsg(message: QueryGetPricesResponseProtoMsg): QueryGetPricesResponse;
        toAmino(message: QueryGetPricesResponse): QueryGetPricesResponseAmino;
        toProto(message: QueryGetPricesResponse): Uint8Array;
        toProtoMsg(message: QueryGetPricesResponse): QueryGetPricesResponseProtoMsg;
    };
    QueryGetShortBookRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetShortBookRequest;
        encode(message: QueryGetShortBookRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetShortBookRequestAmino): QueryGetShortBookRequest;
        fromAminoMsg(object: QueryGetShortBookRequestAminoMsg): QueryGetShortBookRequest;
        fromPartial(object: {
            assetDenom?: string;
            contractAddr?: string;
            price?: string;
            priceDenom?: string;
        }): QueryGetShortBookRequest;
        fromProtoMsg(message: QueryGetShortBookRequestProtoMsg): QueryGetShortBookRequest;
        toAmino(message: QueryGetShortBookRequest): QueryGetShortBookRequestAmino;
        toProto(message: QueryGetShortBookRequest): Uint8Array;
        toProtoMsg(message: QueryGetShortBookRequest): QueryGetShortBookRequestProtoMsg;
    };
    QueryGetShortBookResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetShortBookResponse;
        encode(message: QueryGetShortBookResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetShortBookResponseAmino): QueryGetShortBookResponse;
        fromAminoMsg(object: QueryGetShortBookResponseAminoMsg): QueryGetShortBookResponse;
        fromPartial(object: {
            ShortBook?: {
                entry?: {
                    allocations?: {
                        account?: (...) | (...);
                        orderId?: (...) | (...);
                        quantity?: (...) | (...);
                    }[];
                    assetDenom?: string;
                    price?: string;
                    priceDenom?: string;
                    quantity?: string;
                };
                price?: string;
            };
        }): QueryGetShortBookResponse;
        fromProtoMsg(message: QueryGetShortBookResponseProtoMsg): QueryGetShortBookResponse;
        toAmino(message: QueryGetShortBookResponse): QueryGetShortBookResponseAmino;
        toProto(message: QueryGetShortBookResponse): Uint8Array;
        toProtoMsg(message: QueryGetShortBookResponse): QueryGetShortBookResponseProtoMsg;
    };
    QueryGetTwapsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetTwapsRequest;
        encode(message: QueryGetTwapsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetTwapsRequestAmino): QueryGetTwapsRequest;
        fromAminoMsg(object: QueryGetTwapsRequestAminoMsg): QueryGetTwapsRequest;
        fromPartial(object: {
            contractAddr?: string;
            lookbackSeconds?: bigint;
        }): QueryGetTwapsRequest;
        fromProtoMsg(message: QueryGetTwapsRequestProtoMsg): QueryGetTwapsRequest;
        toAmino(message: QueryGetTwapsRequest): QueryGetTwapsRequestAmino;
        toProto(message: QueryGetTwapsRequest): Uint8Array;
        toProtoMsg(message: QueryGetTwapsRequest): QueryGetTwapsRequestProtoMsg;
    };
    QueryGetTwapsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryGetTwapsResponse;
        encode(message: QueryGetTwapsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryGetTwapsResponseAmino): QueryGetTwapsResponse;
        fromAminoMsg(object: QueryGetTwapsResponseAminoMsg): QueryGetTwapsResponse;
        fromPartial(object: {
            twaps?: {
                lookbackSeconds?: bigint;
                pair?: {
                    assetDenom?: string;
                    priceDenom?: string;
                    priceTicksize?: string;
                    quantityTicksize?: string;
                };
                twap?: string;
            }[];
        }): QueryGetTwapsResponse;
        fromProtoMsg(message: QueryGetTwapsResponseProtoMsg): QueryGetTwapsResponse;
        toAmino(message: QueryGetTwapsResponse): QueryGetTwapsResponseAmino;
        toProto(message: QueryGetTwapsResponse): Uint8Array;
        toProtoMsg(message: QueryGetTwapsResponse): QueryGetTwapsResponseProtoMsg;
    };
    QueryOrderSimulationRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryOrderSimulationRequest;
        encode(message: QueryOrderSimulationRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryOrderSimulationRequestAmino): QueryOrderSimulationRequest;
        fromAminoMsg(object: QueryOrderSimulationRequestAminoMsg): QueryOrderSimulationRequest;
        fromPartial(object: {
            contractAddr?: string;
            order?: {
                account?: string;
                assetDenom?: string;
                contractAddr?: string;
                data?: string;
                id?: bigint;
                nominal?: string;
                orderType?: OrderType;
                positionDirection?: PositionDirection;
                price?: string;
                priceDenom?: string;
                quantity?: string;
                status?: OrderStatus;
                statusDescription?: string;
                triggerPrice?: string;
                triggerStatus?: boolean;
            };
        }): QueryOrderSimulationRequest;
        fromProtoMsg(message: QueryOrderSimulationRequestProtoMsg): QueryOrderSimulationRequest;
        toAmino(message: QueryOrderSimulationRequest): QueryOrderSimulationRequestAmino;
        toProto(message: QueryOrderSimulationRequest): Uint8Array;
        toProtoMsg(message: QueryOrderSimulationRequest): QueryOrderSimulationRequestProtoMsg;
    };
    QueryOrderSimulationResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryOrderSimulationResponse;
        encode(message: QueryOrderSimulationResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryOrderSimulationResponseAmino): QueryOrderSimulationResponse;
        fromAminoMsg(object: QueryOrderSimulationResponseAminoMsg): QueryOrderSimulationResponse;
        fromPartial(object: {
            ExecutedQuantity?: string;
        }): QueryOrderSimulationResponse;
        fromProtoMsg(message: QueryOrderSimulationResponseProtoMsg): QueryOrderSimulationResponse;
        toAmino(message: QueryOrderSimulationResponse): QueryOrderSimulationResponseAmino;
        toProto(message: QueryOrderSimulationResponse): Uint8Array;
        toProtoMsg(message: QueryOrderSimulationResponse): QueryOrderSimulationResponseProtoMsg;
    };
    QueryParamsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsRequest;
        encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
        fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
        fromPartial(_: {}): QueryParamsRequest;
        fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
        toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
        toProto(message: QueryParamsRequest): Uint8Array;
        toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
    };
    QueryParamsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsResponse;
        encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
        fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
        fromPartial(object: {
            params?: {
                beginBlockGasLimit?: bigint;
                contractUnsuspendCost?: bigint;
                defaultGasPerCancel?: bigint;
                defaultGasPerOrder?: bigint;
                defaultGasPerOrderDataByte?: bigint;
                endBlockGasLimit?: bigint;
                gasAllowancePerSettlement?: bigint;
                maxOrderPerPrice?: bigint;
                maxPairsPerContract?: bigint;
                minProcessableRent?: bigint;
                minRentDeposit?: bigint;
                orderBookEntriesPerLoad?: bigint;
                priceSnapshotRetention?: bigint;
                sudoCallGasPrice?: string;
            };
        }): QueryParamsResponse;
        fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
        toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
        toProto(message: QueryParamsResponse): Uint8Array;
        toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
    };
    QueryRegisteredContractRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRegisteredContractRequest;
        encode(message: QueryRegisteredContractRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRegisteredContractRequestAmino): QueryRegisteredContractRequest;
        fromAminoMsg(object: QueryRegisteredContractRequestAminoMsg): QueryRegisteredContractRequest;
        fromPartial(object: {
            contractAddr?: string;
        }): QueryRegisteredContractRequest;
        fromProtoMsg(message: QueryRegisteredContractRequestProtoMsg): QueryRegisteredContractRequest;
        toAmino(message: QueryRegisteredContractRequest): QueryRegisteredContractRequestAmino;
        toProto(message: QueryRegisteredContractRequest): Uint8Array;
        toProtoMsg(message: QueryRegisteredContractRequest): QueryRegisteredContractRequestProtoMsg;
    };
    QueryRegisteredContractResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRegisteredContractResponse;
        encode(message: QueryRegisteredContractResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRegisteredContractResponseAmino): QueryRegisteredContractResponse;
        fromAminoMsg(object: QueryRegisteredContractResponseAminoMsg): QueryRegisteredContractResponse;
        fromPartial(object: {
            contractInfo?: {
                codeId?: bigint;
                contractAddr?: string;
                creator?: string;
                dependencies?: {
                    dependency?: string;
                    immediateElderSibling?: string;
                    immediateYoungerSibling?: string;
                }[];
                needHook?: boolean;
                needOrderMatching?: boolean;
                numIncomingDependencies?: bigint;
                rentBalance?: bigint;
                suspended?: boolean;
                suspensionReason?: string;
            };
        }): QueryRegisteredContractResponse;
        fromProtoMsg(message: QueryRegisteredContractResponseProtoMsg): QueryRegisteredContractResponse;
        toAmino(message: QueryRegisteredContractResponse): QueryRegisteredContractResponseAmino;
        toProto(message: QueryRegisteredContractResponse): Uint8Array;
        toProtoMsg(message: QueryRegisteredContractResponse): QueryRegisteredContractResponseProtoMsg;
    };
    QueryRegisteredPairsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRegisteredPairsRequest;
        encode(message: QueryRegisteredPairsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRegisteredPairsRequestAmino): QueryRegisteredPairsRequest;
        fromAminoMsg(object: QueryRegisteredPairsRequestAminoMsg): QueryRegisteredPairsRequest;
        fromPartial(object: {
            contractAddr?: string;
        }): QueryRegisteredPairsRequest;
        fromProtoMsg(message: QueryRegisteredPairsRequestProtoMsg): QueryRegisteredPairsRequest;
        toAmino(message: QueryRegisteredPairsRequest): QueryRegisteredPairsRequestAmino;
        toProto(message: QueryRegisteredPairsRequest): Uint8Array;
        toProtoMsg(message: QueryRegisteredPairsRequest): QueryRegisteredPairsRequestProtoMsg;
    };
    QueryRegisteredPairsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRegisteredPairsResponse;
        encode(message: QueryRegisteredPairsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRegisteredPairsResponseAmino): QueryRegisteredPairsResponse;
        fromAminoMsg(object: QueryRegisteredPairsResponseAminoMsg): QueryRegisteredPairsResponse;
        fromPartial(object: {
            pairs?: {
                assetDenom?: string;
                priceDenom?: string;
                priceTicksize?: string;
                quantityTicksize?: string;
            }[];
        }): QueryRegisteredPairsResponse;
        fromProtoMsg(message: QueryRegisteredPairsResponseProtoMsg): QueryRegisteredPairsResponse;
        toAmino(message: QueryRegisteredPairsResponse): QueryRegisteredPairsResponseAmino;
        toProto(message: QueryRegisteredPairsResponse): Uint8Array;
        toProtoMsg(message: QueryRegisteredPairsResponse): QueryRegisteredPairsResponseProtoMsg;
    };
    SettlementEntry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): SettlementEntry;
        encode(message: SettlementEntry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SettlementEntryAmino): SettlementEntry;
        fromAminoMsg(object: SettlementEntryAminoMsg): SettlementEntry;
        fromPartial(object: {
            account?: string;
            assetDenom?: string;
            executionCostOrProceed?: string;
            expectedCostOrProceed?: string;
            height?: bigint;
            orderId?: bigint;
            orderType?: string;
            positionDirection?: string;
            priceDenom?: string;
            quantity?: string;
            settlementId?: bigint;
            timestamp?: bigint;
        }): SettlementEntry;
        fromProtoMsg(message: SettlementEntryProtoMsg): SettlementEntry;
        toAmino(message: SettlementEntry): SettlementEntryAmino;
        toProto(message: SettlementEntry): Uint8Array;
        toProtoMsg(message: SettlementEntry): SettlementEntryProtoMsg;
    };
    Settlements: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Settlements;
        encode(message: Settlements, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SettlementsAmino): Settlements;
        fromAminoMsg(object: SettlementsAminoMsg): Settlements;
        fromPartial(object: {
            entries?: {
                account?: string;
                assetDenom?: string;
                executionCostOrProceed?: string;
                expectedCostOrProceed?: string;
                height?: bigint;
                orderId?: bigint;
                orderType?: string;
                positionDirection?: string;
                priceDenom?: string;
                quantity?: string;
                settlementId?: bigint;
                timestamp?: bigint;
            }[];
            epoch?: bigint;
        }): Settlements;
        fromProtoMsg(message: SettlementsProtoMsg): Settlements;
        toAmino(message: Settlements): SettlementsAmino;
        toProto(message: Settlements): Uint8Array;
        toProtoMsg(message: Settlements): SettlementsProtoMsg;
    };
    ShortBook: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ShortBook;
        encode(message: ShortBook, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ShortBookAmino): ShortBook;
        fromAminoMsg(object: ShortBookAminoMsg): ShortBook;
        fromPartial(object: {
            entry?: {
                allocations?: {
                    account?: string;
                    orderId?: bigint;
                    quantity?: string;
                }[];
                assetDenom?: string;
                price?: string;
                priceDenom?: string;
                quantity?: string;
            };
            price?: string;
        }): ShortBook;
        fromProtoMsg(message: ShortBookProtoMsg): ShortBook;
        toAmino(message: ShortBook): ShortBookAmino;
        toProto(message: ShortBook): Uint8Array;
        toProtoMsg(message: ShortBook): ShortBookProtoMsg;
    };
    TickSize: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): TickSize;
        encode(message: TickSize, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TickSizeAmino): TickSize;
        fromAminoMsg(object: TickSizeAminoMsg): TickSize;
        fromPartial(object: {
            contractAddr?: string;
            pair?: {
                assetDenom?: string;
                priceDenom?: string;
                priceTicksize?: string;
                quantityTicksize?: string;
            };
            ticksize?: string;
        }): TickSize;
        fromProtoMsg(message: TickSizeProtoMsg): TickSize;
        toAmino(message: TickSize): TickSizeAmino;
        toProto(message: TickSize): Uint8Array;
        toProtoMsg(message: TickSize): TickSizeProtoMsg;
    };
    Twap: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Twap;
        encode(message: Twap, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TwapAmino): Twap;
        fromAminoMsg(object: TwapAminoMsg): Twap;
        fromPartial(object: {
            lookbackSeconds?: bigint;
            pair?: {
                assetDenom?: string;
                priceDenom?: string;
                priceTicksize?: string;
                quantityTicksize?: string;
            };
            twap?: string;
        }): Twap;
        fromProtoMsg(message: TwapProtoMsg): Twap;
        toAmino(message: Twap): TwapAmino;
        toProto(message: Twap): Uint8Array;
        toProtoMsg(message: Twap): TwapProtoMsg;
    };
    UnitAmino: typeof Unit;
    UnitSDKType: typeof Unit;
    createRpcQueryExtension: ((base: QueryClient) => {
        assetList(request?: QueryAssetListRequest): Promise<QueryAssetListResponse>;
        assetMetadata(request: QueryAssetMetadataRequest): Promise<QueryAssetMetadataResponse>;
        getHistoricalPrices(request: QueryGetHistoricalPricesRequest): Promise<QueryGetHistoricalPricesResponse>;
        getLatestPrice(request: QueryGetLatestPriceRequest): Promise<QueryGetLatestPriceResponse>;
        getMarketSummary(request: QueryGetMarketSummaryRequest): Promise<QueryGetMarketSummaryResponse>;
        getMatchResult(request: QueryGetMatchResultRequest): Promise<QueryGetMatchResultResponse>;
        getOrder(request: QueryGetOrderByIDRequest): Promise<QueryGetOrderByIDResponse>;
        getOrderCount(request: QueryGetOrderCountRequest): Promise<QueryGetOrderCountResponse>;
        getOrderSimulation(request: QueryOrderSimulationRequest): Promise<QueryOrderSimulationResponse>;
        getOrders(request: QueryGetOrdersRequest): Promise<QueryGetOrdersResponse>;
        getPrice(request: QueryGetPriceRequest): Promise<QueryGetPriceResponse>;
        getPrices(request: QueryGetPricesRequest): Promise<QueryGetPricesResponse>;
        getRegisteredContract(request: QueryRegisteredContractRequest): Promise<QueryRegisteredContractResponse>;
        getRegisteredPairs(request: QueryRegisteredPairsRequest): Promise<QueryRegisteredPairsResponse>;
        getTwaps(request: QueryGetTwapsRequest): Promise<QueryGetTwapsResponse>;
        longBook(request: QueryGetLongBookRequest): Promise<QueryGetLongBookResponse>;
        longBookAll(request: QueryAllLongBookRequest): Promise<QueryAllLongBookResponse>;
        params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
        shortBook(request: QueryGetShortBookRequest): Promise<QueryGetShortBookResponse>;
        shortBookAll(request: QueryAllShortBookRequest): Promise<QueryAllShortBookResponse>;
    });
    load: ((protoRegistry: Registry) => void);
    registry: readonly [string, TelescopeGeneratedType<any, any, any>][];
    cancellationInitiatorFromJSON(object: any): CancellationInitiator;
    cancellationInitiatorToJSON(object: CancellationInitiator): string;
    orderStatusFromJSON(object: any): OrderStatus;
    orderStatusToJSON(object: OrderStatus): string;
    orderTypeFromJSON(object: any): OrderType;
    orderTypeToJSON(object: OrderType): string;
    positionDirectionFromJSON(object: any): PositionDirection;
    positionDirectionToJSON(object: PositionDirection): string;
    positionEffectFromJSON(object: any): PositionEffect;
    positionEffectToJSON(object: PositionEffect): string;
    unitFromJSON(object: any): Unit;
    unitToJSON(object: Unit): string;
} = ...