juno-network 0.0.2

package/types/codegen/cosmos/lcd.d.ts

@@ -0,0 +1,49 @@
+export declare const createLCDClient: ({ restEndpoint }: {
+    restEndpoint: any;
+}) => Promise<{
+    cosmos: {
+        auth: {
+            v1beta1: import("./auth/v1beta1/query.lcd").LCDQueryClient;
+        };
+        authz: {
+            v1beta1: import("./authz/v1beta1/query.lcd").LCDQueryClient;
+        };
+        bank: {
+            v1beta1: import("./bank/v1beta1/query.lcd").LCDQueryClient;
+        };
+        distribution: {
+            v1beta1: import("./distribution/v1beta1/query.lcd").LCDQueryClient;
+        };
+        evidence: {
+            v1beta1: import("./evidence/v1beta1/query.lcd").LCDQueryClient;
+        };
+        feegrant: {
+            v1beta1: import("./feegrant/v1beta1/query.lcd").LCDQueryClient;
+        };
+        gov: {
+            v1: import("./gov/v1/query.lcd").LCDQueryClient;
+            v1beta1: import("./gov/v1beta1/query.lcd").LCDQueryClient;
+        };
+        group: {
+            v1: import("./group/v1/query.lcd").LCDQueryClient;
+        };
+        mint: {
+            v1beta1: import("./mint/v1beta1/query.lcd").LCDQueryClient;
+        };
+        nft: {
+            v1beta1: import("./nft/v1beta1/query.lcd").LCDQueryClient;
+        };
+        params: {
+            v1beta1: import("./params/v1beta1/query.lcd").LCDQueryClient;
+        };
+        slashing: {
+            v1beta1: import("./slashing/v1beta1/query.lcd").LCDQueryClient;
+        };
+        staking: {
+            v1beta1: import("./staking/v1beta1/query.lcd").LCDQueryClient;
+        };
+        upgrade: {
+            v1beta1: import("./upgrade/v1beta1/query.lcd").LCDQueryClient;
+        };
+    };
+}>;

package/types/codegen/cosmos/mint/v1beta1/genesis.d.ts

@@ -0,0 +1,17 @@
+import { Minter, Params } from "./mint";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the mint module's genesis state. */
+export interface GenesisState {
+    /** minter is a space for holding current inflation information. */
+    minter: Minter;
+    /** params defines all the paramaters of the module. */
+    params: Params;
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};

package/types/codegen/cosmos/mint/v1beta1/mint.d.ts

@@ -0,0 +1,38 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "@osmonauts/helpers";
+/** Minter represents the minting state. */
+export interface Minter {
+    /** current annual inflation rate */
+    inflation: string;
+    /** current annual expected provisions */
+    annualProvisions: string;
+}
+/** Params holds parameters for the mint module. */
+export interface Params {
+    /** type of coin to mint */
+    mintDenom: string;
+    /** maximum annual change in inflation rate */
+    inflationRateChange: string;
+    /** maximum inflation rate */
+    inflationMax: string;
+    /** minimum inflation rate */
+    inflationMin: string;
+    /** goal of percent bonded atoms */
+    goalBonded: string;
+    /** expected blocks per year */
+    blocksPerYear: Long;
+}
+export declare const Minter: {
+    encode(message: Minter, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Minter;
+    fromJSON(object: any): Minter;
+    toJSON(message: Minter): unknown;
+    fromPartial(object: DeepPartial<Minter>): Minter;
+};
+export declare const Params: {
+    encode(message: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
+    fromJSON(object: any): Params;
+    toJSON(message: Params): unknown;
+    fromPartial(object: DeepPartial<Params>): Params;
+};

package/types/codegen/cosmos/mint/v1beta1/query.d.ts

@@ -0,0 +1,78 @@
+import { Params } from "./mint";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params: Params;
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequest {
+}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponse {
+    /** inflation is the current minting inflation value. */
+    inflation: Uint8Array;
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequest {
+}
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsResponse {
+    /** annual_provisions is the current minting annual provisions value. */
+    annualProvisions: Uint8Array;
+}
+export declare const QueryParamsRequest: {
+    encode(_: QueryParamsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest;
+    fromJSON(_: any): QueryParamsRequest;
+    toJSON(_: QueryParamsRequest): unknown;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+};
+export declare const QueryParamsResponse: {
+    encode(message: QueryParamsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse;
+    fromJSON(object: any): QueryParamsResponse;
+    toJSON(message: QueryParamsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+};
+export declare const QueryInflationRequest: {
+    encode(_: QueryInflationRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryInflationRequest;
+    fromJSON(_: any): QueryInflationRequest;
+    toJSON(_: QueryInflationRequest): unknown;
+    fromPartial(_: DeepPartial<QueryInflationRequest>): QueryInflationRequest;
+};
+export declare const QueryInflationResponse: {
+    encode(message: QueryInflationResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryInflationResponse;
+    fromJSON(object: any): QueryInflationResponse;
+    toJSON(message: QueryInflationResponse): unknown;
+    fromPartial(object: DeepPartial<QueryInflationResponse>): QueryInflationResponse;
+};
+export declare const QueryAnnualProvisionsRequest: {
+    encode(_: QueryAnnualProvisionsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAnnualProvisionsRequest;
+    fromJSON(_: any): QueryAnnualProvisionsRequest;
+    toJSON(_: QueryAnnualProvisionsRequest): unknown;
+    fromPartial(_: DeepPartial<QueryAnnualProvisionsRequest>): QueryAnnualProvisionsRequest;
+};
+export declare const QueryAnnualProvisionsResponse: {
+    encode(message: QueryAnnualProvisionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAnnualProvisionsResponse;
+    fromJSON(object: any): QueryAnnualProvisionsResponse;
+    toJSON(message: QueryAnnualProvisionsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryAnnualProvisionsResponse>): QueryAnnualProvisionsResponse;
+};

package/types/codegen/cosmos/mint/v1beta1/query.lcd.d.ts

@@ -0,0 +1,10 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryInflationRequest, QueryInflationResponse, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse } from "./query";
+export declare class LCDQueryClient extends LCDClient {
+    constructor({ restEndpoint }: {
+        restEndpoint: any;
+    });
+    params(params: QueryParamsRequest): Promise<QueryParamsResponse>;
+    inflation(params: QueryInflationRequest): Promise<QueryInflationResponse>;
+    annualProvisions(params: QueryAnnualProvisionsRequest): Promise<QueryAnnualProvisionsResponse>;
+}

package/types/codegen/cosmos/mint/v1beta1/query.rpc.query.d.ts

@@ -0,0 +1,15 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryParamsRequest, QueryParamsResponse, QueryInflationRequest, QueryInflationResponse, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    inflation(request: QueryInflationRequest): Promise<QueryInflationResponse>;
+    annualProvisions(request: QueryAnnualProvisionsRequest): Promise<QueryAnnualProvisionsResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    inflation(request: QueryInflationRequest): Promise<QueryInflationResponse>;
+    annualProvisions(request: QueryAnnualProvisionsRequest): Promise<QueryAnnualProvisionsResponse>;
+}

package/types/codegen/cosmos/msg/v1/msg.d.ts

@@ -0,0 +1 @@
+export {};

package/types/codegen/cosmos/nft/v1beta1/event.d.ts

@@ -0,0 +1,42 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** EventSend is emitted on Msg/Send */
+export interface EventSend {
+    classId: string;
+    id: string;
+    sender: string;
+    receiver: string;
+}
+/** EventMint is emitted on Mint */
+export interface EventMint {
+    classId: string;
+    id: string;
+    owner: string;
+}
+/** EventBurn is emitted on Burn */
+export interface EventBurn {
+    classId: string;
+    id: string;
+    owner: string;
+}
+export declare const EventSend: {
+    encode(message: EventSend, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventSend;
+    fromJSON(object: any): EventSend;
+    toJSON(message: EventSend): unknown;
+    fromPartial(object: DeepPartial<EventSend>): EventSend;
+};
+export declare const EventMint: {
+    encode(message: EventMint, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventMint;
+    fromJSON(object: any): EventMint;
+    toJSON(message: EventMint): unknown;
+    fromPartial(object: DeepPartial<EventMint>): EventMint;
+};
+export declare const EventBurn: {
+    encode(message: EventBurn, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventBurn;
+    fromJSON(object: any): EventBurn;
+    toJSON(message: EventBurn): unknown;
+    fromPartial(object: DeepPartial<EventBurn>): EventBurn;
+};

package/types/codegen/cosmos/nft/v1beta1/genesis.d.ts

@@ -0,0 +1,30 @@
+import { Class, NFT } from "./nft";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the nft module's genesis state. */
+export interface GenesisState {
+    /** class defines the class of the nft type. */
+    classes: Class[];
+    entries: Entry[];
+}
+/** Entry Defines all nft owned by a person */
+export interface Entry {
+    /** owner is the owner address of the following nft */
+    owner: string;
+    /** nfts is a group of nfts of the same owner */
+    nfts: NFT[];
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};
+export declare const Entry: {
+    encode(message: Entry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Entry;
+    fromJSON(object: any): Entry;
+    toJSON(message: Entry): unknown;
+    fromPartial(object: DeepPartial<Entry>): Entry;
+};

package/types/codegen/cosmos/nft/v1beta1/nft.d.ts

@@ -0,0 +1,47 @@
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** Class defines the class of the nft type. */
+export interface Class {
+    /** id defines the unique identifier of the NFT classification, similar to the contract address of ERC721 */
+    id: string;
+    /** name defines the human-readable name of the NFT classification. Optional */
+    name: string;
+    /** symbol is an abbreviated name for nft classification. Optional */
+    symbol: string;
+    /** description is a brief description of nft classification. Optional */
+    description: string;
+    /** uri for the class metadata stored off chain. It can define schema for Class and NFT `Data` attributes. Optional */
+    uri: string;
+    /** uri_hash is a hash of the document pointed by uri. Optional */
+    uriHash: string;
+    /** data is the app specific metadata of the NFT class. Optional */
+    data: Any;
+}
+/** NFT defines the NFT. */
+export interface NFT {
+    /** class_id associated with the NFT, similar to the contract address of ERC721 */
+    classId: string;
+    /** id is a unique identifier of the NFT */
+    id: string;
+    /** uri for the NFT metadata stored off chain */
+    uri: string;
+    /** uri_hash is a hash of the document pointed by uri */
+    uriHash: string;
+    /** data is an app specific data of the NFT. Optional */
+    data: Any;
+}
+export declare const Class: {
+    encode(message: Class, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Class;
+    fromJSON(object: any): Class;
+    toJSON(message: Class): unknown;
+    fromPartial(object: DeepPartial<Class>): Class;
+};
+export declare const NFT: {
+    encode(message: NFT, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): NFT;
+    fromJSON(object: any): NFT;
+    toJSON(message: NFT): unknown;
+    fromPartial(object: DeepPartial<NFT>): NFT;
+};

package/types/codegen/cosmos/nft/v1beta1/query.d.ts

@@ -0,0 +1,166 @@
+import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
+import { NFT, Class } from "./nft";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "@osmonauts/helpers";
+/** QueryBalanceRequest is the request type for the Query/Balance RPC method */
+export interface QueryBalanceRequest {
+    classId: string;
+    owner: string;
+}
+/** QueryBalanceResponse is the response type for the Query/Balance RPC method */
+export interface QueryBalanceResponse {
+    amount: Long;
+}
+/** QueryOwnerRequest is the request type for the Query/Owner RPC method */
+export interface QueryOwnerRequest {
+    classId: string;
+    id: string;
+}
+/** QueryOwnerResponse is the response type for the Query/Owner RPC method */
+export interface QueryOwnerResponse {
+    owner: string;
+}
+/** QuerySupplyRequest is the request type for the Query/Supply RPC method */
+export interface QuerySupplyRequest {
+    classId: string;
+}
+/** QuerySupplyResponse is the response type for the Query/Supply RPC method */
+export interface QuerySupplyResponse {
+    amount: Long;
+}
+/** QueryNFTstRequest is the request type for the Query/NFTs RPC method */
+export interface QueryNFTsRequest {
+    classId: string;
+    owner: string;
+    pagination: PageRequest;
+}
+/** QueryNFTsResponse is the response type for the Query/NFTs RPC methods */
+export interface QueryNFTsResponse {
+    nfts: NFT[];
+    pagination: PageResponse;
+}
+/** QueryNFTRequest is the request type for the Query/NFT RPC method */
+export interface QueryNFTRequest {
+    classId: string;
+    id: string;
+}
+/** QueryNFTResponse is the response type for the Query/NFT RPC method */
+export interface QueryNFTResponse {
+    nft: NFT;
+}
+/** QueryClassRequest is the request type for the Query/Class RPC method */
+export interface QueryClassRequest {
+    classId: string;
+}
+/** QueryClassResponse is the response type for the Query/Class RPC method */
+export interface QueryClassResponse {
+    class: Class;
+}
+/** QueryClassesRequest is the request type for the Query/Classes RPC method */
+export interface QueryClassesRequest {
+    /** pagination defines an optional pagination for the request. */
+    pagination: PageRequest;
+}
+/** QueryClassesResponse is the response type for the Query/Classes RPC method */
+export interface QueryClassesResponse {
+    classes: Class[];
+    pagination: PageResponse;
+}
+export declare const QueryBalanceRequest: {
+    encode(message: QueryBalanceRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryBalanceRequest;
+    fromJSON(object: any): QueryBalanceRequest;
+    toJSON(message: QueryBalanceRequest): unknown;
+    fromPartial(object: DeepPartial<QueryBalanceRequest>): QueryBalanceRequest;
+};
+export declare const QueryBalanceResponse: {
+    encode(message: QueryBalanceResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryBalanceResponse;
+    fromJSON(object: any): QueryBalanceResponse;
+    toJSON(message: QueryBalanceResponse): unknown;
+    fromPartial(object: DeepPartial<QueryBalanceResponse>): QueryBalanceResponse;
+};
+export declare const QueryOwnerRequest: {
+    encode(message: QueryOwnerRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryOwnerRequest;
+    fromJSON(object: any): QueryOwnerRequest;
+    toJSON(message: QueryOwnerRequest): unknown;
+    fromPartial(object: DeepPartial<QueryOwnerRequest>): QueryOwnerRequest;
+};
+export declare const QueryOwnerResponse: {
+    encode(message: QueryOwnerResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryOwnerResponse;
+    fromJSON(object: any): QueryOwnerResponse;
+    toJSON(message: QueryOwnerResponse): unknown;
+    fromPartial(object: DeepPartial<QueryOwnerResponse>): QueryOwnerResponse;
+};
+export declare const QuerySupplyRequest: {
+    encode(message: QuerySupplyRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QuerySupplyRequest;
+    fromJSON(object: any): QuerySupplyRequest;
+    toJSON(message: QuerySupplyRequest): unknown;
+    fromPartial(object: DeepPartial<QuerySupplyRequest>): QuerySupplyRequest;
+};
+export declare const QuerySupplyResponse: {
+    encode(message: QuerySupplyResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QuerySupplyResponse;
+    fromJSON(object: any): QuerySupplyResponse;
+    toJSON(message: QuerySupplyResponse): unknown;
+    fromPartial(object: DeepPartial<QuerySupplyResponse>): QuerySupplyResponse;
+};
+export declare const QueryNFTsRequest: {
+    encode(message: QueryNFTsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryNFTsRequest;
+    fromJSON(object: any): QueryNFTsRequest;
+    toJSON(message: QueryNFTsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryNFTsRequest>): QueryNFTsRequest;
+};
+export declare const QueryNFTsResponse: {
+    encode(message: QueryNFTsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryNFTsResponse;
+    fromJSON(object: any): QueryNFTsResponse;
+    toJSON(message: QueryNFTsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryNFTsResponse>): QueryNFTsResponse;
+};
+export declare const QueryNFTRequest: {
+    encode(message: QueryNFTRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryNFTRequest;
+    fromJSON(object: any): QueryNFTRequest;
+    toJSON(message: QueryNFTRequest): unknown;
+    fromPartial(object: DeepPartial<QueryNFTRequest>): QueryNFTRequest;
+};
+export declare const QueryNFTResponse: {
+    encode(message: QueryNFTResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryNFTResponse;
+    fromJSON(object: any): QueryNFTResponse;
+    toJSON(message: QueryNFTResponse): unknown;
+    fromPartial(object: DeepPartial<QueryNFTResponse>): QueryNFTResponse;
+};
+export declare const QueryClassRequest: {
+    encode(message: QueryClassRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClassRequest;
+    fromJSON(object: any): QueryClassRequest;
+    toJSON(message: QueryClassRequest): unknown;
+    fromPartial(object: DeepPartial<QueryClassRequest>): QueryClassRequest;
+};
+export declare const QueryClassResponse: {
+    encode(message: QueryClassResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClassResponse;
+    fromJSON(object: any): QueryClassResponse;
+    toJSON(message: QueryClassResponse): unknown;
+    fromPartial(object: DeepPartial<QueryClassResponse>): QueryClassResponse;
+};
+export declare const QueryClassesRequest: {
+    encode(message: QueryClassesRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClassesRequest;
+    fromJSON(object: any): QueryClassesRequest;
+    toJSON(message: QueryClassesRequest): unknown;
+    fromPartial(object: DeepPartial<QueryClassesRequest>): QueryClassesRequest;
+};
+export declare const QueryClassesResponse: {
+    encode(message: QueryClassesResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClassesResponse;
+    fromJSON(object: any): QueryClassesResponse;
+    toJSON(message: QueryClassesResponse): unknown;
+    fromPartial(object: DeepPartial<QueryClassesResponse>): QueryClassesResponse;
+};

package/types/codegen/cosmos/nft/v1beta1/query.lcd.d.ts

@@ -0,0 +1,14 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryBalanceRequest, QueryBalanceResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryNFTsRequest, QueryNFTsResponse, QueryNFTRequest, QueryNFTResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse } from "./query";
+export declare class LCDQueryClient extends LCDClient {
+    constructor({ restEndpoint }: {
+        restEndpoint: any;
+    });
+    balance(params: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+    owner(params: QueryOwnerRequest): Promise<QueryOwnerResponse>;
+    supply(params: QuerySupplyRequest): Promise<QuerySupplyResponse>;
+    nFTs(params: QueryNFTsRequest): Promise<QueryNFTsResponse>;
+    nFT(params: QueryNFTRequest): Promise<QueryNFTResponse>;
+    class(params: QueryClassRequest): Promise<QueryClassResponse>;
+    classes(params: QueryClassesRequest): Promise<QueryClassesResponse>;
+}

package/types/codegen/cosmos/nft/v1beta1/query.rpc.query.d.ts

@@ -0,0 +1,23 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryBalanceRequest, QueryBalanceResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryNFTsRequest, QueryNFTsResponse, QueryNFTRequest, QueryNFTResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+    owner(request: QueryOwnerRequest): Promise<QueryOwnerResponse>;
+    supply(request: QuerySupplyRequest): Promise<QuerySupplyResponse>;
+    nFTs(request: QueryNFTsRequest): Promise<QueryNFTsResponse>;
+    nFT(request: QueryNFTRequest): Promise<QueryNFTResponse>;
+    class(request: QueryClassRequest): Promise<QueryClassResponse>;
+    classes(request: QueryClassesRequest): Promise<QueryClassesResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+    owner(request: QueryOwnerRequest): Promise<QueryOwnerResponse>;
+    supply(request: QuerySupplyRequest): Promise<QuerySupplyResponse>;
+    nFTs(request: QueryNFTsRequest): Promise<QueryNFTsResponse>;
+    nFT(request: QueryNFTRequest): Promise<QueryNFTResponse>;
+    class(request: QueryClassRequest): Promise<QueryClassResponse>;
+    classes(request: QueryClassesRequest): Promise<QueryClassesResponse>;
+}

package/types/codegen/cosmos/nft/v1beta1/tx.amino.d.ts

@@ -0,0 +1,18 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { MsgSend } from "./tx";
+export interface AminoMsgSend extends AminoMsg {
+    type: "cosmos-sdk/MsgNFTSend";
+    value: {
+        class_id: string;
+        id: string;
+        sender: string;
+        receiver: string;
+    };
+}
+export declare const AminoConverter: {
+    "/cosmos.nft.v1beta1.MsgSend": {
+        aminoType: string;
+        toAmino: ({ classId, id, sender, receiver }: MsgSend) => AminoMsgSend["value"];
+        fromAmino: ({ class_id, id, sender, receiver }: AminoMsgSend["value"]) => MsgSend;
+    };
+};

package/types/codegen/cosmos/nft/v1beta1/tx.d.ts

@@ -0,0 +1,30 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** MsgSend represents a message to send a nft from one account to another account. */
+export interface MsgSend {
+    /** class_id defines the unique identifier of the nft classification, similar to the contract address of ERC721 */
+    classId: string;
+    /** id defines the unique identification of nft */
+    id: string;
+    /** sender is the address of the owner of nft */
+    sender: string;
+    /** receiver is the receiver address of nft */
+    receiver: string;
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponse {
+}
+export declare const MsgSend: {
+    encode(message: MsgSend, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSend;
+    fromJSON(object: any): MsgSend;
+    toJSON(message: MsgSend): unknown;
+    fromPartial(object: DeepPartial<MsgSend>): MsgSend;
+};
+export declare const MsgSendResponse: {
+    encode(_: MsgSendResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendResponse;
+    fromJSON(_: any): MsgSendResponse;
+    toJSON(_: MsgSendResponse): unknown;
+    fromPartial(_: DeepPartial<MsgSendResponse>): MsgSendResponse;
+};

package/types/codegen/cosmos/nft/v1beta1/tx.registry.d.ts

@@ -0,0 +1,36 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgSend } from "./tx";
+export declare const registry: ReadonlyArray<[string, GeneratedType]>;
+export declare const load: (protoRegistry: Registry) => void;
+export declare const MessageComposer: {
+    encoded: {
+        send(value: MsgSend): {
+            typeUrl: string;
+            value: Uint8Array;
+        };
+    };
+    withTypeUrl: {
+        send(value: MsgSend): {
+            typeUrl: string;
+            value: MsgSend;
+        };
+    };
+    toJSON: {
+        send(value: MsgSend): {
+            typeUrl: string;
+            value: unknown;
+        };
+    };
+    fromJSON: {
+        send(value: any): {
+            typeUrl: string;
+            value: MsgSend;
+        };
+    };
+    fromPartial: {
+        send(value: MsgSend): {
+            typeUrl: string;
+            value: MsgSend;
+        };
+    };
+};

package/types/codegen/cosmos/nft/v1beta1/tx.rpc.msg.d.ts

@@ -0,0 +1,11 @@
+import { Rpc } from "@osmonauts/helpers";
+import { MsgSend, MsgSendResponse } from "./tx";
+/** Msg defines the RPC service */
+export interface Msg {
+    send(request: MsgSend): Promise<MsgSendResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    send(request: MsgSend): Promise<MsgSendResponse>;
+}