juno-network 0.0.4 → 0.1.1

package/types/codegen/confio/proofs.d.ts

@@ -1,309 +0,0 @@
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "@osmonauts/helpers";
-export declare enum HashOp {
-    /** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. */
-    NO_HASH = 0,
-    SHA256 = 1,
-    SHA512 = 2,
-    KECCAK = 3,
-    RIPEMD160 = 4,
-    /** BITCOIN - ripemd160(sha256(x)) */
-    BITCOIN = 5,
-    UNRECOGNIZED = -1
-}
-export declare function hashOpFromJSON(object: any): HashOp;
-export declare function hashOpToJSON(object: HashOp): string;
-/**
- * LengthOp defines how to process the key and value of the LeafOp
- * to include length information. After encoding the length with the given
- * algorithm, the length will be prepended to the key and value bytes.
- * (Each one with it's own encoded length)
- */
-export declare enum LengthOp {
-    /** NO_PREFIX - NO_PREFIX don't include any length info */
-    NO_PREFIX = 0,
-    /** VAR_PROTO - VAR_PROTO uses protobuf (and go-amino) varint encoding of the length */
-    VAR_PROTO = 1,
-    /** VAR_RLP - VAR_RLP uses rlp int encoding of the length */
-    VAR_RLP = 2,
-    /** FIXED32_BIG - FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer */
-    FIXED32_BIG = 3,
-    /** FIXED32_LITTLE - FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer */
-    FIXED32_LITTLE = 4,
-    /** FIXED64_BIG - FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer */
-    FIXED64_BIG = 5,
-    /** FIXED64_LITTLE - FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer */
-    FIXED64_LITTLE = 6,
-    /** REQUIRE_32_BYTES - REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output) */
-    REQUIRE_32_BYTES = 7,
-    /** REQUIRE_64_BYTES - REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output) */
-    REQUIRE_64_BYTES = 8,
-    UNRECOGNIZED = -1
-}
-export declare function lengthOpFromJSON(object: any): LengthOp;
-export declare function lengthOpToJSON(object: LengthOp): string;
-/**
- * ExistenceProof takes a key and a value and a set of steps to perform on it.
- * The result of peforming all these steps will provide a "root hash", which can
- * be compared to the value in a header.
- *
- * Since it is computationally infeasible to produce a hash collission for any of the used
- * cryptographic hash functions, if someone can provide a series of operations to transform
- * a given key and value into a root hash that matches some trusted root, these key and values
- * must be in the referenced merkle tree.
- *
- * The only possible issue is maliablity in LeafOp, such as providing extra prefix data,
- * which should be controlled by a spec. Eg. with lengthOp as NONE,
- * prefix = FOO, key = BAR, value = CHOICE
- * and
- * prefix = F, key = OOBAR, value = CHOICE
- * would produce the same value.
- *
- * With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field
- * in the ProofSpec is valuable to prevent this mutability. And why all trees should
- * length-prefix the data before hashing it.
- */
-export interface ExistenceProof {
-    key: Uint8Array;
-    value: Uint8Array;
-    leaf: LeafOp;
-    path: InnerOp[];
-}
-/**
- * NonExistenceProof takes a proof of two neighbors, one left of the desired key,
- * one right of the desired key. If both proofs are valid AND they are neighbors,
- * then there is no valid proof for the given key.
- */
-export interface NonExistenceProof {
-    /** TODO: remove this as unnecessary??? we prove a range */
-    key: Uint8Array;
-    left: ExistenceProof;
-    right: ExistenceProof;
-}
-/** CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages */
-export interface CommitmentProof {
-    exist?: ExistenceProof;
-    nonexist?: NonExistenceProof;
-    batch?: BatchProof;
-    compressed?: CompressedBatchProof;
-}
-/**
- * LeafOp represents the raw key-value data we wish to prove, and
- * must be flexible to represent the internal transformation from
- * the original key-value pairs into the basis hash, for many existing
- * merkle trees.
- *
- * key and value are passed in. So that the signature of this operation is:
- * leafOp(key, value) -> output
- *
- * To process this, first prehash the keys and values if needed (ANY means no hash in this case):
- * hkey = prehashKey(key)
- * hvalue = prehashValue(value)
- *
- * Then combine the bytes, and hash it
- * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue)
- */
-export interface LeafOp {
-    hash: HashOp;
-    prehashKey: HashOp;
-    prehashValue: HashOp;
-    length: LengthOp;
-    /**
-     * prefix is a fixed bytes that may optionally be included at the beginning to differentiate
-     * a leaf node from an inner node.
-     */
-    prefix: Uint8Array;
-}
-/**
- * InnerOp represents a merkle-proof step that is not a leaf.
- * It represents concatenating two children and hashing them to provide the next result.
- *
- * The result of the previous step is passed in, so the signature of this op is:
- * innerOp(child) -> output
- *
- * The result of applying InnerOp should be:
- * output = op.hash(op.prefix || child || op.suffix)
- *
- * where the || operator is concatenation of binary data,
- * and child is the result of hashing all the tree below this step.
- *
- * Any special data, like prepending child with the length, or prepending the entire operation with
- * some value to differentiate from leaf nodes, should be included in prefix and suffix.
- * If either of prefix or suffix is empty, we just treat it as an empty string
- */
-export interface InnerOp {
-    hash: HashOp;
-    prefix: Uint8Array;
-    suffix: Uint8Array;
-}
-/**
- * ProofSpec defines what the expected parameters are for a given proof type.
- * This can be stored in the client and used to validate any incoming proofs.
- *
- * verify(ProofSpec, Proof) -> Proof | Error
- *
- * As demonstrated in tests, if we don't fix the algorithm used to calculate the
- * LeafHash for a given tree, there are many possible key-value pairs that can
- * generate a given hash (by interpretting the preimage differently).
- * We need this for proper security, requires client knows a priori what
- * tree format server uses. But not in code, rather a configuration object.
- */
-export interface ProofSpec {
-    /**
-     * any field in the ExistenceProof must be the same as in this spec.
-     * except Prefix, which is just the first bytes of prefix (spec can be longer)
-     */
-    leafSpec: LeafOp;
-    innerSpec: InnerSpec;
-    /** max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries) */
-    maxDepth: number;
-    /** min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) */
-    minDepth: number;
-}
-/**
- * InnerSpec contains all store-specific structure info to determine if two proofs from a
- * given store are neighbors.
- *
- * This enables:
- *
- * isLeftMost(spec: InnerSpec, op: InnerOp)
- * isRightMost(spec: InnerSpec, op: InnerOp)
- * isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp)
- */
-export interface InnerSpec {
-    /**
-     * Child order is the ordering of the children node, must count from 0
-     * iavl tree is [0, 1] (left then right)
-     * merk is [0, 2, 1] (left, right, here)
-     */
-    childOrder: number[];
-    childSize: number;
-    minPrefixLength: number;
-    maxPrefixLength: number;
-    /** empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0) */
-    emptyChild: Uint8Array;
-    /** hash is the algorithm that must be used for each InnerOp */
-    hash: HashOp;
-}
-/** BatchProof is a group of multiple proof types than can be compressed */
-export interface BatchProof {
-    entries: BatchEntry[];
-}
-/** Use BatchEntry not CommitmentProof, to avoid recursion */
-export interface BatchEntry {
-    exist?: ExistenceProof;
-    nonexist?: NonExistenceProof;
-}
-export interface CompressedBatchProof {
-    entries: CompressedBatchEntry[];
-    lookupInners: InnerOp[];
-}
-/** Use BatchEntry not CommitmentProof, to avoid recursion */
-export interface CompressedBatchEntry {
-    exist?: CompressedExistenceProof;
-    nonexist?: CompressedNonExistenceProof;
-}
-export interface CompressedExistenceProof {
-    key: Uint8Array;
-    value: Uint8Array;
-    leaf: LeafOp;
-    /** these are indexes into the lookup_inners table in CompressedBatchProof */
-    path: number[];
-}
-export interface CompressedNonExistenceProof {
-    /** TODO: remove this as unnecessary??? we prove a range */
-    key: Uint8Array;
-    left: CompressedExistenceProof;
-    right: CompressedExistenceProof;
-}
-export declare const ExistenceProof: {
-    encode(message: ExistenceProof, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): ExistenceProof;
-    fromJSON(object: any): ExistenceProof;
-    toJSON(message: ExistenceProof): unknown;
-    fromPartial(object: DeepPartial<ExistenceProof>): ExistenceProof;
-};
-export declare const NonExistenceProof: {
-    encode(message: NonExistenceProof, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): NonExistenceProof;
-    fromJSON(object: any): NonExistenceProof;
-    toJSON(message: NonExistenceProof): unknown;
-    fromPartial(object: DeepPartial<NonExistenceProof>): NonExistenceProof;
-};
-export declare const CommitmentProof: {
-    encode(message: CommitmentProof, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): CommitmentProof;
-    fromJSON(object: any): CommitmentProof;
-    toJSON(message: CommitmentProof): unknown;
-    fromPartial(object: DeepPartial<CommitmentProof>): CommitmentProof;
-};
-export declare const LeafOp: {
-    encode(message: LeafOp, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): LeafOp;
-    fromJSON(object: any): LeafOp;
-    toJSON(message: LeafOp): unknown;
-    fromPartial(object: DeepPartial<LeafOp>): LeafOp;
-};
-export declare const InnerOp: {
-    encode(message: InnerOp, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): InnerOp;
-    fromJSON(object: any): InnerOp;
-    toJSON(message: InnerOp): unknown;
-    fromPartial(object: DeepPartial<InnerOp>): InnerOp;
-};
-export declare const ProofSpec: {
-    encode(message: ProofSpec, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): ProofSpec;
-    fromJSON(object: any): ProofSpec;
-    toJSON(message: ProofSpec): unknown;
-    fromPartial(object: DeepPartial<ProofSpec>): ProofSpec;
-};
-export declare const InnerSpec: {
-    encode(message: InnerSpec, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): InnerSpec;
-    fromJSON(object: any): InnerSpec;
-    toJSON(message: InnerSpec): unknown;
-    fromPartial(object: DeepPartial<InnerSpec>): InnerSpec;
-};
-export declare const BatchProof: {
-    encode(message: BatchProof, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): BatchProof;
-    fromJSON(object: any): BatchProof;
-    toJSON(message: BatchProof): unknown;
-    fromPartial(object: DeepPartial<BatchProof>): BatchProof;
-};
-export declare const BatchEntry: {
-    encode(message: BatchEntry, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): BatchEntry;
-    fromJSON(object: any): BatchEntry;
-    toJSON(message: BatchEntry): unknown;
-    fromPartial(object: DeepPartial<BatchEntry>): BatchEntry;
-};
-export declare const CompressedBatchProof: {
-    encode(message: CompressedBatchProof, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedBatchProof;
-    fromJSON(object: any): CompressedBatchProof;
-    toJSON(message: CompressedBatchProof): unknown;
-    fromPartial(object: DeepPartial<CompressedBatchProof>): CompressedBatchProof;
-};
-export declare const CompressedBatchEntry: {
-    encode(message: CompressedBatchEntry, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedBatchEntry;
-    fromJSON(object: any): CompressedBatchEntry;
-    toJSON(message: CompressedBatchEntry): unknown;
-    fromPartial(object: DeepPartial<CompressedBatchEntry>): CompressedBatchEntry;
-};
-export declare const CompressedExistenceProof: {
-    encode(message: CompressedExistenceProof, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedExistenceProof;
-    fromJSON(object: any): CompressedExistenceProof;
-    toJSON(message: CompressedExistenceProof): unknown;
-    fromPartial(object: DeepPartial<CompressedExistenceProof>): CompressedExistenceProof;
-};
-export declare const CompressedNonExistenceProof: {
-    encode(message: CompressedNonExistenceProof, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): CompressedNonExistenceProof;
-    fromJSON(object: any): CompressedNonExistenceProof;
-    toJSON(message: CompressedNonExistenceProof): unknown;
-    fromPartial(object: DeepPartial<CompressedNonExistenceProof>): CompressedNonExistenceProof;
-};

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

@@ -1,51 +0,0 @@
-import { Any } from "../../../google/protobuf/any";
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "@osmonauts/helpers";
-/**
- * Config represents the configuration for a Cosmos SDK ABCI app.
- * It is intended that all state machine logic including the version of
- * baseapp and tx handlers (and possibly even Tendermint) that an app needs
- * can be described in a config object. For compatibility, the framework should
- * allow a mixture of declarative and imperative app wiring, however, apps
- * that strive for the maximum ease of maintainability should be able to describe
- * their state machine with a config object alone.
- */
-export interface Config {
-    /** modules are the module configurations for the app. */
-    modules: ModuleConfig[];
-}
-/** ModuleConfig is a module configuration for an app. */
-export interface ModuleConfig {
-    /**
-     * name is the unique name of the module within the app. It should be a name
-     * that persists between different versions of a module so that modules
-     * can be smoothly upgraded to new versions.
-     *
-     * For example, for the module cosmos.bank.module.v1.Module, we may chose
-     * to simply name the module "bank" in the app. When we upgrade to
-     * cosmos.bank.module.v2.Module, the app-specific name "bank" stays the same
-     * and the framework knows that the v2 module should receive all the same state
-     * that the v1 module had. Note: modules should provide info on which versions
-     * they can migrate from in the ModuleDescriptor.can_migration_from field.
-     */
-    name: string;
-    /**
-     * config is the config object for the module. Module config messages should
-     * define a ModuleDescriptor using the cosmos.app.v1alpha1.is_module extension.
-     */
-    config: Any;
-}
-export declare const Config: {
-    encode(message: Config, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): Config;
-    fromJSON(object: any): Config;
-    toJSON(message: Config): unknown;
-    fromPartial(object: DeepPartial<Config>): Config;
-};
-export declare const ModuleConfig: {
-    encode(message: ModuleConfig, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): ModuleConfig;
-    fromJSON(object: any): ModuleConfig;
-    toJSON(message: ModuleConfig): unknown;
-    fromPartial(object: DeepPartial<ModuleConfig>): ModuleConfig;
-};

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

@@ -1,105 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

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