injectivejs 0.1.0 → 0.2.0

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

@@ -0,0 +1,99 @@
+import { Params, ParamsSDKType } 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 {
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestSDKType {
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params: Params;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseSDKType {
+    /** params defines the parameters of the module. */
+    params: ParamsSDKType;
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequest {
+}
+/** QueryInflationRequest is the request type for the Query/Inflation RPC method. */
+export interface QueryInflationRequestSDKType {
+}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponse {
+    /** inflation is the current minting inflation value. */
+    inflation: Uint8Array;
+}
+/**
+ * QueryInflationResponse is the response type for the Query/Inflation RPC
+ * method.
+ */
+export interface QueryInflationResponseSDKType {
+    /** inflation is the current minting inflation value. */
+    inflation: Uint8Array;
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequest {
+}
+/**
+ * QueryAnnualProvisionsRequest is the request type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsRequestSDKType {
+}
+/**
+ * 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;
+}
+/**
+ * QueryAnnualProvisionsResponse is the response type for the
+ * Query/AnnualProvisions RPC method.
+ */
+export interface QueryAnnualProvisionsResponseSDKType {
+    /** annual_provisions is the current minting annual provisions value. */
+    annual_provisions: Uint8Array;
+}
+export declare const QueryParamsRequest: {
+    encode(_: QueryParamsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+};
+export declare const QueryParamsResponse: {
+    encode(message: QueryParamsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+};
+export declare const QueryInflationRequest: {
+    encode(_: QueryInflationRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryInflationRequest;
+    fromPartial(_: DeepPartial<QueryInflationRequest>): QueryInflationRequest;
+};
+export declare const QueryInflationResponse: {
+    encode(message: QueryInflationResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryInflationResponse;
+    fromPartial(object: DeepPartial<QueryInflationResponse>): QueryInflationResponse;
+};
+export declare const QueryAnnualProvisionsRequest: {
+    encode(_: QueryAnnualProvisionsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAnnualProvisionsRequest;
+    fromPartial(_: DeepPartial<QueryAnnualProvisionsRequest>): QueryAnnualProvisionsRequest;
+};
+export declare const QueryAnnualProvisionsResponse: {
+    encode(message: QueryAnnualProvisionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAnnualProvisionsResponse;
+    fromPartial(object: DeepPartial<QueryAnnualProvisionsResponse>): QueryAnnualProvisionsResponse;
+};

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

@@ -0,0 +1,11 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryParamsRequest, QueryParamsResponseSDKType, QueryInflationRequest, QueryInflationResponseSDKType, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponseSDKType } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params(_params?: QueryParamsRequest): Promise<QueryParamsResponseSDKType>;
+    inflation(_params?: QueryInflationRequest): Promise<QueryInflationResponseSDKType>;
+    annualProvisions(_params?: QueryAnnualProvisionsRequest): Promise<QueryAnnualProvisionsResponseSDKType>;
+}

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

@@ -0,0 +1,21 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryClient } from "@cosmjs/stargate";
+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>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    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,55 @@
+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;
+}
+/** EventSend is emitted on Msg/Send */
+export interface EventSendSDKType {
+    class_id: string;
+    id: string;
+    sender: string;
+    receiver: string;
+}
+/** EventMint is emitted on Mint */
+export interface EventMint {
+    classId: string;
+    id: string;
+    owner: string;
+}
+/** EventMint is emitted on Mint */
+export interface EventMintSDKType {
+    class_id: string;
+    id: string;
+    owner: string;
+}
+/** EventBurn is emitted on Burn */
+export interface EventBurn {
+    classId: string;
+    id: string;
+    owner: string;
+}
+/** EventBurn is emitted on Burn */
+export interface EventBurnSDKType {
+    class_id: 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;
+    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;
+    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;
+    fromPartial(object: DeepPartial<EventBurn>): EventBurn;
+};

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

@@ -0,0 +1,39 @@
+import { Class, ClassSDKType, NFT, NFTSDKType } 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[];
+}
+/** GenesisState defines the nft module's genesis state. */
+export interface GenesisStateSDKType {
+    /** class defines the class of the nft type. */
+    classes: ClassSDKType[];
+    entries: EntrySDKType[];
+}
+/** 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[];
+}
+/** Entry Defines all nft owned by a person */
+export interface EntrySDKType {
+    /** owner is the owner address of the following nft */
+    owner: string;
+    /** nfts is a group of nfts of the same owner */
+    nfts: NFTSDKType[];
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    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;
+    fromPartial(object: DeepPartial<Entry>): Entry;
+};

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

@@ -0,0 +1,73 @@
+import { Any, AnySDKType } 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;
+}
+/** Class defines the class of the nft type. */
+export interface ClassSDKType {
+    /** 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 */
+    uri_hash: string;
+    /** data is the app specific metadata of the NFT class. Optional */
+    data: AnySDKType;
+}
+/** 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;
+}
+/** NFT defines the NFT. */
+export interface NFTSDKType {
+    /** class_id associated with the NFT, similar to the contract address of ERC721 */
+    class_id: 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 */
+    uri_hash: string;
+    /** data is an app specific data of the NFT. Optional */
+    data: AnySDKType;
+}
+export declare const Class: {
+    encode(message: Class, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Class;
+    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;
+    fromPartial(object: DeepPartial<NFT>): NFT;
+};

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

@@ -0,0 +1,202 @@
+import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../base/query/v1beta1/pagination";
+import { NFT, NFTSDKType, Class, ClassSDKType } 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;
+}
+/** QueryBalanceRequest is the request type for the Query/Balance RPC method */
+export interface QueryBalanceRequestSDKType {
+    class_id: string;
+    owner: string;
+}
+/** QueryBalanceResponse is the response type for the Query/Balance RPC method */
+export interface QueryBalanceResponse {
+    amount: Long;
+}
+/** QueryBalanceResponse is the response type for the Query/Balance RPC method */
+export interface QueryBalanceResponseSDKType {
+    amount: Long;
+}
+/** QueryOwnerRequest is the request type for the Query/Owner RPC method */
+export interface QueryOwnerRequest {
+    classId: string;
+    id: string;
+}
+/** QueryOwnerRequest is the request type for the Query/Owner RPC method */
+export interface QueryOwnerRequestSDKType {
+    class_id: string;
+    id: string;
+}
+/** QueryOwnerResponse is the response type for the Query/Owner RPC method */
+export interface QueryOwnerResponse {
+    owner: string;
+}
+/** QueryOwnerResponse is the response type for the Query/Owner RPC method */
+export interface QueryOwnerResponseSDKType {
+    owner: string;
+}
+/** QuerySupplyRequest is the request type for the Query/Supply RPC method */
+export interface QuerySupplyRequest {
+    classId: string;
+}
+/** QuerySupplyRequest is the request type for the Query/Supply RPC method */
+export interface QuerySupplyRequestSDKType {
+    class_id: string;
+}
+/** QuerySupplyResponse is the response type for the Query/Supply RPC method */
+export interface QuerySupplyResponse {
+    amount: Long;
+}
+/** QuerySupplyResponse is the response type for the Query/Supply RPC method */
+export interface QuerySupplyResponseSDKType {
+    amount: Long;
+}
+/** QueryNFTstRequest is the request type for the Query/NFTs RPC method */
+export interface QueryNFTsRequest {
+    classId?: string;
+    owner?: string;
+    pagination?: PageRequest;
+}
+/** QueryNFTstRequest is the request type for the Query/NFTs RPC method */
+export interface QueryNFTsRequestSDKType {
+    class_id?: string;
+    owner?: string;
+    pagination?: PageRequestSDKType;
+}
+/** QueryNFTsResponse is the response type for the Query/NFTs RPC methods */
+export interface QueryNFTsResponse {
+    nfts: NFT[];
+    pagination?: PageResponse;
+}
+/** QueryNFTsResponse is the response type for the Query/NFTs RPC methods */
+export interface QueryNFTsResponseSDKType {
+    nfts: NFTSDKType[];
+    pagination?: PageResponseSDKType;
+}
+/** QueryNFTRequest is the request type for the Query/NFT RPC method */
+export interface QueryNFTRequest {
+    classId: string;
+    id: string;
+}
+/** QueryNFTRequest is the request type for the Query/NFT RPC method */
+export interface QueryNFTRequestSDKType {
+    class_id: string;
+    id: string;
+}
+/** QueryNFTResponse is the response type for the Query/NFT RPC method */
+export interface QueryNFTResponse {
+    nft: NFT;
+}
+/** QueryNFTResponse is the response type for the Query/NFT RPC method */
+export interface QueryNFTResponseSDKType {
+    nft: NFTSDKType;
+}
+/** QueryClassRequest is the request type for the Query/Class RPC method */
+export interface QueryClassRequest {
+    classId: string;
+}
+/** QueryClassRequest is the request type for the Query/Class RPC method */
+export interface QueryClassRequestSDKType {
+    class_id: string;
+}
+/** QueryClassResponse is the response type for the Query/Class RPC method */
+export interface QueryClassResponse {
+    class: Class;
+}
+/** QueryClassResponse is the response type for the Query/Class RPC method */
+export interface QueryClassResponseSDKType {
+    class: ClassSDKType;
+}
+/** QueryClassesRequest is the request type for the Query/Classes RPC method */
+export interface QueryClassesRequest {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequest;
+}
+/** QueryClassesRequest is the request type for the Query/Classes RPC method */
+export interface QueryClassesRequestSDKType {
+    /** pagination defines an optional pagination for the request. */
+    pagination?: PageRequestSDKType;
+}
+/** QueryClassesResponse is the response type for the Query/Classes RPC method */
+export interface QueryClassesResponse {
+    classes: Class[];
+    pagination?: PageResponse;
+}
+/** QueryClassesResponse is the response type for the Query/Classes RPC method */
+export interface QueryClassesResponseSDKType {
+    classes: ClassSDKType[];
+    pagination?: PageResponseSDKType;
+}
+export declare const QueryBalanceRequest: {
+    encode(message: QueryBalanceRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryBalanceRequest;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    fromPartial(object: DeepPartial<QueryClassesResponse>): QueryClassesResponse;
+};

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

@@ -0,0 +1,15 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryBalanceRequest, QueryBalanceResponseSDKType, QueryOwnerRequest, QueryOwnerResponseSDKType, QuerySupplyRequest, QuerySupplyResponseSDKType, QueryNFTsRequest, QueryNFTsResponseSDKType, QueryNFTRequest, QueryNFTResponseSDKType, QueryClassRequest, QueryClassResponseSDKType, QueryClassesRequest, QueryClassesResponseSDKType } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    balance(params: QueryBalanceRequest): Promise<QueryBalanceResponseSDKType>;
+    owner(params: QueryOwnerRequest): Promise<QueryOwnerResponseSDKType>;
+    supply(params: QuerySupplyRequest): Promise<QuerySupplyResponseSDKType>;
+    nFTs(params: QueryNFTsRequest): Promise<QueryNFTsResponseSDKType>;
+    nFT(params: QueryNFTRequest): Promise<QueryNFTResponseSDKType>;
+    class(params: QueryClassRequest): Promise<QueryClassResponseSDKType>;
+    classes(params?: QueryClassesRequest): Promise<QueryClassesResponseSDKType>;
+}

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

@@ -0,0 +1,33 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryClient } from "@cosmjs/stargate";
+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>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    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,40 @@
+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;
+}
+/** MsgSend represents a message to send a nft from one account to another account. */
+export interface MsgSendSDKType {
+    /** class_id defines the unique identifier of the nft classification, similar to the contract address of ERC721 */
+    class_id: 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 {
+}
+/** MsgSendResponse defines the Msg/Send response type. */
+export interface MsgSendResponseSDKType {
+}
+export declare const MsgSend: {
+    encode(message: MsgSend, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSend;
+    fromPartial(object: DeepPartial<MsgSend>): MsgSend;
+};
+export declare const MsgSendResponse: {
+    encode(_: MsgSendResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendResponse;
+    fromPartial(_: DeepPartial<MsgSendResponse>): MsgSendResponse;
+};

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

@@ -0,0 +1,24 @@
+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;
+        };
+    };
+    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>;
+}