juno-network 0.0.2

package/types/codegen/cosmos/app/v1alpha1/module.d.ts

@@ -0,0 +1,105 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** ModuleDescriptor describes an app module. */
+export interface ModuleDescriptor {
+    /**
+     * go_import names the package that should be imported by an app to load the
+     * module in the runtime module registry. Either go_import must be defined here
+     * or the go_package option must be defined at the file level to indicate
+     * to users where to location the module implementation. go_import takes
+     * precedence over go_package when both are defined.
+     */
+    goImport: string;
+    /**
+     * use_package refers to a protobuf package that this module
+     * uses and exposes to the world. In an app, only one module should "use"
+     * or own a single protobuf package. It is assumed that the module uses
+     * all of the .proto files in a single package.
+     */
+    usePackage: PackageReference[];
+    /**
+     * can_migrate_from defines which module versions this module can migrate
+     * state from. The framework will check that one module version is able to
+     * migrate from a previous module version before attempting to update its
+     * config. It is assumed that modules can transitively migrate from earlier
+     * versions. For instance if v3 declares it can migrate from v2, and v2
+     * declares it can migrate from v1, the framework knows how to migrate
+     * from v1 to v3, assuming all 3 module versions are registered at runtime.
+     */
+    canMigrateFrom: MigrateFromInfo[];
+}
+/** PackageReference is a reference to a protobuf package used by a module. */
+export interface PackageReference {
+    /** name is the fully-qualified name of the package. */
+    name: string;
+    /**
+     * revision is the optional revision of the package that is being used.
+     * Protobuf packages used in Cosmos should generally have a major version
+     * as the last part of the package name, ex. foo.bar.baz.v1.
+     * The revision of a package can be thought of as the minor version of a
+     * package which has additional backwards compatible definitions that weren't
+     * present in a previous version.
+     *
+     * A package should indicate its revision with a source code comment
+     * above the package declaration in one of its fields containing the
+     * test "Revision N" where N is an integer revision. All packages start
+     * at revision 0 the first time they are released in a module.
+     *
+     * When a new version of a module is released and items are added to existing
+     * .proto files, these definitions should contain comments of the form
+     * "Since Revision N" where N is an integer revision.
+     *
+     * When the module runtime starts up, it will check the pinned proto
+     * image and panic if there are runtime protobuf definitions that are not
+     * in the pinned descriptor which do not have
+     * a "Since Revision N" comment or have a "Since Revision N" comment where
+     * N is <= to the revision specified here. This indicates that the protobuf
+     * files have been updated, but the pinned file descriptor hasn't.
+     *
+     * If there are items in the pinned file descriptor with a revision
+     * greater than the value indicated here, this will also cause a panic
+     * as it may mean that the pinned descriptor for a legacy module has been
+     * improperly updated or that there is some other versioning discrepancy.
+     * Runtime protobuf definitions will also be checked for compatibility
+     * with pinned file descriptors to make sure there are no incompatible changes.
+     *
+     * This behavior ensures that:
+     * * pinned proto images are up-to-date
+     * * protobuf files are carefully annotated with revision comments which
+     * are important good client UX
+     * * protobuf files are changed in backwards and forwards compatible ways
+     */
+    revision: number;
+}
+/**
+ * MigrateFromInfo is information on a module version that a newer module
+ * can migrate from.
+ */
+export interface MigrateFromInfo {
+    /**
+     * module is the fully-qualified protobuf name of the module config object
+     * for the previous module version, ex: "cosmos.group.module.v1.Module".
+     */
+    module: string;
+}
+export declare const ModuleDescriptor: {
+    encode(message: ModuleDescriptor, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ModuleDescriptor;
+    fromJSON(object: any): ModuleDescriptor;
+    toJSON(message: ModuleDescriptor): unknown;
+    fromPartial(object: DeepPartial<ModuleDescriptor>): ModuleDescriptor;
+};
+export declare const PackageReference: {
+    encode(message: PackageReference, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PackageReference;
+    fromJSON(object: any): PackageReference;
+    toJSON(message: PackageReference): unknown;
+    fromPartial(object: DeepPartial<PackageReference>): PackageReference;
+};
+export declare const MigrateFromInfo: {
+    encode(message: MigrateFromInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MigrateFromInfo;
+    fromJSON(object: any): MigrateFromInfo;
+    toJSON(message: MigrateFromInfo): unknown;
+    fromPartial(object: DeepPartial<MigrateFromInfo>): MigrateFromInfo;
+};

package/types/codegen/cosmos/app/v1alpha1/query.d.ts

@@ -0,0 +1,25 @@
+import { Config } from "./config";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** QueryConfigRequest is the Query/Config request type. */
+export interface QueryConfigRequest {
+}
+/** QueryConfigRequest is the Query/Config response type. */
+export interface QueryConfigResponse {
+    /** config is the current app config. */
+    config: Config;
+}
+export declare const QueryConfigRequest: {
+    encode(_: QueryConfigRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConfigRequest;
+    fromJSON(_: any): QueryConfigRequest;
+    toJSON(_: QueryConfigRequest): unknown;
+    fromPartial(_: DeepPartial<QueryConfigRequest>): QueryConfigRequest;
+};
+export declare const QueryConfigResponse: {
+    encode(message: QueryConfigResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConfigResponse;
+    fromJSON(object: any): QueryConfigResponse;
+    toJSON(message: QueryConfigResponse): unknown;
+    fromPartial(object: DeepPartial<QueryConfigResponse>): QueryConfigResponse;
+};

package/types/codegen/cosmos/app/v1alpha1/query.rpc.query.d.ts

@@ -0,0 +1,11 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryConfigRequest, QueryConfigResponse } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    config(request: QueryConfigRequest): Promise<QueryConfigResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    config(request: QueryConfigRequest): Promise<QueryConfigResponse>;
+}

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

@@ -0,0 +1,49 @@
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccount {
+    address: string;
+    pubKey: Any;
+    accountNumber: Long;
+    sequence: Long;
+}
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccount {
+    baseAccount: BaseAccount;
+    name: string;
+    permissions: string[];
+}
+/** Params defines the parameters for the auth module. */
+export interface Params {
+    maxMemoCharacters: Long;
+    txSigLimit: Long;
+    txSizeCostPerByte: Long;
+    sigVerifyCostEd25519: Long;
+    sigVerifyCostSecp256k1: Long;
+}
+export declare const BaseAccount: {
+    encode(message: BaseAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BaseAccount;
+    fromJSON(object: any): BaseAccount;
+    toJSON(message: BaseAccount): unknown;
+    fromPartial(object: DeepPartial<BaseAccount>): BaseAccount;
+};
+export declare const ModuleAccount: {
+    encode(message: ModuleAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ModuleAccount;
+    fromJSON(object: any): ModuleAccount;
+    toJSON(message: ModuleAccount): unknown;
+    fromPartial(object: DeepPartial<ModuleAccount>): ModuleAccount;
+};
+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/auth/v1beta1/genesis.d.ts

@@ -0,0 +1,18 @@
+import { Params } from "./auth";
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the auth module's genesis state. */
+export interface GenesisState {
+    /** params defines all the paramaters of the module. */
+    params: Params;
+    /** accounts are the accounts present at genesis. */
+    accounts: Any[];
+}
+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/auth/v1beta1/query.d.ts

@@ -0,0 +1,171 @@
+import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
+import { Any } from "../../../google/protobuf/any";
+import { Params } from "./auth";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * QueryAccountsRequest is the request type for the Query/Accounts RPC method.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsRequest {
+    /** pagination defines an optional pagination for the request. */
+    pagination: PageRequest;
+}
+/**
+ * QueryAccountsResponse is the response type for the Query/Accounts RPC method.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface QueryAccountsResponse {
+    /** accounts are the existing accounts */
+    accounts: Any[];
+    /** pagination defines the pagination in the response. */
+    pagination: PageResponse;
+}
+/** QueryAccountRequest is the request type for the Query/Account RPC method. */
+export interface QueryAccountRequest {
+    /** address defines the address to query for. */
+    address: string;
+}
+/** QueryModuleAccountsRequest is the request type for the Query/ModuleAccounts RPC method. */
+export interface QueryModuleAccountsRequest {
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params: Params;
+}
+/** QueryAccountResponse is the response type for the Query/Account RPC method. */
+export interface QueryAccountResponse {
+    /** account defines the account of the corresponding address. */
+    account: Any;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+/** QueryModuleAccountsResponse is the response type for the Query/ModuleAccounts RPC method. */
+export interface QueryModuleAccountsResponse {
+    accounts: Any[];
+}
+/** Bech32PrefixRequest is the request type for Bech32Prefix rpc method */
+export interface Bech32PrefixRequest {
+}
+/** Bech32PrefixResponse is the response type for Bech32Prefix rpc method */
+export interface Bech32PrefixResponse {
+    bech32Prefix: string;
+}
+/** AddressBytesToStringRequest is the request type for AddressString rpc method */
+export interface AddressBytesToStringRequest {
+    addressBytes: Uint8Array;
+}
+/** AddressBytesToStringResponse is the response type for AddressString rpc method */
+export interface AddressBytesToStringResponse {
+    addressString: string;
+}
+/** AddressStringToBytesRequest is the request type for AccountBytes rpc method */
+export interface AddressStringToBytesRequest {
+    addressString: string;
+}
+/** AddressStringToBytesResponse is the response type for AddressBytes rpc method */
+export interface AddressStringToBytesResponse {
+    addressBytes: Uint8Array;
+}
+export declare const QueryAccountsRequest: {
+    encode(message: QueryAccountsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountsRequest;
+    fromJSON(object: any): QueryAccountsRequest;
+    toJSON(message: QueryAccountsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryAccountsRequest>): QueryAccountsRequest;
+};
+export declare const QueryAccountsResponse: {
+    encode(message: QueryAccountsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountsResponse;
+    fromJSON(object: any): QueryAccountsResponse;
+    toJSON(message: QueryAccountsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryAccountsResponse>): QueryAccountsResponse;
+};
+export declare const QueryAccountRequest: {
+    encode(message: QueryAccountRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountRequest;
+    fromJSON(object: any): QueryAccountRequest;
+    toJSON(message: QueryAccountRequest): unknown;
+    fromPartial(object: DeepPartial<QueryAccountRequest>): QueryAccountRequest;
+};
+export declare const QueryModuleAccountsRequest: {
+    encode(_: QueryModuleAccountsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryModuleAccountsRequest;
+    fromJSON(_: any): QueryModuleAccountsRequest;
+    toJSON(_: QueryModuleAccountsRequest): unknown;
+    fromPartial(_: DeepPartial<QueryModuleAccountsRequest>): QueryModuleAccountsRequest;
+};
+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 QueryAccountResponse: {
+    encode(message: QueryAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountResponse;
+    fromJSON(object: any): QueryAccountResponse;
+    toJSON(message: QueryAccountResponse): unknown;
+    fromPartial(object: DeepPartial<QueryAccountResponse>): QueryAccountResponse;
+};
+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 QueryModuleAccountsResponse: {
+    encode(message: QueryModuleAccountsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryModuleAccountsResponse;
+    fromJSON(object: any): QueryModuleAccountsResponse;
+    toJSON(message: QueryModuleAccountsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryModuleAccountsResponse>): QueryModuleAccountsResponse;
+};
+export declare const Bech32PrefixRequest: {
+    encode(_: Bech32PrefixRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Bech32PrefixRequest;
+    fromJSON(_: any): Bech32PrefixRequest;
+    toJSON(_: Bech32PrefixRequest): unknown;
+    fromPartial(_: DeepPartial<Bech32PrefixRequest>): Bech32PrefixRequest;
+};
+export declare const Bech32PrefixResponse: {
+    encode(message: Bech32PrefixResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Bech32PrefixResponse;
+    fromJSON(object: any): Bech32PrefixResponse;
+    toJSON(message: Bech32PrefixResponse): unknown;
+    fromPartial(object: DeepPartial<Bech32PrefixResponse>): Bech32PrefixResponse;
+};
+export declare const AddressBytesToStringRequest: {
+    encode(message: AddressBytesToStringRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AddressBytesToStringRequest;
+    fromJSON(object: any): AddressBytesToStringRequest;
+    toJSON(message: AddressBytesToStringRequest): unknown;
+    fromPartial(object: DeepPartial<AddressBytesToStringRequest>): AddressBytesToStringRequest;
+};
+export declare const AddressBytesToStringResponse: {
+    encode(message: AddressBytesToStringResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AddressBytesToStringResponse;
+    fromJSON(object: any): AddressBytesToStringResponse;
+    toJSON(message: AddressBytesToStringResponse): unknown;
+    fromPartial(object: DeepPartial<AddressBytesToStringResponse>): AddressBytesToStringResponse;
+};
+export declare const AddressStringToBytesRequest: {
+    encode(message: AddressStringToBytesRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AddressStringToBytesRequest;
+    fromJSON(object: any): AddressStringToBytesRequest;
+    toJSON(message: AddressStringToBytesRequest): unknown;
+    fromPartial(object: DeepPartial<AddressStringToBytesRequest>): AddressStringToBytesRequest;
+};
+export declare const AddressStringToBytesResponse: {
+    encode(message: AddressStringToBytesResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AddressStringToBytesResponse;
+    fromJSON(object: any): AddressStringToBytesResponse;
+    toJSON(message: AddressStringToBytesResponse): unknown;
+    fromPartial(object: DeepPartial<AddressStringToBytesResponse>): AddressStringToBytesResponse;
+};

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

@@ -0,0 +1,14 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryAccountsRequest, QueryAccountsResponse, QueryAccountRequest, QueryAccountResponse, QueryParamsRequest, QueryParamsResponse, QueryModuleAccountsRequest, QueryModuleAccountsResponse, Bech32PrefixRequest, Bech32PrefixResponse, AddressBytesToStringRequest, AddressBytesToStringResponse, AddressStringToBytesRequest, AddressStringToBytesResponse } from "./query";
+export declare class LCDQueryClient extends LCDClient {
+    constructor({ restEndpoint }: {
+        restEndpoint: any;
+    });
+    accounts(params: QueryAccountsRequest): Promise<QueryAccountsResponse>;
+    account(params: QueryAccountRequest): Promise<QueryAccountResponse>;
+    params(params: QueryParamsRequest): Promise<QueryParamsResponse>;
+    moduleAccounts(params: QueryModuleAccountsRequest): Promise<QueryModuleAccountsResponse>;
+    bech32Prefix(params: Bech32PrefixRequest): Promise<Bech32PrefixResponse>;
+    addressBytesToString(params: AddressBytesToStringRequest): Promise<AddressBytesToStringResponse>;
+    addressStringToBytes(params: AddressStringToBytesRequest): Promise<AddressStringToBytesResponse>;
+}

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

@@ -0,0 +1,23 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryAccountsRequest, QueryAccountsResponse, QueryAccountRequest, QueryAccountResponse, QueryParamsRequest, QueryParamsResponse, QueryModuleAccountsRequest, QueryModuleAccountsResponse, Bech32PrefixRequest, Bech32PrefixResponse, AddressBytesToStringRequest, AddressBytesToStringResponse, AddressStringToBytesRequest, AddressStringToBytesResponse } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    accounts(request: QueryAccountsRequest): Promise<QueryAccountsResponse>;
+    account(request: QueryAccountRequest): Promise<QueryAccountResponse>;
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    moduleAccounts(request: QueryModuleAccountsRequest): Promise<QueryModuleAccountsResponse>;
+    bech32Prefix(request: Bech32PrefixRequest): Promise<Bech32PrefixResponse>;
+    addressBytesToString(request: AddressBytesToStringRequest): Promise<AddressBytesToStringResponse>;
+    addressStringToBytes(request: AddressStringToBytesRequest): Promise<AddressStringToBytesResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    accounts(request: QueryAccountsRequest): Promise<QueryAccountsResponse>;
+    account(request: QueryAccountRequest): Promise<QueryAccountResponse>;
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    moduleAccounts(request: QueryModuleAccountsRequest): Promise<QueryModuleAccountsResponse>;
+    bech32Prefix(request: Bech32PrefixRequest): Promise<Bech32PrefixResponse>;
+    addressBytesToString(request: AddressBytesToStringRequest): Promise<AddressBytesToStringResponse>;
+    addressStringToBytes(request: AddressStringToBytesRequest): Promise<AddressStringToBytesResponse>;
+}

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

@@ -0,0 +1,67 @@
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * GenericAuthorization gives the grantee unrestricted permissions to execute
+ * the provided method on behalf of the granter's account.
+ */
+export interface GenericAuthorization {
+    /** Msg, identified by it's type URL, to grant unrestricted permissions to execute */
+    msg: string;
+}
+/**
+ * Grant gives permissions to execute
+ * the provide method with expiration time.
+ */
+export interface Grant {
+    authorization: Any;
+    /**
+     * time when the grant will expire and will be pruned. If null, then the grant
+     * doesn't have a time expiration (other conditions  in `authorization`
+     * may apply to invalidate the grant)
+     */
+    expiration?: Date;
+}
+/**
+ * GrantAuthorization extends a grant with both the addresses of the grantee and granter.
+ * It is used in genesis.proto and query.proto
+ */
+export interface GrantAuthorization {
+    granter: string;
+    grantee: string;
+    authorization: Any;
+    expiration: Date;
+}
+/** GrantQueueItem contains the list of TypeURL of a sdk.Msg. */
+export interface GrantQueueItem {
+    /** msg_type_urls contains the list of TypeURL of a sdk.Msg. */
+    msgTypeUrls: string[];
+}
+export declare const GenericAuthorization: {
+    encode(message: GenericAuthorization, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenericAuthorization;
+    fromJSON(object: any): GenericAuthorization;
+    toJSON(message: GenericAuthorization): unknown;
+    fromPartial(object: DeepPartial<GenericAuthorization>): GenericAuthorization;
+};
+export declare const Grant: {
+    encode(message: Grant, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Grant;
+    fromJSON(object: any): Grant;
+    toJSON(message: Grant): unknown;
+    fromPartial(object: DeepPartial<Grant>): Grant;
+};
+export declare const GrantAuthorization: {
+    encode(message: GrantAuthorization, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrantAuthorization;
+    fromJSON(object: any): GrantAuthorization;
+    toJSON(message: GrantAuthorization): unknown;
+    fromPartial(object: DeepPartial<GrantAuthorization>): GrantAuthorization;
+};
+export declare const GrantQueueItem: {
+    encode(message: GrantQueueItem, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrantQueueItem;
+    fromJSON(object: any): GrantQueueItem;
+    toJSON(message: GrantQueueItem): unknown;
+    fromPartial(object: DeepPartial<GrantQueueItem>): GrantQueueItem;
+};

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

@@ -0,0 +1,34 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** EventGrant is emitted on Msg/Grant */
+export interface EventGrant {
+    /** Msg type URL for which an autorization is granted */
+    msgTypeUrl: string;
+    /** Granter account address */
+    granter: string;
+    /** Grantee account address */
+    grantee: string;
+}
+/** EventRevoke is emitted on Msg/Revoke */
+export interface EventRevoke {
+    /** Msg type URL for which an autorization is revoked */
+    msgTypeUrl: string;
+    /** Granter account address */
+    granter: string;
+    /** Grantee account address */
+    grantee: string;
+}
+export declare const EventGrant: {
+    encode(message: EventGrant, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventGrant;
+    fromJSON(object: any): EventGrant;
+    toJSON(message: EventGrant): unknown;
+    fromPartial(object: DeepPartial<EventGrant>): EventGrant;
+};
+export declare const EventRevoke: {
+    encode(message: EventRevoke, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EventRevoke;
+    fromJSON(object: any): EventRevoke;
+    toJSON(message: EventRevoke): unknown;
+    fromPartial(object: DeepPartial<EventRevoke>): EventRevoke;
+};

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

@@ -0,0 +1,14 @@
+import { GrantAuthorization } from "./authz";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the authz module's genesis state. */
+export interface GenesisState {
+    authorization: GrantAuthorization[];
+}
+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/authz/v1beta1/query.d.ts

@@ -0,0 +1,88 @@
+import { PageRequest, PageResponse } from "../../base/query/v1beta1/pagination";
+import { Grant, GrantAuthorization } from "./authz";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** QueryGrantsRequest is the request type for the Query/Grants RPC method. */
+export interface QueryGrantsRequest {
+    granter: string;
+    grantee: string;
+    /** Optional, msg_type_url, when set, will query only grants matching given msg type. */
+    msgTypeUrl: string;
+    /** pagination defines an pagination for the request. */
+    pagination: PageRequest;
+}
+/** QueryGrantsResponse is the response type for the Query/Authorizations RPC method. */
+export interface QueryGrantsResponse {
+    /** authorizations is a list of grants granted for grantee by granter. */
+    grants: Grant[];
+    /** pagination defines an pagination for the response. */
+    pagination: PageResponse;
+}
+/** QueryGranterGrantsRequest is the request type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsRequest {
+    granter: string;
+    /** pagination defines an pagination for the request. */
+    pagination: PageRequest;
+}
+/** QueryGranterGrantsResponse is the response type for the Query/GranterGrants RPC method. */
+export interface QueryGranterGrantsResponse {
+    /** grants is a list of grants granted by the granter. */
+    grants: GrantAuthorization[];
+    /** pagination defines an pagination for the response. */
+    pagination: PageResponse;
+}
+/** QueryGranteeGrantsRequest is the request type for the Query/IssuedGrants RPC method. */
+export interface QueryGranteeGrantsRequest {
+    grantee: string;
+    /** pagination defines an pagination for the request. */
+    pagination: PageRequest;
+}
+/** QueryGranteeGrantsResponse is the response type for the Query/GranteeGrants RPC method. */
+export interface QueryGranteeGrantsResponse {
+    /** grants is a list of grants granted to the grantee. */
+    grants: GrantAuthorization[];
+    /** pagination defines an pagination for the response. */
+    pagination: PageResponse;
+}
+export declare const QueryGrantsRequest: {
+    encode(message: QueryGrantsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGrantsRequest;
+    fromJSON(object: any): QueryGrantsRequest;
+    toJSON(message: QueryGrantsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryGrantsRequest>): QueryGrantsRequest;
+};
+export declare const QueryGrantsResponse: {
+    encode(message: QueryGrantsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGrantsResponse;
+    fromJSON(object: any): QueryGrantsResponse;
+    toJSON(message: QueryGrantsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryGrantsResponse>): QueryGrantsResponse;
+};
+export declare const QueryGranterGrantsRequest: {
+    encode(message: QueryGranterGrantsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGranterGrantsRequest;
+    fromJSON(object: any): QueryGranterGrantsRequest;
+    toJSON(message: QueryGranterGrantsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryGranterGrantsRequest>): QueryGranterGrantsRequest;
+};
+export declare const QueryGranterGrantsResponse: {
+    encode(message: QueryGranterGrantsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGranterGrantsResponse;
+    fromJSON(object: any): QueryGranterGrantsResponse;
+    toJSON(message: QueryGranterGrantsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryGranterGrantsResponse>): QueryGranterGrantsResponse;
+};
+export declare const QueryGranteeGrantsRequest: {
+    encode(message: QueryGranteeGrantsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGranteeGrantsRequest;
+    fromJSON(object: any): QueryGranteeGrantsRequest;
+    toJSON(message: QueryGranteeGrantsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryGranteeGrantsRequest>): QueryGranteeGrantsRequest;
+};
+export declare const QueryGranteeGrantsResponse: {
+    encode(message: QueryGranteeGrantsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGranteeGrantsResponse;
+    fromJSON(object: any): QueryGranteeGrantsResponse;
+    toJSON(message: QueryGranteeGrantsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryGranteeGrantsResponse>): QueryGranteeGrantsResponse;
+};

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

@@ -0,0 +1,10 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryGrantsRequest, QueryGrantsResponse, QueryGranterGrantsRequest, QueryGranterGrantsResponse, QueryGranteeGrantsRequest, QueryGranteeGrantsResponse } from "./query";
+export declare class LCDQueryClient extends LCDClient {
+    constructor({ restEndpoint }: {
+        restEndpoint: any;
+    });
+    grants(params: QueryGrantsRequest): Promise<QueryGrantsResponse>;
+    granterGrants(params: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse>;
+    granteeGrants(params: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse>;
+}

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

@@ -0,0 +1,15 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryGrantsRequest, QueryGrantsResponse, QueryGranterGrantsRequest, QueryGranterGrantsResponse, QueryGranteeGrantsRequest, QueryGranteeGrantsResponse } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse>;
+    granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse>;
+    granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    grants(request: QueryGrantsRequest): Promise<QueryGrantsResponse>;
+    granterGrants(request: QueryGranterGrantsRequest): Promise<QueryGranterGrantsResponse>;
+    granteeGrants(request: QueryGranteeGrantsRequest): Promise<QueryGranteeGrantsResponse>;
+}