@agoric/cosmic-proto 0.4.1-dev-e077dea.0.e077dea → 0.4.1-dev-f6d536e.0.f6d536e

package/README.md

@@ -196,10 +196,9 @@ yarn publish
 
 Checkout these related projects:
 
-* [@cosmology/telescope](https://github.com/cosmology-tech/telescope) Your Frontend Companion for Building with TypeScript with Cosmos SDK Modules.
+* [@hyperweb/telescope](https://github.com/hyperweb-io/telescope) Your Frontend Companion for Building with TypeScript with Cosmos SDK Modules.
 * [chain-registry](https://github.com/cosmology-tech/chain-registry) Everything from token symbols, logos, and IBC denominations for all assets you want to support in your application.
 * [cosmos-kit](https://github.com/cosmology-tech/cosmos-kit) Experience the convenience of connecting with a variety of web3 wallets through a single, streamlined interface.
 * [create-cosmos-app](https://github.com/cosmology-tech/create-cosmos-app) Set up a modern Cosmos app by running one command.
 * [interchain-ui](https://github.com/cosmology-tech/interchain-ui) The Interchain Design System, empowering developers with a flexible, easy-to-use UI kit.
 * [starship](https://github.com/cosmology-tech/starship) Unified Testing and Development for the Interchain.
-

package/dist/codegen/agoric/bundle.d.ts

@@ -19,6 +19,9 @@ export declare namespace agoric {
         ChunkStateSDKType: typeof _3.ChunkState;
         CoreEvalProposal: {
             typeUrl: "/agoric.swingset.CoreEvalProposal";
+            aminoType: "swingset/CoreEvalProposal";
+            is(o: any): o is _3.CoreEvalProposal;
+            isSDK(o: any): o is _3.CoreEvalProposalSDKType;
             encode(message: _3.CoreEvalProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.CoreEvalProposal;
             fromJSON(object: any): _3.CoreEvalProposal;
@@ -30,6 +33,8 @@ export declare namespace agoric {
         };
         CoreEval: {
             typeUrl: "/agoric.swingset.CoreEval";
+            is(o: any): o is _3.CoreEval;
+            isSDK(o: any): o is _3.CoreEvalSDKType;
             encode(message: _3.CoreEval, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.CoreEval;
             fromJSON(object: any): _3.CoreEval;
@@ -41,6 +46,8 @@ export declare namespace agoric {
         };
         Params: {
             typeUrl: "/agoric.swingset.Params";
+            is(o: any): o is _3.Params;
+            isSDK(o: any): o is _3.ParamsSDKType;
             encode(message: _3.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.Params;
             fromJSON(object: any): _3.Params;
@@ -52,6 +59,8 @@ export declare namespace agoric {
         };
         State: {
             typeUrl: "/agoric.swingset.State";
+            is(o: any): o is _3.State;
+            isSDK(o: any): o is _3.StateSDKType;
             encode(message: _3.State, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.State;
             fromJSON(object: any): _3.State;
@@ -63,6 +72,8 @@ export declare namespace agoric {
         };
         StringBeans: {
             typeUrl: "/agoric.swingset.StringBeans";
+            is(o: any): o is _3.StringBeans;
+            isSDK(o: any): o is _3.StringBeansSDKType;
             encode(message: _3.StringBeans, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.StringBeans;
             fromJSON(object: any): _3.StringBeans;
@@ -74,6 +85,8 @@ export declare namespace agoric {
         };
         PowerFlagFee: {
             typeUrl: "/agoric.swingset.PowerFlagFee";
+            is(o: any): o is _3.PowerFlagFee;
+            isSDK(o: any): o is _3.PowerFlagFeeSDKType;
             encode(message: _3.PowerFlagFee, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.PowerFlagFee;
             fromJSON(object: any): _3.PowerFlagFee;
@@ -85,6 +98,8 @@ export declare namespace agoric {
         };
         QueueSize: {
             typeUrl: "/agoric.swingset.QueueSize";
+            is(o: any): o is _3.QueueSize;
+            isSDK(o: any): o is _3.QueueSizeSDKType;
             encode(message: _3.QueueSize, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.QueueSize;
             fromJSON(object: any): _3.QueueSize;
@@ -96,6 +111,8 @@ export declare namespace agoric {
         };
         UintMapEntry: {
             typeUrl: "/agoric.swingset.UintMapEntry";
+            is(o: any): o is _3.UintMapEntry;
+            isSDK(o: any): o is _3.UintMapEntrySDKType;
             encode(message: _3.UintMapEntry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.UintMapEntry;
             fromJSON(object: any): _3.UintMapEntry;
@@ -107,6 +124,8 @@ export declare namespace agoric {
         };
         Egress: {
             typeUrl: "/agoric.swingset.Egress";
+            is(o: any): o is _3.Egress;
+            isSDK(o: any): o is _3.EgressSDKType;
             encode(message: _3.Egress, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.Egress;
             fromJSON(object: any): _3.Egress;
@@ -118,6 +137,8 @@ export declare namespace agoric {
         };
         SwingStoreArtifact: {
             typeUrl: "/agoric.swingset.SwingStoreArtifact";
+            is(o: any): o is _3.SwingStoreArtifact;
+            isSDK(o: any): o is _3.SwingStoreArtifactSDKType;
             encode(message: _3.SwingStoreArtifact, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.SwingStoreArtifact;
             fromJSON(object: any): _3.SwingStoreArtifact;
@@ -129,6 +150,8 @@ export declare namespace agoric {
         };
         ChunkedArtifact: {
             typeUrl: "/agoric.swingset.ChunkedArtifact";
+            is(o: any): o is _3.ChunkedArtifact;
+            isSDK(o: any): o is _3.ChunkedArtifactSDKType;
             encode(message: _3.ChunkedArtifact, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.ChunkedArtifact;
             fromJSON(object: any): _3.ChunkedArtifact;
@@ -140,6 +163,8 @@ export declare namespace agoric {
         };
         ChunkInfo: {
             typeUrl: "/agoric.swingset.ChunkInfo";
+            is(o: any): o is _3.ChunkInfo;
+            isSDK(o: any): o is _3.ChunkInfoSDKType;
             encode(message: _3.ChunkInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.ChunkInfo;
             fromJSON(object: any): _3.ChunkInfo;
@@ -151,6 +176,8 @@ export declare namespace agoric {
         };
         ChunkedArtifactNode: {
             typeUrl: "/agoric.swingset.ChunkedArtifactNode";
+            is(o: any): o is _3.ChunkedArtifactNode;
+            isSDK(o: any): o is _3.ChunkedArtifactNodeSDKType;
             encode(message: _3.ChunkedArtifactNode, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _3.ChunkedArtifactNode;
             fromJSON(object: any): _3.ChunkedArtifactNode;
@@ -162,6 +189,8 @@ export declare namespace agoric {
         };
         QueryParamsRequest: {
             typeUrl: "/agoric.swingset.QueryParamsRequest";
+            is(o: any): o is _2.QueryParamsRequest;
+            isSDK(o: any): o is _2.QueryParamsRequestSDKType;
             encode(_: _2.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryParamsRequest;
             fromJSON(_: any): _2.QueryParamsRequest;
@@ -173,6 +202,8 @@ export declare namespace agoric {
         };
         QueryParamsResponse: {
             typeUrl: "/agoric.swingset.QueryParamsResponse";
+            is(o: any): o is _2.QueryParamsResponse;
+            isSDK(o: any): o is _2.QueryParamsResponseSDKType;
             encode(message: _2.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryParamsResponse;
             fromJSON(object: any): _2.QueryParamsResponse;
@@ -184,6 +215,8 @@ export declare namespace agoric {
         };
         QueryEgressRequest: {
             typeUrl: "/agoric.swingset.QueryEgressRequest";
+            is(o: any): o is _2.QueryEgressRequest;
+            isSDK(o: any): o is _2.QueryEgressRequestSDKType;
             encode(message: _2.QueryEgressRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryEgressRequest;
             fromJSON(object: any): _2.QueryEgressRequest;
@@ -195,6 +228,8 @@ export declare namespace agoric {
         };
         QueryEgressResponse: {
             typeUrl: "/agoric.swingset.QueryEgressResponse";
+            is(o: any): o is _2.QueryEgressResponse;
+            isSDK(o: any): o is _2.QueryEgressResponseSDKType;
             encode(message: _2.QueryEgressResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryEgressResponse;
             fromJSON(object: any): _2.QueryEgressResponse;
@@ -206,6 +241,8 @@ export declare namespace agoric {
         };
         QueryMailboxRequest: {
             typeUrl: "/agoric.swingset.QueryMailboxRequest";
+            is(o: any): o is _2.QueryMailboxRequest;
+            isSDK(o: any): o is _2.QueryMailboxRequestSDKType;
             encode(message: _2.QueryMailboxRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryMailboxRequest;
             fromJSON(object: any): _2.QueryMailboxRequest;
@@ -217,6 +254,8 @@ export declare namespace agoric {
         };
         QueryMailboxResponse: {
             typeUrl: "/agoric.swingset.QueryMailboxResponse";
+            is(o: any): o is _2.QueryMailboxResponse;
+            isSDK(o: any): o is _2.QueryMailboxResponseSDKType;
             encode(message: _2.QueryMailboxResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryMailboxResponse;
             fromJSON(object: any): _2.QueryMailboxResponse;
@@ -228,6 +267,8 @@ export declare namespace agoric {
         };
         QueryChunkedArtifactStatusRequest: {
             typeUrl: "/agoric.swingset.QueryChunkedArtifactStatusRequest";
+            is(o: any): o is _2.QueryChunkedArtifactStatusRequest;
+            isSDK(o: any): o is _2.QueryChunkedArtifactStatusRequestSDKType;
             encode(message: _2.QueryChunkedArtifactStatusRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryChunkedArtifactStatusRequest;
             fromJSON(object: any): _2.QueryChunkedArtifactStatusRequest;
@@ -239,6 +280,8 @@ export declare namespace agoric {
         };
         QueryChunkedArtifactStatusResponse: {
             typeUrl: "/agoric.swingset.QueryChunkedArtifactStatusResponse";
+            is(o: any): o is _2.QueryChunkedArtifactStatusResponse;
+            isSDK(o: any): o is _2.QueryChunkedArtifactStatusResponseSDKType;
             encode(message: _2.QueryChunkedArtifactStatusResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _2.QueryChunkedArtifactStatusResponse;
             fromJSON(object: any): _2.QueryChunkedArtifactStatusResponse;
@@ -250,6 +293,9 @@ export declare namespace agoric {
         };
         MsgDeliverInbound: {
             typeUrl: "/agoric.swingset.MsgDeliverInbound";
+            aminoType: "swingset/DeliverInbound";
+            is(o: any): o is _1.MsgDeliverInbound;
+            isSDK(o: any): o is _1.MsgDeliverInboundSDKType;
             encode(message: _1.MsgDeliverInbound, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgDeliverInbound;
             fromJSON(object: any): _1.MsgDeliverInbound;
@@ -261,6 +307,8 @@ export declare namespace agoric {
         };
         MsgDeliverInboundResponse: {
             typeUrl: "/agoric.swingset.MsgDeliverInboundResponse";
+            is(o: any): o is _1.MsgDeliverInboundResponse;
+            isSDK(o: any): o is _1.MsgDeliverInboundResponseSDKType;
             encode(_: _1.MsgDeliverInboundResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgDeliverInboundResponse;
             fromJSON(_: any): _1.MsgDeliverInboundResponse;
@@ -272,6 +320,9 @@ export declare namespace agoric {
         };
         MsgWalletAction: {
             typeUrl: "/agoric.swingset.MsgWalletAction";
+            aminoType: "swingset/WalletAction";
+            is(o: any): o is _1.MsgWalletAction;
+            isSDK(o: any): o is _1.MsgWalletActionSDKType;
             encode(message: _1.MsgWalletAction, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgWalletAction;
             fromJSON(object: any): _1.MsgWalletAction;
@@ -283,6 +334,8 @@ export declare namespace agoric {
         };
         MsgWalletActionResponse: {
             typeUrl: "/agoric.swingset.MsgWalletActionResponse";
+            is(o: any): o is _1.MsgWalletActionResponse;
+            isSDK(o: any): o is _1.MsgWalletActionResponseSDKType;
             encode(_: _1.MsgWalletActionResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgWalletActionResponse;
             fromJSON(_: any): _1.MsgWalletActionResponse;
@@ -294,6 +347,9 @@ export declare namespace agoric {
         };
         MsgWalletSpendAction: {
             typeUrl: "/agoric.swingset.MsgWalletSpendAction";
+            aminoType: "swingset/WalletSpendAction";
+            is(o: any): o is _1.MsgWalletSpendAction;
+            isSDK(o: any): o is _1.MsgWalletSpendActionSDKType;
             encode(message: _1.MsgWalletSpendAction, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgWalletSpendAction;
             fromJSON(object: any): _1.MsgWalletSpendAction;
@@ -305,6 +361,8 @@ export declare namespace agoric {
         };
         MsgWalletSpendActionResponse: {
             typeUrl: "/agoric.swingset.MsgWalletSpendActionResponse";
+            is(o: any): o is _1.MsgWalletSpendActionResponse;
+            isSDK(o: any): o is _1.MsgWalletSpendActionResponseSDKType;
             encode(_: _1.MsgWalletSpendActionResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgWalletSpendActionResponse;
             fromJSON(_: any): _1.MsgWalletSpendActionResponse;
@@ -316,6 +374,9 @@ export declare namespace agoric {
         };
         MsgProvision: {
             typeUrl: "/agoric.swingset.MsgProvision";
+            aminoType: "swingset/Provision";
+            is(o: any): o is _1.MsgProvision;
+            isSDK(o: any): o is _1.MsgProvisionSDKType;
             encode(message: _1.MsgProvision, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgProvision;
             fromJSON(object: any): _1.MsgProvision;
@@ -327,6 +388,8 @@ export declare namespace agoric {
         };
         MsgProvisionResponse: {
             typeUrl: "/agoric.swingset.MsgProvisionResponse";
+            is(o: any): o is _1.MsgProvisionResponse;
+            isSDK(o: any): o is _1.MsgProvisionResponseSDKType;
             encode(_: _1.MsgProvisionResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgProvisionResponse;
             fromJSON(_: any): _1.MsgProvisionResponse;
@@ -338,6 +401,9 @@ export declare namespace agoric {
         };
         MsgInstallBundle: {
             typeUrl: "/agoric.swingset.MsgInstallBundle";
+            aminoType: "swingset/InstallBundle";
+            is(o: any): o is _1.MsgInstallBundle;
+            isSDK(o: any): o is _1.MsgInstallBundleSDKType;
             encode(message: _1.MsgInstallBundle, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgInstallBundle;
             fromJSON(object: any): _1.MsgInstallBundle;
@@ -349,6 +415,9 @@ export declare namespace agoric {
         };
         MsgCoreEval: {
             typeUrl: "/agoric.swingset.MsgCoreEval";
+            aminoType: "cosmos-sdk/x/swingset/MsgCoreEval";
+            is(o: any): o is _1.MsgCoreEval;
+            isSDK(o: any): o is _1.MsgCoreEvalSDKType;
             encode(message: _1.MsgCoreEval, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgCoreEval;
             fromJSON(object: any): _1.MsgCoreEval;
@@ -360,6 +429,8 @@ export declare namespace agoric {
         };
         MsgCoreEvalResponse: {
             typeUrl: "/agoric.swingset.MsgCoreEvalResponse";
+            is(o: any): o is _1.MsgCoreEvalResponse;
+            isSDK(o: any): o is _1.MsgCoreEvalResponseSDKType;
             encode(message: _1.MsgCoreEvalResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgCoreEvalResponse;
             fromJSON(object: any): _1.MsgCoreEvalResponse;
@@ -371,6 +442,8 @@ export declare namespace agoric {
         };
         MsgInstallBundleResponse: {
             typeUrl: "/agoric.swingset.MsgInstallBundleResponse";
+            is(o: any): o is _1.MsgInstallBundleResponse;
+            isSDK(o: any): o is _1.MsgInstallBundleResponseSDKType;
             encode(message: _1.MsgInstallBundleResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgInstallBundleResponse;
             fromJSON(object: any): _1.MsgInstallBundleResponse;
@@ -382,6 +455,8 @@ export declare namespace agoric {
         };
         MsgSendChunk: {
             typeUrl: "/agoric.swingset.MsgSendChunk";
+            is(o: any): o is _1.MsgSendChunk;
+            isSDK(o: any): o is _1.MsgSendChunkSDKType;
             encode(message: _1.MsgSendChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgSendChunk;
             fromJSON(object: any): _1.MsgSendChunk;
@@ -393,6 +468,8 @@ export declare namespace agoric {
         };
         MsgSendChunkResponse: {
             typeUrl: "/agoric.swingset.MsgSendChunkResponse";
+            is(o: any): o is _1.MsgSendChunkResponse;
+            isSDK(o: any): o is _1.MsgSendChunkResponseSDKType;
             encode(message: _1.MsgSendChunkResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _1.MsgSendChunkResponse;
             fromJSON(object: any): _1.MsgSendChunkResponse;
@@ -404,6 +481,8 @@ export declare namespace agoric {
         };
         GenesisState: {
             typeUrl: "/agoric.swingset.GenesisState";
+            is(o: any): o is _0.GenesisState;
+            isSDK(o: any): o is _0.GenesisStateSDKType;
             encode(message: _0.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _0.GenesisState;
             fromJSON(object: any): _0.GenesisState;
@@ -415,6 +494,8 @@ export declare namespace agoric {
         };
         SwingStoreExportDataEntry: {
             typeUrl: "/agoric.swingset.SwingStoreExportDataEntry";
+            is(o: any): o is _0.SwingStoreExportDataEntry;
+            isSDK(o: any): o is _0.SwingStoreExportDataEntrySDKType;
             encode(message: _0.SwingStoreExportDataEntry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _0.SwingStoreExportDataEntry;
             fromJSON(object: any): _0.SwingStoreExportDataEntry;
@@ -428,6 +509,8 @@ export declare namespace agoric {
     const vbank: {
         Params: {
             typeUrl: "/agoric.vbank.Params";
+            is(o: any): o is _7.Params;
+            isSDK(o: any): o is _7.ParamsSDKType;
             encode(message: _7.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _7.Params;
             fromJSON(object: any): _7.Params;
@@ -439,6 +522,8 @@ export declare namespace agoric {
         };
         State: {
             typeUrl: "/agoric.vbank.State";
+            is(o: any): o is _7.State;
+            isSDK(o: any): o is _7.StateSDKType;
             encode(message: _7.State, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _7.State;
             fromJSON(object: any): _7.State;
@@ -450,6 +535,8 @@ export declare namespace agoric {
         };
         QueryParamsRequest: {
             typeUrl: "/agoric.vbank.QueryParamsRequest";
+            is(o: any): o is _6.QueryParamsRequest;
+            isSDK(o: any): o is _6.QueryParamsRequestSDKType;
             encode(_: _6.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _6.QueryParamsRequest;
             fromJSON(_: any): _6.QueryParamsRequest;
@@ -461,6 +548,8 @@ export declare namespace agoric {
         };
         QueryParamsResponse: {
             typeUrl: "/agoric.vbank.QueryParamsResponse";
+            is(o: any): o is _6.QueryParamsResponse;
+            isSDK(o: any): o is _6.QueryParamsResponseSDKType;
             encode(message: _6.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _6.QueryParamsResponse;
             fromJSON(object: any): _6.QueryParamsResponse;
@@ -472,6 +561,8 @@ export declare namespace agoric {
         };
         QueryStateRequest: {
             typeUrl: "/agoric.vbank.QueryStateRequest";
+            is(o: any): o is _6.QueryStateRequest;
+            isSDK(o: any): o is _6.QueryStateRequestSDKType;
             encode(_: _6.QueryStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _6.QueryStateRequest;
             fromJSON(_: any): _6.QueryStateRequest;
@@ -483,6 +574,8 @@ export declare namespace agoric {
         };
         QueryStateResponse: {
             typeUrl: "/agoric.vbank.QueryStateResponse";
+            is(o: any): o is _6.QueryStateResponse;
+            isSDK(o: any): o is _6.QueryStateResponseSDKType;
             encode(message: _6.QueryStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _6.QueryStateResponse;
             fromJSON(object: any): _6.QueryStateResponse;
@@ -494,6 +587,8 @@ export declare namespace agoric {
         };
         GenesisState: {
             typeUrl: "/agoric.vbank.GenesisState";
+            is(o: any): o is _4.GenesisState;
+            isSDK(o: any): o is _4.GenesisStateSDKType;
             encode(message: _4.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _4.GenesisState;
             fromJSON(object: any): _4.GenesisState;
@@ -507,6 +602,9 @@ export declare namespace agoric {
     const vibc: {
         MsgSendPacket: {
             typeUrl: "/agoric.vibc.MsgSendPacket";
+            aminoType: "vibc/SendPacket";
+            is(o: any): o is _8.MsgSendPacket;
+            isSDK(o: any): o is _8.MsgSendPacketSDKType;
             encode(message: _8.MsgSendPacket, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _8.MsgSendPacket;
             fromJSON(object: any): _8.MsgSendPacket;
@@ -518,6 +616,8 @@ export declare namespace agoric {
         };
         MsgSendPacketResponse: {
             typeUrl: "/agoric.vibc.MsgSendPacketResponse";
+            is(o: any): o is _8.MsgSendPacketResponse;
+            isSDK(o: any): o is _8.MsgSendPacketResponseSDKType;
             encode(_: _8.MsgSendPacketResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _8.MsgSendPacketResponse;
             fromJSON(_: any): _8.MsgSendPacketResponse;
@@ -531,6 +631,8 @@ export declare namespace agoric {
     const vlocalchain: {
         CosmosTx: {
             typeUrl: "/agoric.vlocalchain.CosmosTx";
+            is(o: any): o is _9.CosmosTx;
+            isSDK(o: any): o is _9.CosmosTxSDKType;
             encode(message: _9.CosmosTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _9.CosmosTx;
             fromJSON(object: any): _9.CosmosTx;
@@ -542,6 +644,8 @@ export declare namespace agoric {
         };
         QueryRequest: {
             typeUrl: "/agoric.vlocalchain.QueryRequest";
+            is(o: any): o is _9.QueryRequest;
+            isSDK(o: any): o is _9.QueryRequestSDKType;
             encode(message: _9.QueryRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _9.QueryRequest;
             fromJSON(object: any): _9.QueryRequest;
@@ -553,6 +657,8 @@ export declare namespace agoric {
         };
         QueryResponse: {
             typeUrl: "/agoric.vlocalchain.QueryResponse";
+            is(o: any): o is _9.QueryResponse;
+            isSDK(o: any): o is _9.QueryResponseSDKType;
             encode(message: _9.QueryResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _9.QueryResponse;
             fromJSON(object: any): _9.QueryResponse;
@@ -564,6 +670,8 @@ export declare namespace agoric {
         };
         QueryResponses: {
             typeUrl: "/agoric.vlocalchain.QueryResponses";
+            is(o: any): o is _9.QueryResponses;
+            isSDK(o: any): o is _9.QueryResponsesSDKType;
             encode(message: _9.QueryResponses, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _9.QueryResponses;
             fromJSON(object: any): _9.QueryResponses;
@@ -577,6 +685,8 @@ export declare namespace agoric {
     const vstorage: {
         Data: {
             typeUrl: "/agoric.vstorage.Data";
+            is(o: any): o is _12.Data;
+            isSDK(o: any): o is _12.DataSDKType;
             encode(message: _12.Data, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _12.Data;
             fromJSON(object: any): _12.Data;
@@ -588,6 +698,8 @@ export declare namespace agoric {
         };
         Children: {
             typeUrl: "/agoric.vstorage.Children";
+            is(o: any): o is _12.Children;
+            isSDK(o: any): o is _12.ChildrenSDKType;
             encode(message: _12.Children, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _12.Children;
             fromJSON(object: any): _12.Children;
@@ -599,6 +711,8 @@ export declare namespace agoric {
         };
         QueryDataRequest: {
             typeUrl: "/agoric.vstorage.QueryDataRequest";
+            is(o: any): o is _11.QueryDataRequest;
+            isSDK(o: any): o is _11.QueryDataRequestSDKType;
             encode(message: _11.QueryDataRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _11.QueryDataRequest;
             fromJSON(object: any): _11.QueryDataRequest;
@@ -610,6 +724,8 @@ export declare namespace agoric {
         };
         QueryDataResponse: {
             typeUrl: "/agoric.vstorage.QueryDataResponse";
+            is(o: any): o is _11.QueryDataResponse;
+            isSDK(o: any): o is _11.QueryDataResponseSDKType;
             encode(message: _11.QueryDataResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _11.QueryDataResponse;
             fromJSON(object: any): _11.QueryDataResponse;
@@ -621,6 +737,8 @@ export declare namespace agoric {
         };
         QueryCapDataRequest: {
             typeUrl: "/agoric.vstorage.QueryCapDataRequest";
+            is(o: any): o is _11.QueryCapDataRequest;
+            isSDK(o: any): o is _11.QueryCapDataRequestSDKType;
             encode(message: _11.QueryCapDataRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _11.QueryCapDataRequest;
             fromJSON(object: any): _11.QueryCapDataRequest;
@@ -632,6 +750,8 @@ export declare namespace agoric {
         };
         QueryCapDataResponse: {
             typeUrl: "/agoric.vstorage.QueryCapDataResponse";
+            is(o: any): o is _11.QueryCapDataResponse;
+            isSDK(o: any): o is _11.QueryCapDataResponseSDKType;
             encode(message: _11.QueryCapDataResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _11.QueryCapDataResponse;
             fromJSON(object: any): _11.QueryCapDataResponse;
@@ -643,6 +763,8 @@ export declare namespace agoric {
         };
         QueryChildrenRequest: {
             typeUrl: "/agoric.vstorage.QueryChildrenRequest";
+            is(o: any): o is _11.QueryChildrenRequest;
+            isSDK(o: any): o is _11.QueryChildrenRequestSDKType;
             encode(message: _11.QueryChildrenRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _11.QueryChildrenRequest;
             fromJSON(object: any): _11.QueryChildrenRequest;
@@ -654,6 +776,8 @@ export declare namespace agoric {
         };
         QueryChildrenResponse: {
             typeUrl: "/agoric.vstorage.QueryChildrenResponse";
+            is(o: any): o is _11.QueryChildrenResponse;
+            isSDK(o: any): o is _11.QueryChildrenResponseSDKType;
             encode(message: _11.QueryChildrenResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _11.QueryChildrenResponse;
             fromJSON(object: any): _11.QueryChildrenResponse;
@@ -665,6 +789,8 @@ export declare namespace agoric {
         };
         GenesisState: {
             typeUrl: "/agoric.vstorage.GenesisState";
+            is(o: any): o is _10.GenesisState;
+            isSDK(o: any): o is _10.GenesisStateSDKType;
             encode(message: _10.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _10.GenesisState;
             fromJSON(object: any): _10.GenesisState;
@@ -676,6 +802,8 @@ export declare namespace agoric {
         };
         DataEntry: {
             typeUrl: "/agoric.vstorage.DataEntry";
+            is(o: any): o is _10.DataEntry;
+            isSDK(o: any): o is _10.DataEntrySDKType;
             encode(message: _10.DataEntry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _10.DataEntry;
             fromJSON(object: any): _10.DataEntry;
@@ -689,6 +817,8 @@ export declare namespace agoric {
     const vtransfer: {
         GenesisState: {
             typeUrl: "/agoric.vtransfer.GenesisState";
+            is(o: any): o is _13.GenesisState;
+            isSDK(o: any): o is _13.GenesisStateSDKType;
             encode(message: _13.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
             decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _13.GenesisState;
             fromJSON(object: any): _13.GenesisState;

package/dist/codegen/agoric/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/codegen/agoric/bundle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEzC,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,8BAA8B,CAAC;AACnD,OAAO,KAAK,GAAG,MAAM,uBAAuB,CAAC;AAC7C,OAAO,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAC;AAC9C,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAC;AAC9C,yBAAiB,MAAM,CAAC;IACf,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKpB,CAAC;IACK,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKjB,CAAC;IACK,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;KAEhB,CAAC;IACK,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEvB,CAAC;IACK,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIpB,CAAC;IACK,MAAM,SAAS;;;;;;;;;;;;KAErB,CAAC;CACH"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/codegen/agoric/bundle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEzC,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,8BAA8B,CAAC;AACnD,OAAO,KAAK,GAAG,MAAM,uBAAuB,CAAC;AAC7C,OAAO,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAC3C,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAC;AAC9C,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAC;AAC9C,yBAAiB,MAAM,CAAC;IACf,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKpB,CAAC;IACK,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKjB,CAAC;IACK,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEhB,CAAC;IACK,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEvB,CAAC;IACK,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIpB,CAAC;IACK,MAAM,SAAS;;;;;;;;;;;;;;KAErB,CAAC;CACH"}

package/dist/codegen/agoric/swingset/genesis.d.ts

@@ -1,7 +1,12 @@
 import { Params, type ParamsSDKType, State, type StateSDKType } from './swingset.js';
 import { BinaryReader, BinaryWriter } from '../../binary.js';
 import { type JsonSafe } from '../../json-safe.js';
-/** The initial or exported state. */
+/**
+ * The initial or exported state.
+ * @name GenesisState
+ * @package agoric.swingset
+ * @see proto type: agoric.swingset.GenesisState
+ */
 export interface GenesisState {
     params: Params;
     state: State;
@@ -12,14 +17,24 @@ export interface GenesisStateProtoMsg {
     typeUrl: '/agoric.swingset.GenesisState';
     value: Uint8Array;
 }
-/** The initial or exported state. */
+/**
+ * The initial or exported state.
+ * @name GenesisStateSDKType
+ * @package agoric.swingset
+ * @see proto type: agoric.swingset.GenesisState
+ */
 export interface GenesisStateSDKType {
     params: ParamsSDKType;
     state: StateSDKType;
     swing_store_export_data: SwingStoreExportDataEntrySDKType[];
     swing_store_export_data_hash: string;
 }
-/** A SwingStore "export data" entry. */
+/**
+ * A SwingStore "export data" entry.
+ * @name SwingStoreExportDataEntry
+ * @package agoric.swingset
+ * @see proto type: agoric.swingset.SwingStoreExportDataEntry
+ */
 export interface SwingStoreExportDataEntry {
     key: string;
     value: string;
@@ -28,13 +43,26 @@ export interface SwingStoreExportDataEntryProtoMsg {
     typeUrl: '/agoric.swingset.SwingStoreExportDataEntry';
     value: Uint8Array;
 }
-/** A SwingStore "export data" entry. */
+/**
+ * A SwingStore "export data" entry.
+ * @name SwingStoreExportDataEntrySDKType
+ * @package agoric.swingset
+ * @see proto type: agoric.swingset.SwingStoreExportDataEntry
+ */
 export interface SwingStoreExportDataEntrySDKType {
     key: string;
     value: string;
 }
+/**
+ * The initial or exported state.
+ * @name GenesisState
+ * @package agoric.swingset
+ * @see proto type: agoric.swingset.GenesisState
+ */
 export declare const GenesisState: {
     typeUrl: "/agoric.swingset.GenesisState";
+    is(o: any): o is GenesisState;
+    isSDK(o: any): o is GenesisStateSDKType;
     encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
     fromJSON(object: any): GenesisState;
@@ -44,8 +72,16 @@ export declare const GenesisState: {
     toProto(message: GenesisState): Uint8Array;
     toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
 };
+/**
+ * A SwingStore "export data" entry.
+ * @name SwingStoreExportDataEntry
+ * @package agoric.swingset
+ * @see proto type: agoric.swingset.SwingStoreExportDataEntry
+ */
 export declare const SwingStoreExportDataEntry: {
     typeUrl: "/agoric.swingset.SwingStoreExportDataEntry";
+    is(o: any): o is SwingStoreExportDataEntry;
+    isSDK(o: any): o is SwingStoreExportDataEntrySDKType;
     encode(message: SwingStoreExportDataEntry, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): SwingStoreExportDataEntry;
     fromJSON(object: any): SwingStoreExportDataEntry;