juno-network 0.0.2

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

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

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

@@ -0,0 +1,13 @@
+import { Rpc } from "@osmonauts/helpers";
+import { MsgSoftwareUpgrade, MsgSoftwareUpgradeResponse, MsgCancelUpgrade, MsgCancelUpgradeResponse } from "./tx";
+/** Msg defines the RPC service */
+export interface Msg {
+    softwareUpgrade(request: MsgSoftwareUpgrade): Promise<MsgSoftwareUpgradeResponse>;
+    cancelUpgrade(request: MsgCancelUpgrade): Promise<MsgCancelUpgradeResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    softwareUpgrade(request: MsgSoftwareUpgrade): Promise<MsgSoftwareUpgradeResponse>;
+    cancelUpgrade(request: MsgCancelUpgrade): Promise<MsgCancelUpgradeResponse>;
+}

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

@@ -0,0 +1,102 @@
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/** Plan specifies information about a planned upgrade and when it should occur. */
+export interface Plan {
+    /**
+     * Sets the name for the upgrade. This name will be used by the upgraded
+     * version of the software to apply any special "on-upgrade" commands during
+     * the first BeginBlock method after the upgrade is applied. It is also used
+     * to detect whether a software version can handle a given upgrade. If no
+     * upgrade handler with this name has been set in the software, it will be
+     * assumed that the software is out-of-date when the upgrade Time or Height is
+     * reached and the software will exit.
+     */
+    name: string;
+    /**
+     * Deprecated: Time based upgrades have been deprecated. Time based upgrade logic
+     * has been removed from the SDK.
+     * If this field is not empty, an error will be thrown.
+     */
+    /** @deprecated */
+    time: Date;
+    /**
+     * The height at which the upgrade must be performed.
+     * Only used if Time is not set.
+     */
+    height: Long;
+    /**
+     * Any application specific upgrade info to be included on-chain
+     * such as a git commit that validators could automatically upgrade to
+     */
+    info: string;
+    /**
+     * Deprecated: UpgradedClientState field has been deprecated. IBC upgrade logic has been
+     * moved to the IBC module in the sub module 02-client.
+     * If this field is not empty, an error will be thrown.
+     */
+    /** @deprecated */
+    upgradedClientState: Any;
+}
+/**
+ * SoftwareUpgradeProposal is a gov Content type for initiating a software
+ * upgrade.
+ * Deprecated: This legacy proposal is deprecated in favor of Msg-based gov
+ * proposals, see MsgSoftwareUpgrade.
+ */
+/** @deprecated */
+export interface SoftwareUpgradeProposal {
+    title: string;
+    description: string;
+    plan: Plan;
+}
+/**
+ * CancelSoftwareUpgradeProposal is a gov Content type for cancelling a software
+ * upgrade.
+ * Deprecated: This legacy proposal is deprecated in favor of Msg-based gov
+ * proposals, see MsgCancelUpgrade.
+ */
+/** @deprecated */
+export interface CancelSoftwareUpgradeProposal {
+    title: string;
+    description: string;
+}
+/**
+ * ModuleVersion specifies a module and its consensus version.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface ModuleVersion {
+    /** name of the app module */
+    name: string;
+    /** consensus version of the app module */
+    version: Long;
+}
+export declare const Plan: {
+    encode(message: Plan, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Plan;
+    fromJSON(object: any): Plan;
+    toJSON(message: Plan): unknown;
+    fromPartial(object: DeepPartial<Plan>): Plan;
+};
+export declare const SoftwareUpgradeProposal: {
+    encode(message: SoftwareUpgradeProposal, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SoftwareUpgradeProposal;
+    fromJSON(object: any): SoftwareUpgradeProposal;
+    toJSON(message: SoftwareUpgradeProposal): unknown;
+    fromPartial(object: DeepPartial<SoftwareUpgradeProposal>): SoftwareUpgradeProposal;
+};
+export declare const CancelSoftwareUpgradeProposal: {
+    encode(message: CancelSoftwareUpgradeProposal, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CancelSoftwareUpgradeProposal;
+    fromJSON(object: any): CancelSoftwareUpgradeProposal;
+    toJSON(message: CancelSoftwareUpgradeProposal): unknown;
+    fromPartial(object: DeepPartial<CancelSoftwareUpgradeProposal>): CancelSoftwareUpgradeProposal;
+};
+export declare const ModuleVersion: {
+    encode(message: ModuleVersion, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ModuleVersion;
+    fromJSON(object: any): ModuleVersion;
+    toJSON(message: ModuleVersion): unknown;
+    fromPartial(object: DeepPartial<ModuleVersion>): ModuleVersion;
+};

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

@@ -0,0 +1,58 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { MsgCreateVestingAccount, MsgCreatePermanentLockedAccount, MsgCreatePeriodicVestingAccount } from "./tx";
+export interface AminoMsgCreateVestingAccount extends AminoMsg {
+    type: "cosmos-sdk/MsgCreateVestingAccount";
+    value: {
+        from_address: string;
+        to_address: string;
+        amount: {
+            denom: string;
+            amount: string;
+        }[];
+        end_time: string;
+        delayed: boolean;
+    };
+}
+export interface AminoMsgCreatePermanentLockedAccount extends AminoMsg {
+    type: "cosmos-sdk/MsgCreatePermanentLockedAccount";
+    value: {
+        from_address: string;
+        to_address: string;
+        amount: {
+            denom: string;
+            amount: string;
+        }[];
+    };
+}
+export interface AminoMsgCreatePeriodicVestingAccount extends AminoMsg {
+    type: "cosmos-sdk/MsgCreatePeriodicVestingAccount";
+    value: {
+        from_address: string;
+        to_address: string;
+        start_time: string;
+        vesting_periods: {
+            length: string;
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+        }[];
+    };
+}
+export declare const AminoConverter: {
+    "/cosmos.vesting.v1beta1.MsgCreateVestingAccount": {
+        aminoType: string;
+        toAmino: ({ fromAddress, toAddress, amount, endTime, delayed }: MsgCreateVestingAccount) => AminoMsgCreateVestingAccount["value"];
+        fromAmino: ({ from_address, to_address, amount, end_time, delayed }: AminoMsgCreateVestingAccount["value"]) => MsgCreateVestingAccount;
+    };
+    "/cosmos.vesting.v1beta1.MsgCreatePermanentLockedAccount": {
+        aminoType: string;
+        toAmino: ({ fromAddress, toAddress, amount }: MsgCreatePermanentLockedAccount) => AminoMsgCreatePermanentLockedAccount["value"];
+        fromAmino: ({ from_address, to_address, amount }: AminoMsgCreatePermanentLockedAccount["value"]) => MsgCreatePermanentLockedAccount;
+    };
+    "/cosmos.vesting.v1beta1.MsgCreatePeriodicVestingAccount": {
+        aminoType: string;
+        toAmino: ({ fromAddress, toAddress, startTime, vestingPeriods }: MsgCreatePeriodicVestingAccount) => AminoMsgCreatePeriodicVestingAccount["value"];
+        fromAmino: ({ from_address, to_address, start_time, vesting_periods }: AminoMsgCreatePeriodicVestingAccount["value"]) => MsgCreatePeriodicVestingAccount;
+    };
+};

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

@@ -0,0 +1,88 @@
+import { Coin } from "../../base/v1beta1/coin";
+import { Period } from "./vesting";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * MsgCreateVestingAccount defines a message that enables creating a vesting
+ * account.
+ */
+export interface MsgCreateVestingAccount {
+    fromAddress: string;
+    toAddress: string;
+    amount: Coin[];
+    endTime: Long;
+    delayed: boolean;
+}
+/** MsgCreateVestingAccountResponse defines the Msg/CreateVestingAccount response type. */
+export interface MsgCreateVestingAccountResponse {
+}
+/**
+ * MsgCreatePermanentLockedAccount defines a message that enables creating a permanent
+ * locked account.
+ */
+export interface MsgCreatePermanentLockedAccount {
+    fromAddress: string;
+    toAddress: string;
+    amount: Coin[];
+}
+/** MsgCreatePermanentLockedAccountResponse defines the Msg/CreatePermanentLockedAccount response type. */
+export interface MsgCreatePermanentLockedAccountResponse {
+}
+/**
+ * MsgCreateVestingAccount defines a message that enables creating a vesting
+ * account.
+ */
+export interface MsgCreatePeriodicVestingAccount {
+    fromAddress: string;
+    toAddress: string;
+    startTime: Long;
+    vestingPeriods: Period[];
+}
+/**
+ * MsgCreateVestingAccountResponse defines the Msg/CreatePeriodicVestingAccount
+ * response type.
+ */
+export interface MsgCreatePeriodicVestingAccountResponse {
+}
+export declare const MsgCreateVestingAccount: {
+    encode(message: MsgCreateVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateVestingAccount;
+    fromJSON(object: any): MsgCreateVestingAccount;
+    toJSON(message: MsgCreateVestingAccount): unknown;
+    fromPartial(object: DeepPartial<MsgCreateVestingAccount>): MsgCreateVestingAccount;
+};
+export declare const MsgCreateVestingAccountResponse: {
+    encode(_: MsgCreateVestingAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateVestingAccountResponse;
+    fromJSON(_: any): MsgCreateVestingAccountResponse;
+    toJSON(_: MsgCreateVestingAccountResponse): unknown;
+    fromPartial(_: DeepPartial<MsgCreateVestingAccountResponse>): MsgCreateVestingAccountResponse;
+};
+export declare const MsgCreatePermanentLockedAccount: {
+    encode(message: MsgCreatePermanentLockedAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePermanentLockedAccount;
+    fromJSON(object: any): MsgCreatePermanentLockedAccount;
+    toJSON(message: MsgCreatePermanentLockedAccount): unknown;
+    fromPartial(object: DeepPartial<MsgCreatePermanentLockedAccount>): MsgCreatePermanentLockedAccount;
+};
+export declare const MsgCreatePermanentLockedAccountResponse: {
+    encode(_: MsgCreatePermanentLockedAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePermanentLockedAccountResponse;
+    fromJSON(_: any): MsgCreatePermanentLockedAccountResponse;
+    toJSON(_: MsgCreatePermanentLockedAccountResponse): unknown;
+    fromPartial(_: DeepPartial<MsgCreatePermanentLockedAccountResponse>): MsgCreatePermanentLockedAccountResponse;
+};
+export declare const MsgCreatePeriodicVestingAccount: {
+    encode(message: MsgCreatePeriodicVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePeriodicVestingAccount;
+    fromJSON(object: any): MsgCreatePeriodicVestingAccount;
+    toJSON(message: MsgCreatePeriodicVestingAccount): unknown;
+    fromPartial(object: DeepPartial<MsgCreatePeriodicVestingAccount>): MsgCreatePeriodicVestingAccount;
+};
+export declare const MsgCreatePeriodicVestingAccountResponse: {
+    encode(_: MsgCreatePeriodicVestingAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePeriodicVestingAccountResponse;
+    fromJSON(_: any): MsgCreatePeriodicVestingAccountResponse;
+    toJSON(_: MsgCreatePeriodicVestingAccountResponse): unknown;
+    fromPartial(_: DeepPartial<MsgCreatePeriodicVestingAccountResponse>): MsgCreatePeriodicVestingAccountResponse;
+};

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

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

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

@@ -0,0 +1,15 @@
+import { Rpc } from "@osmonauts/helpers";
+import { MsgCreateVestingAccount, MsgCreateVestingAccountResponse, MsgCreatePermanentLockedAccount, MsgCreatePermanentLockedAccountResponse, MsgCreatePeriodicVestingAccount, MsgCreatePeriodicVestingAccountResponse } from "./tx";
+/** Msg defines the RPC service */
+export interface Msg {
+    createVestingAccount(request: MsgCreateVestingAccount): Promise<MsgCreateVestingAccountResponse>;
+    createPermanentLockedAccount(request: MsgCreatePermanentLockedAccount): Promise<MsgCreatePermanentLockedAccountResponse>;
+    createPeriodicVestingAccount(request: MsgCreatePeriodicVestingAccount): Promise<MsgCreatePeriodicVestingAccountResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    createVestingAccount(request: MsgCreateVestingAccount): Promise<MsgCreateVestingAccountResponse>;
+    createPermanentLockedAccount(request: MsgCreatePermanentLockedAccount): Promise<MsgCreatePermanentLockedAccountResponse>;
+    createPeriodicVestingAccount(request: MsgCreatePeriodicVestingAccount): Promise<MsgCreatePeriodicVestingAccountResponse>;
+}

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

@@ -0,0 +1,97 @@
+import { BaseAccount } from "../../auth/v1beta1/auth";
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * BaseVestingAccount implements the VestingAccount interface. It contains all
+ * the necessary fields needed for any vesting account implementation.
+ */
+export interface BaseVestingAccount {
+    baseAccount: BaseAccount;
+    originalVesting: Coin[];
+    delegatedFree: Coin[];
+    delegatedVesting: Coin[];
+    endTime: Long;
+}
+/**
+ * ContinuousVestingAccount implements the VestingAccount interface. It
+ * continuously vests by unlocking coins linearly with respect to time.
+ */
+export interface ContinuousVestingAccount {
+    baseVestingAccount: BaseVestingAccount;
+    startTime: Long;
+}
+/**
+ * DelayedVestingAccount implements the VestingAccount interface. It vests all
+ * coins after a specific time, but non prior. In other words, it keeps them
+ * locked until a specified time.
+ */
+export interface DelayedVestingAccount {
+    baseVestingAccount: BaseVestingAccount;
+}
+/** Period defines a length of time and amount of coins that will vest. */
+export interface Period {
+    length: Long;
+    amount: Coin[];
+}
+/**
+ * PeriodicVestingAccount implements the VestingAccount interface. It
+ * periodically vests by unlocking coins during each specified period.
+ */
+export interface PeriodicVestingAccount {
+    baseVestingAccount: BaseVestingAccount;
+    startTime: Long;
+    vestingPeriods: Period[];
+}
+/**
+ * PermanentLockedAccount implements the VestingAccount interface. It does
+ * not ever release coins, locking them indefinitely. Coins in this account can
+ * still be used for delegating and for governance votes even while locked.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface PermanentLockedAccount {
+    baseVestingAccount: BaseVestingAccount;
+}
+export declare const BaseVestingAccount: {
+    encode(message: BaseVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BaseVestingAccount;
+    fromJSON(object: any): BaseVestingAccount;
+    toJSON(message: BaseVestingAccount): unknown;
+    fromPartial(object: DeepPartial<BaseVestingAccount>): BaseVestingAccount;
+};
+export declare const ContinuousVestingAccount: {
+    encode(message: ContinuousVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ContinuousVestingAccount;
+    fromJSON(object: any): ContinuousVestingAccount;
+    toJSON(message: ContinuousVestingAccount): unknown;
+    fromPartial(object: DeepPartial<ContinuousVestingAccount>): ContinuousVestingAccount;
+};
+export declare const DelayedVestingAccount: {
+    encode(message: DelayedVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DelayedVestingAccount;
+    fromJSON(object: any): DelayedVestingAccount;
+    toJSON(message: DelayedVestingAccount): unknown;
+    fromPartial(object: DeepPartial<DelayedVestingAccount>): DelayedVestingAccount;
+};
+export declare const Period: {
+    encode(message: Period, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Period;
+    fromJSON(object: any): Period;
+    toJSON(message: Period): unknown;
+    fromPartial(object: DeepPartial<Period>): Period;
+};
+export declare const PeriodicVestingAccount: {
+    encode(message: PeriodicVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PeriodicVestingAccount;
+    fromJSON(object: any): PeriodicVestingAccount;
+    toJSON(message: PeriodicVestingAccount): unknown;
+    fromPartial(object: DeepPartial<PeriodicVestingAccount>): PeriodicVestingAccount;
+};
+export declare const PermanentLockedAccount: {
+    encode(message: PermanentLockedAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PermanentLockedAccount;
+    fromJSON(object: any): PermanentLockedAccount;
+    toJSON(message: PermanentLockedAccount): unknown;
+    fromPartial(object: DeepPartial<PermanentLockedAccount>): PermanentLockedAccount;
+};

package/types/codegen/cosmos_proto/bundle.d.ts

@@ -0,0 +1,27 @@
+import * as _1 from "./cosmos";
+export declare const cosmos_proto: {
+    scalarTypeFromJSON(object: any): _1.ScalarType;
+    scalarTypeToJSON(object: _1.ScalarType): string;
+    ScalarType: typeof _1.ScalarType;
+    InterfaceDescriptor: {
+        encode(message: _1.InterfaceDescriptor, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _1.InterfaceDescriptor;
+        fromJSON(object: any): _1.InterfaceDescriptor;
+        toJSON(message: _1.InterfaceDescriptor): unknown;
+        fromPartial(object: {
+            name?: string;
+            description?: string;
+        }): _1.InterfaceDescriptor;
+    };
+    ScalarDescriptor: {
+        encode(message: _1.ScalarDescriptor, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _1.ScalarDescriptor;
+        fromJSON(object: any): _1.ScalarDescriptor;
+        toJSON(message: _1.ScalarDescriptor): unknown;
+        fromPartial(object: {
+            name?: string;
+            description?: string;
+            fieldType?: _1.ScalarType[];
+        }): _1.ScalarDescriptor;
+    };
+};

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

@@ -0,0 +1,73 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+export declare enum ScalarType {
+    SCALAR_TYPE_UNSPECIFIED = 0,
+    SCALAR_TYPE_STRING = 1,
+    SCALAR_TYPE_BYTES = 2,
+    UNRECOGNIZED = -1
+}
+export declare function scalarTypeFromJSON(object: any): ScalarType;
+export declare function scalarTypeToJSON(object: ScalarType): string;
+/**
+ * InterfaceDescriptor describes an interface type to be used with
+ * accepts_interface and implements_interface and declared by declare_interface.
+ */
+export interface InterfaceDescriptor {
+    /**
+     * name is the name of the interface. It should be a short-name (without
+     * a period) such that the fully qualified name of the interface will be
+     * package.name, ex. for the package a.b and interface named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the interface and its
+     * purpose.
+     */
+    description: string;
+}
+/**
+ * ScalarDescriptor describes an scalar type to be used with
+ * the scalar field option and declared by declare_scalar.
+ * Scalars extend simple protobuf built-in types with additional
+ * syntax and semantics, for instance to represent big integers.
+ * Scalars should ideally define an encoding such that there is only one
+ * valid syntactical representation for a given semantic meaning,
+ * i.e. the encoding should be deterministic.
+ */
+export interface ScalarDescriptor {
+    /**
+     * name is the name of the scalar. It should be a short-name (without
+     * a period) such that the fully qualified name of the scalar will be
+     * package.name, ex. for the package a.b and scalar named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the scalar and its
+     * encoding format. For instance a big integer or decimal scalar should
+     * specify precisely the expected encoding format.
+     */
+    description: string;
+    /**
+     * field_type is the type of field with which this scalar can be used.
+     * Scalars can be used with one and only one type of field so that
+     * encoding standards and simple and clear. Currently only string and
+     * bytes fields are supported for scalars.
+     */
+    fieldType: ScalarType[];
+}
+export declare const InterfaceDescriptor: {
+    encode(message: InterfaceDescriptor, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): InterfaceDescriptor;
+    fromJSON(object: any): InterfaceDescriptor;
+    toJSON(message: InterfaceDescriptor): unknown;
+    fromPartial(object: DeepPartial<InterfaceDescriptor>): InterfaceDescriptor;
+};
+export declare const ScalarDescriptor: {
+    encode(message: ScalarDescriptor, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ScalarDescriptor;
+    fromJSON(object: any): ScalarDescriptor;
+    toJSON(message: ScalarDescriptor): unknown;
+    fromPartial(object: DeepPartial<ScalarDescriptor>): ScalarDescriptor;
+};